OpenCV- iOS 图像处理编程入门

OpenCV简介

OpenCV（Open Source Computer Vision Library） 是一个广受欢迎的开源的跨渠道核算机视觉库，它完成了图画处理和核算机视觉方面的许多通用算法，算法从最基本的滤波到高级的物体检测皆有包括。

多语言接口

OpenCV 运用 C/C++ 开发，一起也供给了 Python、Java、MATLAB 等其他语言的接口。

跨渠道

OpenCV 是跨渠道的，能够在 Windows、Linux、Mac OS、Android、iOS 等操作系统上运转。

应用领域广泛

OpenCV 的应用领域十分广泛，包括图画拼接、图画降噪、产品质检、人机交互、人脸识别、动作识别、动作跟踪、无人驾驶等。OpenCV 还供给了机器学习模块，你能够运用正态贝叶斯、K最近邻、支持向量机、决策树、随机森林、人工神经网络等机器学习算法。

集成OpenCV

1、首先创立一个Xcode 工程， 在Build Settings 设置BuEnable Bitcode 为NO。

2、运用 cocoaPads 配置OpenCV。打开终端，cd到项目的目录，执行pod init 命令初始化工程，创立工程对应的Podfile文件。运用 vim Podfile 增加 pod ‘OpenCV’ ,’~> 4.3.0’，最终执行pod install安装OpenCV。

3、所引用到OpenCV 的类文件，需求将m文件改成.mm,告知编译器有C++。

根底图画容器Mat

图画表明

通常咱们拍照的现实世界中的真实的图画，在转化到电子设备中时，记载的却是图画中的每个点的数值。

一副尺度为A x B的图画，能够用AxB的矩阵来表明，矩阵元素的值表明这个方位上的像素的亮度，一般来说像素值越大表明该点越亮。

一般情况，灰度图用 2 维矩阵表明，五颜六色(多通道)图画用 3 维矩阵(M N 3)表明。关于图画显示来说，目前大部分设备都是用无符号 8 位整数(类型为 CV_8U)表明像素亮度。

图画数据在核算机内存中的存储次序为以图画最左上点(也可能是最左下 点)开端，假如是多通道图画，比方 RGB 图画，则每个 像素用三个字节表明。在 OpenCV 中，RGB 图画的通道次序为 BGR 。

Mat类要害特点及界说

其间要害的特点如下：

/* flag参数中包括许多关于矩阵的信息，如: -Mat 的标识

-数据是否连续 -深度 -通道数目

*/

int flags;

//矩阵的维数，取值应该大于或等于 2

int dims;

//矩阵的行数和列数，假如矩阵超越 2 维，这两个变量的值都为-1

int rows, cols;

//指向数据的指针

uchar* data;

//指向引用计数的指针 //假如数据是由用户分配的，则为 NULL

int* refcount;

Mat界说如下：

class CV_EXPORTS Mat
{
public:
    Mat();
    Mat(int rows, int cols, int type);
    Mat(Size size, int type);
    Mat(int rows, int cols, int type, const Scalar& s);
    Mat(Size size, int type, const Scalar& s);
    Mat(int ndims, const int* sizes, int type);
    Mat(const std::vector<int>& sizes, int type);
    Mat(int ndims, const int* sizes, int type, const Scalar& s);
    Mat(const std::vector<int>& sizes, int type, const Scalar& s);
    Mat(const Mat& m);
    Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
    Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
    .......
    .........................
    ................................
          /*! includes several bit-fields:
         - the magic signature
         - continuity flag
         - depth
         - number of channels
     */
    int flags;
    //! the matrix dimensionality, >= 2
    int dims;
    //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
    int rows, cols;
    //! pointer to the data
    uchar* data;
    //! helper fields used in locateROI and adjustROI
    const uchar* datastart;
    const uchar* dataend;
    const uchar* datalimit;
    //! custom allocator
    MatAllocator* allocator;
    //! and the standard allocator
    static MatAllocator* getStdAllocator();
    static MatAllocator* getDefaultAllocator();
    static void setDefaultAllocator(MatAllocator* allocator);
    //! internal use method: updates the continuity flag
    void updateContinuityFlag();
    //! interaction with UMat
    UMatData* u;
    MatSize size;
    MatStep step;
protected:
    template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
};

创立Mat方针

Mat 是一个十分优秀的图画类，它一起也是一个通用的矩阵类，能够用来创立和操作多维矩阵。有多种方法创立一个 Mat 方针。

关于二维多通道图画，首先要界说其尺度，即行数和列数。然后需求指定存储元素的数据类型以及每个矩阵点的通道数。为此，界说规矩如下：

CV_【位数】【带符号与否】【类型前缀】C【通道数】

例：CV_8UC3：表明运用8位的unsigned char类型，每个像素有三个元素组成三通道。而预先界说的通道数能够多达四个。Scalar 是个short 类型的向量，能运用指定的定制化值来初始化矩阵，它还能够表明色彩。

1、结构函数方法创立Mat

Mat M(5,8, CV_8UC3, Scalar(255,0,0));

创立一个高度为5，宽度为8的图画，图画元素为8位无符号类型，且有3个通道。图画的一切像素值被初始化为（255，0，0）。因 OpenCV 中默认的色彩次序为 BGR，因而这是一个纯蓝色的图画【RGB为：（0，0，255）】

//创立行数为 rows，列数为 col，类型为 type 的图画;
Mat::Mat(int rows, int cols, int type);
//创立巨细为 size，类型为 type 的图画;
Mat::Mat(Size size, int type)
//创立行数为 rows，列数为 col，类型为 type 的图画，并将一切元素初始 化为值 s;
Mat::Mat(int rows, int cols, int type, const Scalar& s);
//创立巨细为 size，类型为 type 的图画，并将一切元素初始化为值 s;
Mat::Mat(Size size, int type, const Scalar& s);

2、使用Create()函数创立Mat

Mat mat;
mat.create(2, 2, CV_8UC3);

常用数据结构和函数

Point类

用于表明点。Point类数据结构表明了二维坐标系下的点，即由其图画坐标x和y指定的2D点。

运用方式如下：

Point point;
point.x=2;
point.y=5;
或
Point point=Point(2,5);

Scalar类

用于表明色彩的。Scalar()表明具有4个元素的数组，在OpenCV中被许多用于传递像素值，如RGB色彩值。RGB色彩值为三个参数，关于Scalar()来说，第四个参数为可选，用不到则无需写出，只写三个参数，则OpenCV会认为咱们就想表明三个参数。

例：

 Scalar scalar=Scalar(0,2,255);

界说的RGB色彩值为：0：蓝色重量，2：绿色重量，255：赤色重量。

Scalar类的源头为Scalar_类，而Scalar_类为Vec4x 的一个变种，常用的Scalar其实便是 Scalar_<double> ，这也是为啥许多函数的参数能够输入Mat，也能够是Scalar。

//Vec 是Matx的一个派生类，一个一维的Matx,和vector很类似。Matx是个轻量级的Mat,必须在运用前规定好巨细。
template<typename _Tp> class Scalar_ : public Vec<_Tp, 4>
{
public:
    //! default constructor
    Scalar_();
    Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
    Scalar_(_Tp v0);
    Scalar_(const Scalar_& s);
    Scalar_(Scalar_&& s) CV_NOEXCEPT;
    Scalar_& operator=(const Scalar_& s);
    Scalar_& operator=(Scalar_&& s) CV_NOEXCEPT;
    template<typename _Tp2, int cn>
    Scalar_(const Vec<_Tp2, cn>& v);
    //! returns a scalar with all elements set to v0
    static Scalar_<_Tp> all(_Tp v0);
    //! conversion to another data type
    template<typename T2> operator Scalar_<T2>() const;
    //! per-element product
    Scalar_<_Tp> mul(const Scalar_<_Tp>& a, double scale=1 ) const;
    //! returns (v0, -v1, -v2, -v3)
    Scalar_<_Tp> conj() const;
    //! returns true iff v1 == v2 == v3 == 0
    bool isReal() const;
};
typedef Scalar_<double> Scalar;

Size类

用于表明尺度。Size类部分源代码如下：

typedef Size_<int> Size2i;
typedef Size_<int64> Size2l;
typedef Size_<float> Size2f;
typedef Size_<double> Size2d;
typedef Size2i Size;

其间Size_是模版类，在此，Size_<int> 表明其类内部的模版所代表的类型为int。意思是：首先给已知的数据类型Size_<int> 起个新名字为Size2i，然后又给已知的数据类型Size2i 起个新名字Size。因而，Size_<int> 、Size2i、Size三个类型名等价。

Size_模版界说如下：

template<typename _Tp> class Size_
{
public:
    typedef _Tp value_type;
    //! default constructor
  //结构函数
    Size_();
    Size_(_Tp _width, _Tp _height);
    Size_(const Size_& sz);
    Size_(Size_&& sz) CV_NOEXCEPT;
    Size_(const Point_<_Tp>& pt);
    Size_& operator = (const Size_& sz);
    Size_& operator = (Size_&& sz) CV_NOEXCEPT;
    //! the area (width*height)
  //区域(width*height)
    _Tp area() const;
    //! aspect ratio (width/height)
    double aspectRatio() const;
    //! true if empty
    bool empty() const;
    //! conversion of another data type.
  //转化为另一种数据类型
    template<typename _Tp2> operator Size_<_Tp2>() const;
     //常用特点，模版类型的宽度和高度
    _Tp width; //!< the width 宽度
    _Tp height; //!< the height高度
};

Size_模版类内部又重载了一些结构函数，运费用最高的结构函数如下：

Size_(_Tp _width, _Tp _height);

于是咱们能够用xx.width和xx.height 来分别表明宽和高。

例：Size(2,3);结构出的Size宽为2，高为3。即 size.width=2， size.height=3。

 Size size=Size(2,3);
 size.width;
 size.height;

Rect类

用于表明矩形。Rect 类的成员变量有x，y，width，height，分别为左上角点点坐标和矩形的宽和高。常用的成员函数有Size(),回来值为Size;area()回来矩形的面积；contains（Point）判别点是否坐落矩形内；inside(Rect)函数判别矩形是否在该矩形内；tl()回来左上角点坐标；br()回来右下角点坐标。如想求两个矩形的交集和并集，可如下这么写：

  Rect rect1=Rect(0,0,100,120);
  Rect rect2=Rect(10,10,100,120);
  Rect rect=rect1|rect2;
  Rect rect3=rect1&rect2;

若想让矩形进行平移或缩放操作，可这样：

  Rect rect=Rect(10,10,100,120);
  Rect rect1=rect+point;
  Rect rect2=rect+size;

cvtColor类

用于色彩空间转化。cvtColor()函数是OpenCV里的色彩空间转化函数，能够完成RGB向HSV 、HSI等色彩空间的转化，能够转化为灰度图画。

cvtColor()函数界说如下：

CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 );

第1个参数src为输入图画，第2个参数dst为输出图画，第3个参数code为色彩空间转化的标识符，第4个参数dstCn为方针图画的通道数，若参数是0，表明方针图画取源图画的通道数。

例：转化源图片为灰度图片

 cvtColor(matInput, grayMat,COLOR_BGR2GRAY);

色彩空间转化标识符在OpenCV 库中的imgproc.hpp 中的ColorConversionCodes 枚举中界说了许多标识符。

/** the color conversion codes
@see @ref imgproc_color_conversions
@ingroup imgproc_color_conversions
 */
enum ColorConversionCodes {
    COLOR_BGR2BGRA     = 0, //!< add alpha channel to RGB or BGR image
    COLOR_RGB2RGBA     = COLOR_BGR2BGRA,
    COLOR_BGRA2BGR     = 1, //!< remove alpha channel from RGB or BGR image
    COLOR_RGBA2RGB     = COLOR_BGRA2BGR,
    COLOR_BGR2RGBA     = 2, //!< convert between RGB and BGR color spaces (with or without alpha channel)
    COLOR_RGB2BGRA     = COLOR_BGR2RGBA,
    COLOR_RGBA2BGR     = 3,
    COLOR_BGRA2RGB     = COLOR_RGBA2BGR,
    ...........
    ...................
    ..............................
        //! Demosaicing with alpha channel
    COLOR_BayerBG2BGRA = 139,
    COLOR_BayerGB2BGRA = 140,
    COLOR_BayerRG2BGRA = 141,
    COLOR_BayerGR2BGRA = 142,
    COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA,
    COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA,
    COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA,
    COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA,
    COLOR_COLORCVT_MAX  = 143
};

图画处理技能

拜访图画中的像素

咱们现已了解到图画矩阵的巨细取决于所用的色彩模型，精确的说取决于所用的通道数。假如是灰度图画，矩阵如下：

c 0	c 1	c …	c m
R 0	0,0	0,1	…	0,m
R 1	1,0	1,1	…	1,m
R …	…,0	…,1	…	…,m
R n	n,0	n,1	n,..	n,m

多通道图来说，矩阵中列会包括多个子列，其子列个数与通道数持平。

例：下面表明RGB 色彩模型的矩阵。

c 0	c 1	c …	c m
R 0	0,0 0,0 0,0	0,1 0,1 0,1	… … …	0,m 0,m 0,m
R 1	1,0 1,0 1,0	1,1 1,1 1,1	… … …	1,m 1,m 1,m
R …	…,0 …,0 …,0	…,1 …,1 …,1	… … …	…,m …,m …,m
R n	n,0 n,0 n,0	n,1 n,1 n,1	n,.. n,.. n,..	n,m n,m n,m

值得注意的是，OpenCV中子列的通道次序是反过来的，是BGR 而不是RGB。

任何图画处理算法，都是从操作每个像素开端的。OpenCV中供给了三种拜访每个像素的方法。

指针拜访：

指针拜访像素使用的是C语言中的操作符[]。这种最快。

//色彩空间减缩
void colorReduce(Mat& matInput,Mat& matoutput,int div){
    //仿制输入图画
    matoutput=matInput.clone();
    int rows=matoutput.rows;//行数，高度
    int cols=matoutput.cols*matoutput.channels();//列数*通道数=每一行元素的个数
    //遍历图画矩阵//宽度
    for (int i=0; i<rows; i++) {//行循环
        uchar *data=matoutput.ptr<uchar>(i);//取出第i行首地址
        for (int j=0; j<cols; j++) {//列循环
            data[j]=data[j]/div*div+div/2;//开端处理每一个像素
        }
    }
}

Mat类中的公有成员变量rows为图画的高度，cols是宽度。channels()函数回来图画的通道数。灰度通道是1，五颜六色通道数为3，含alpha的为4。ptr<uchar>(i)能够得到图画任意行的首地址。ptr是模版函数，回来第i行的首地址。

迭代器iterator：

在迭代法中，仅仅需求获取图画矩阵的begin和end，然后增加迭代从begin到end。将(*it)带星操作符增加到迭代指针前，即可拜访当前指向的内容。相比指针直接拜访可能呈现越界的问题，迭代器肯定是十分安全的方法。

//色彩空间减缩
void colorReduceIterator(Mat& matInput,Mat& matoutput,int div){
    //仿制输入图画
    matoutput=matInput.clone();
    //初始方位迭代器
    Mat_<Vec3b>::iterator it=matoutput.begin<Vec3b>();
    //终止方位的迭代器
    Mat_<Vec3b>::iterator itend =matoutput.end<Vec3b>();
    //遍历图画矩阵
    for (;it!=itend;++it) {
        //处理每一个像素
        (*it)[0]=(*it)[0]/div*div+div/2;
        (*it)[1]=(*it)[1]/div*div+div/2;
        (*it)[2]=(*it)[2]/div*div+div/2;
    }
}

动态地址核算：

运用动态地址来核算操作像素，需配合at方法的colorReduce 函数。这种方法简洁明了。但不是最快。

//色彩空间减缩
void colorReduceVec(Mat& matInput,Mat& matoutput,int div){
    //参数准备
    matoutput=matInput.clone();
    int rows=matoutput.rows;//行数
    int cols=matoutput.cols;//列数
    for (int i=0; i<rows; i++) {
        for (int j=0; j<cols; j++) {//处理每一个像素
            //蓝色通道
            matoutput.at<Vec3b>(i,j)[0]=matoutput.at<Vec3b>(i,j)[0]/div*div+div/2;
             //绿色通道
            matoutput.at<Vec3b>(i,j)[1]=matoutput.at<Vec3b>(i,j)[1]/div*div+div/2;
            //赤色通道
            matoutput.at<Vec3b>(i,j)[2]=matoutput.at<Vec3b>(i,j)[2]/div*div+div/2;
        }
    }
}

at<Vec3b>(i,j)函数能够用来存取图画元素，但是在编译期必须知道图画的数据类型。务必保证指定的数据类型和矩阵中的数据类型相符合，因at方法本身不对任何数据类型进行转化。

五颜六色图画

每个像素由三个部分构成，蓝色通道、绿色通道、赤色通道 【BGR】 。

若带Alpha通道，则每个像素由三个部分构成，蓝色通道、绿色通道、赤色通道 Alpha通道【BGRA】 。

三通道图画

是指具有RGB三种通道的图画，简略来说便是五颜六色图画。R：赤色，G：绿色，B：蓝色。比方赤色为（255，0，0）

四通道图画

是在三通道的根底上加上了一个Alpha通道，Alpha用来衡量一个像素或图画的通明度。比方Alpha为0时，该像素彻底通明，Alpha为255时，该像素是彻底不通明。
一个包括五颜六色图画的Mat，会回来一个由3个8位数组成的向量。OpenCV中将此类型的向量界说为Vec3b,即由3个unsigned char 组成的向量。若带有alpha通道，则会回来一个由4个8位数组成的向量，OpenCV中将此类型的向量界说为为Vec4b。所以咱们能够这样运用：matoutput.at<Vec3b>(i,j)[0]索引值0标明了色彩的通道号为0。代表该点的B重量(蓝色)。

图画置灰

//置灰
-(UIImage *)grayInPutImage:(UIImage *)inputImage{
    cv::Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    cv:: Mat grayMat;
    cv::cvtColor(matInput, grayMat,cv::COLOR_BGR2GRAY);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:grayMat];
    return imag;
}

方框滤波

//方框滤波操作
-(UIImage *)boxFilterInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat boxFilterMat;
    boxFilter(matInput, boxFilterMat, -1,cv::Size(value+1,value+1));
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:boxFilterMat];
    return imag;
}

均值滤波

//均值滤波操作
-(UIImage *)blurInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat blurMat;
    blur(matInput, blurMat, cv::Size(value+1,value+1),cv::Point(-1,-1));
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:blurMat];
    return imag;
}

高斯滤波

//高斯滤波操作
-(UIImage *)gaussianBlurInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat gaussianBlurMat;
    GaussianBlur(matInput, gaussianBlurMat, cv::Size(value*2+1,value*2+1), 0,0);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:gaussianBlurMat];
    return imag;
}

中值滤波

//中值滤波操作
-(UIImage *)medianBlurInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat medianBlurMat;
    medianBlur(matInput, medianBlurMat,value*2+1);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:medianBlurMat];
    return imag;
}

双边滤波

//双边滤波操作
-(UIImage *)bilateralFilterInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat bilateralFilterMat;
    Mat grayMat;
    cvtColor(matInput, grayMat,cv::COLOR_BGR2GRAY);
    bilateralFilter(grayMat, bilateralFilterMat, value, (double)value*2, (double)value/2);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:bilateralFilterMat];
    return imag;
}

腐蚀

//腐蚀操作
- (UIImage *)erodeInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat element;
    element=cv::getStructuringElement(MORPH_RECT, cv::Size(2*value+1,2*value+1),cv::Point(value,value));
    Mat desimg;
    erode(matInput,desimg,element);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:desimg];
    return imag;
}

胀大

//胀大操作
- (UIImage *)dilateInPutImage:(UIImage *)inputImage value:(int)value{
    Mat matInput=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat element;
    element=cv::getStructuringElement(MORPH_RECT, cv::Size(2*value+1,2*value+1),cv::Point(value,value));
    Mat desimg;
    dilate(matInput,desimg,element);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:desimg];
    return imag;
}

边际检测

//边际检测
-(UIImage *)cannyInPutImage:(UIImage *)inputImage value:(int)value{
    if (value==0) {
        return inputImage;
    }
    Mat srcImage=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    Mat destImage;
    destImage.create(srcImage.size(), srcImage.type());
    Mat grayImage;
    cvtColor(srcImage, grayImage, COLOR_BGR2GRAY);
    Mat edge;
    blur(grayImage,edge,cv::Size(value,value));
    Canny(edge, edge, 13, 9 ,3);
    destImage=Scalar::all(0);
    srcImage.copyTo(destImage, edge);
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:destImage];
    return imag;
}

图画对比度和亮度调整

//调整对比度和亮度
-(UIImage *)contrasAndBrightInPutImage:(UIImage *)inputImage alpha:(NSInteger)alpha beta:(NSInteger)beta{
    Mat g_srcImage=[[CVUtil sharedInstance]cvMatFromUIImage:inputImage];
    if(g_srcImage.empty()){
        return nil;
    }
    Mat g_dstImage=Mat::zeros(g_srcImage.size(),g_srcImage.type());
    int height=g_srcImage.rows;
    int width=g_srcImage.cols;
    for (int row=0; row<height; row++) {
        for (int col=0; col<width; col++) {
            for (int c=0; c<4; c++) {//4通道BGRA图画
                g_dstImage.at<Vec4b>(row,col)[c]=saturate_cast<uchar>((alpha*0.01)*(g_srcImage.at<Vec4b>(row,col)[c])+beta);
            }
        }
    }
    UIImage *imag=[[CVUtil sharedInstance]UIImageFromCVMat:g_dstImage];
    return imag;
}

总结

OpenCV 的应用领域十分广泛，关于图画处理、人机交互及机器学习算法感兴趣的能够选择一个方向进行深化的研究。