图形图像处理 - 手写 QQ 说说图片处理效果

OpenCv 的基础学习目前先告一段落了，后面我们要开始手写一些常用的效果，且都是基于 Android 平台的。希望我们有一定的 C++ 和 JNI 基础，如果我们对这块知识有所欠缺，大家不妨看看这个：Android进阶之旅（JNI基础实战）

我们可能会忍不住问，做 android 应用层开发，学习图形图像处理到底有啥好处？首先不知我们是否有在 Glide 中有看到像这样的源码：

  private static final int GIF_HEADER = 0x474946;  private static final int PNG_HEADER = 0x89504E47;  static final int EXIF_MAGIC_NUMBER = 0xFFD8;  @NonNull
  private ImageType getType(Reader reader) throws IOException {    final int firstTwoBytes = reader.getUInt16();    // JPEG.
    if (firstTwoBytes == EXIF_MAGIC_NUMBER) {      return JPEG;
    }    final int firstFourBytes = (firstTwoBytes << 16 & 0xFFFF0000) | (reader.getUInt16() & 0xFFFF);    // PNG.
    if (firstFourBytes == PNG_HEADER) {      // See: http://stackoverflow.com/questions/2057923/how-to-check-a-png-for-grayscale-alpha
      // -color-type
      reader.skip(25 - 4);      int alpha = reader.getByte();      // A RGB indexed PNG can also have transparency. Better safe than sorry!
      return alpha >= 3 ? PNG_A : PNG;
    }    // GIF from first 3 bytes.
    if (firstFourBytes >> 8 == GIF_HEADER) {      return GIF;
    }    // ....... 省略部分代码
    return ImageType.WEBP;
  }

其次学习 opencv 不能只停留在其 api 的调用上，我们必须了解其内部的实现的原理，最好还要能手写实现。最后学习图像图形处理，也有利于我们后面学习音视频的开发，能够帮助我们更加熟悉 NDK 开发，包括我们自己去阅读 android native 层的源码等等，总之好处还是有很多的。

接下来我们就以 QQ 发说说处理图片的效果为例，来手写实现部分效果。有些效果在之前的文章中已有讲到，这里就不再给代码了，我们可以参考：《图形图像处理 - Android 滤镜效果》 搭建 android ndk 开发环境和集成 opencv 大家可以参考：《NDK开发前奏 - 实现支付宝人脸识别功能》。

1. 逆世界和镜像

againstWorld(JNIEnv *env, jclass type, jobject bitmap) {    // bitmap -> mat
    Mat src;
    cv_helper::bitmap2mat(env, bitmap, src);    // 二分之一的位置
    const int middleRows = src.rows >> 1;    // 四分之一的位置
    const int quarterRows = middleRows >> 1;    Mat res(src.size(), src.type());    // 处理下半部分
    for (int rows = 0; rows < middleRows; ++rows) {        for (int cols = 0; cols < src.cols; ++cols) {
            res.at<int>(middleRows + rows, cols) = src.at<int>(quarterRows + rows, cols);
        }
    }    // 处理上半部分
    for (int rows = 0; rows < middleRows; ++rows) {        for (int cols = 0; cols < src.cols; ++cols) {
            res.at<int>(rows, cols) = src.at<int>(src.rows - quarterRows - rows, cols);
        }
    }    // mat -> bitmap
    cv_helper::mat2bitmap(env, res, bitmap);    return bitmap;
}

2. remap 重映射

void remap(Mat &src, Mat &dst, Mat &mapX, Mat &mapY) {    // 有一系列的检测
    dst.create(src.size(), src.type());    for (int rows = 0; rows < dst.rows; ++rows) {        for (int cols = 0; cols < dst.cols; ++cols) {            int r_rows = mapY.at<int>(rows, cols);            int r_cols = mapX.at<int>(rows, cols);
            dst.at<Vec4b>(rows, cols) = src.at<Vec4b>(r_rows, r_cols);
        }
    }
}

remap(JNIEnv *env, jclass type, jobject bitmap) {    // bitmap -> mat
    Mat src;
    cv_helper::bitmap2mat(env, bitmap, src);
    Mat res;    Mat mapX(src.size(), src.type());    Mat mapY(src.size(), src.type());    for (int rows = 0; rows < src.rows; ++rows) {        for (int cols = 0; cols < src.cols; ++cols) {
            mapX.at<int>(rows, cols) = src.cols - cols;
            mapY.at<int>(rows, cols) = src.rows - rows;
        }
    }

    remap(src, res, mapX, mapY);    // mat -> bitmap
    cv_helper::mat2bitmap(env, res, bitmap);    return bitmap;
}

3. resize 插值法

我们经常会将某种尺寸的图像转换为其他尺寸的图像，如果放大或者缩小图片的尺寸，笼统来说的话，可以使用OpenCV为我们提供的如下两种方式：

1. resize函数。这是最直接的方式，

2. pyrUp( )、pyrDown( )函数。即图像金字塔相关的两个函数，对图像进行向上采样，向下采样的操作。

pyrUp、pyrDown 其实和专门用作放大缩小图像尺寸的 resize 在功能上差不多，披着图像金字塔的皮，说白了还是在对图像进行放大和缩小操作。另外需要指出的是，pyrUp、pyrDown 在 OpenCV 的 imgproc 模块中的 Image Filtering 子模块里。而 resize 在 imgproc 模块的 Geometric Image Transformations 子模块里。关于 pyrUp、pyrDown 在 opencv 基础学习中已有详细介绍，这里就不再反复了。

resize( ) 为 OpenCV 中专职调整图像大小的函数。此函数将源图像精确地转换为指定尺寸的目标图像。如果源图像中设置了 ROI（Region Of Interest ，感兴趣区域），那么 resize( ) 函数会对源图像的 ROI 区域进行调整图像尺寸的操作，来输出到目标图像中。若目标图像中已经设置 ROI 区域，不难理解 resize( ) 将会对源图像进行尺寸调整并填充到目标图像的 ROI 中。很多时候，我们并不用考虑第二个参数dst的初始图像尺寸和类型（即直接定义一个Mat类型，不用对其初始化），因为其尺寸和类型可以由 src,dsize,fx 和 fy 这其他的几个参数来确定。可选的方式为：

• INTER_NEAREST - 最近邻插值

• INTER_LINEAR - 线性插值（默认值）

• INTER_AREA - 区域插值（利用像素区域关系的重采样插值）

• INTER_CUBIC –三次样条插值（超过4×4像素邻域内的双三次插值）

• INTER_LANCZOS4 -Lanczos插值（超过8×8像素邻域的Lanczos插值）

1. 最近邻插值
   最简单的图像缩放算法就是最近邻插值。顾名思义，就是将目标图像各点的像素值设为源图像中与其最近的点。算法优点在与简单、速度快。

如下图所示，一个44的图片缩放为88的图片。步骤：

• 生成一张空白的8*8的图片，然后在缩放位置填充原始图片值(可以这么理解)

• 在图片的未填充区域(黑色部分)，填充为原有图片最近的位置的像素值。

  
  

  

  最近邻插值

void resize(Mat src, Mat dst, int nH, int nW) {
    dst.create(nH, nW, src.type());    int oH = src.rows;    int oW = src.cols;    for (int rows = 0; rows < dst.rows; ++rows) {        for (int cols = 0; cols < dst.cols; ++cols) {            int nR = rows * (nH / oH);            int nC = cols * (nW / oW);
            dst.at<Vec4b>(rows, cols) = src.at<Vec4b>(nR, nC);
        }
    }
}

1. 双线性插值法

如果原始图像src的大小是3×3，目标图像dst的大小是4×4，考虑dst中(1,1)点像素对应原始图像像素点的位置为(0.75,0.75)，如果使用最近邻算法来计算，原始图像的位置在浮点数取整后为坐标(0,0)。

上面这样粗暴的计算会丢失很多信息，考虑(0.75,0.75)这个信息，它表示在原始图像中的坐标位置，相比较取(0,0)点，(0.75,0.75)貌似更接近(1,1)点，那如果将最近邻算法中的取整方式改为cvRound（四舍五入）的方式取(1,1)点，同样会有丢的信息，即丢失了“0.25”部分的(0,0)点、(1,0)点和(0,1)点。

可以看到，dst图像上(X,Y)对应到src图像上的点，最好是根据计算出的浮点数坐标，按照百分比各取四周的像素点的部分。
如下图：

双线性插值的原理相类似，这里不写双线性插值计算点坐标的方法，容易把思路带跑偏，直接就按照比率权重的思想考虑。将 ( wWX , hHY ) ( wWX , hHY ) 写成 ( x′ + u , y′ + v ) ( x′ + u , y′ + v ) 的形式，表示将 xx 与yy 中的整数和小数分开表示 uvuv 分别代表小数部分。这样，根据权重比率的思想得到计算公式

(X,Y) = (1 − u) · (1 − v) · (x , y) + (u − 1) · v · ( x , y + 1) + u · (v − 1) · (x + 1 , y) + (u · v) · (x , y)

在实际的代码编写中，会有两个问题，一个是图像会发生偏移，另一个是效率问题。

几何中心对齐：

由于计算的图像是离散坐标系，如果使用 (wWX , hHY) (wWX , hHY) 公式来计算，得到的 (X , Y) 值是错误的比率计算而来的，即 (x + 1 , y)、(x , y + 1)、(x + 1 , y + 1)这三组点中，有可能有几个没有参与到比率运算当中，或者这个插值的比率直接是错误的。 例如，src 图像大小是 a×aa×a，dst 图像的大小是 0.5a×0.5a0.5a×0.5a。

根据原始公式计算(wW , hH) (wW , hH)得到(2 , 2)(2 , 2)（注意这不是表示点坐标，而是 x 和 y 对应的比率）如果要计算 dst 点 (0 , 0) 对应的插值结果，由于 (2 , 2) (2 , 2) 是整数，没有小数，所以最后得到 dst 点在 (0 , 0) (0 , 0) 点的像素值就是src图像上在 (0,0)(0,0)点的值。然而，我们想要的 dst 在 (0,0)(0,0)上的结果是应该是有 (0 , 0) (1 , 0) (0 , 1) (1 , 1) 这四个点各自按照 0.5×0.5 的比率加权的结果。 所以我们要将 dst 上面的点，按照比率 (wW , hH) ( wW , hH) 向右下方向平移0.5个单位。

公式如下：
(x , y) = (XwW + 0.5(wW − 1),YhH + 0.5(hH − 1))
(x , y) = (XwW + 0.5(wW − 1),YhH + 0.5(hH − 1))

运算优化：由计算公式可以得知，在计算每一个dst图像中的像素值时会涉及到大量的浮点数运算，性能不佳。可以考虑将浮点数变换成一个整数，即扩大一定的倍数，运算得到的结果再除以这个倍数。举一个简单的例子，计算 0.25×0.75，可以将 0.25 和 0.75 都乘上 8，得到 2×6=12，结果再除以 8282，这样运算的结果与直接计算浮点数没有差别。

在程序中，没有办法取得一个标准的整数，使得两个相互运算的浮点数都变成类似“2”和”6“一样的标准整数，只能取一个适当的值来尽量的减少误差，在源码当中取值为 211211=2048，即 2 的固定幂数，最后结果可以通过用位移来表示除以一个 2 整次幂数，计算速度会有很大的提高。

//双线性插值void resize(const Mat &src, Mat &dst, Size &dsize, double fx = 0.0, double fy = 0.0){    //获取矩阵大小
    Size ssize = src.size();    //保证矩阵的长宽都大于0
    CV_Assert(ssize.area() > 0);    //如果dsize为(0,0)
    if (!dsize.area()) {        //satureate_cast防止数据溢出
        dsize = Size(saturate_cast<int>(src.cols * fx),
                     saturate_cast<int>(src.rows * fy));

        CV_Assert(dsize.area());
    } else {        //Size中的宽高和mat中的行列是相反的
        fx = (double) dsize.width / src.cols;
        fy = (double) dsize.height / src.rows;
    }

    dst.create(dsize, src.type());    double ifx = 1. / fx;    double ify = 1. / fy;

    uchar *dp = dst.data;
    uchar *sp = src.data;    //宽(列数）
    int iWidthSrc = src.cols;    //高(行数)
    int iHiehgtSrc = src.rows;    int channels = src.channels();    short cbufy[2];    short cbufx[2];    for (int row = 0; row < dst.rows; row++) {        float fy = (float) ((row + 0.5) * ify - 0.5);        //整数部分
        int sy = cvFloor(fy);        //小数部分
        fy -= sy;
        sy = std::min(sy, iHiehgtSrc - 2);
        sy = std::max(0, sy);

        cbufy[0] = cv::saturate_cast<short>((1.f - fy) * 2048);
        cbufy[1] = 2048 - cbufy[0];        for (int col = 0; col < dst.cols; col++) {            float fx = (float) ((col + 0.5) * ifx - 0.5);            int sx = cvFloor(fx);
            fx -= sx;            if (sx < 0) {
                fx = 0, sx = 0;
            }            if (sx >= iWidthSrc - 1) {
                fx = 0, sx = iWidthSrc - 2;
            }

            cbufx[0] = cv::saturate_cast<short>((1.f - fx) * 2048);
            cbufx[1] = 2048 - cbufx[0];            for (int k = 0; k < src.channels(); ++k) {
                dp[(row * dst.cols + col) * channels + k] = (
                        sp[(sy * src.cols + sx) * channels + k] * cbufx[0] * cbufy[0] +
                        sp[((sy + 1) * src.cols + sx) * channels + k] * cbufx[0] *
                        cbufy[1] +
                        sp[(sy * src.cols + (sx + 1)) * channels + k] * cbufx[1] *
                        cbufy[0] +
                        sp[((sy + 1) * src.cols + (sx + 1)) * channels + k] * cbufx[1] *
                        cbufy[1]
                ) >> 22;
            }
        }
    }
}

作者：红橙Darren
链接：https://www.jianshu.com/p/d54e24efbd7b