当前位置：首页 > 谈天说地 > 正文内容

OpenCV iOS 图像处理编程入门详细教程

34资源网2022年07月28日 11:01242

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;
}