Mat类对象的分析与应用

1 Mat对象的构造方法

Mat类提供了构造函数、复制构造函数与赋值构造函数来初始化一个对象。下面选取了Opencv中的部分源代码：

 //! default constructor
    Mat();
    //! constructs 2D matrix of the specified size and type
    // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
    Mat(int rows, int cols, int type);
    Mat(Size size, int type);
    //! constucts 2D matrix and fills it with the specified value _s.
    Mat(int rows, int cols, int type, const Scalar& s);
    Mat(Size size, int type, const Scalar& s);

    //! constructs n-dimensional matrix
    Mat(int ndims, const int* sizes, int type);
    Mat(int ndims, const int* sizes, int type, const Scalar& s);

    //! copy constructor
    Mat(const Mat& m);
    //! constructor for matrix headers pointing to user-allocated data
    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);
    Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);

    //! creates a matrix header for a part of the bigger matrix
    Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
    Mat(const Mat& m, const Rect& roi);
    Mat(const Mat& m, const Range* ranges);
    //! converts old-style CvMat to the new matrix; the data is not copied by default
    Mat(const CvMat* m, bool copyData=false);
    //! converts old-style CvMatND to the new matrix; the data is not copied by default
    Mat(const CvMatND* m, bool copyData=false);
    //! converts old-style IplImage to the new matrix; the data is not copied by default
    Mat(const IplImage* img, bool copyData=false);
    //! builds matrix from std::vector with or without copying the data
    template<typename _Tp> explicit Mat(const vector<_Tp>& vec, bool copyData=false);
    //! builds matrix from cv::Vec; the data is copied by default
    template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
    //! builds matrix from cv::Matx; the data is copied by default
    template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
    //! builds matrix from a 2D point
    template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
    //! builds matrix from a 3D point
    template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
    //! builds matrix from comma initializer
    template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);

    //! download data from GpuMat
    explicit Mat(const gpu::GpuMat& m);

    //! destructor - calls release()
    ~Mat();
    //! assignment operators
    Mat& operator = (const Mat& m);
    Mat& operator = (const MatExpr& expr);

我们可以采用上述函数构造Mat对象，如

Mat A, C；   //缺省构造函数，只创建了头部分，没有实际数据
A = imread("1.jpg", CV_LOAD_IMAGE_COLOR);//将图片1数据读入A中
Mat B(A);        //使用复制构造函数使B指向A的数据
C=A;              //使用赋值构造函数使C指向A的数据
Mat D(2,2, CV_8UC3, Scalar(0,0,255))  //利用带参数的构造函数创建对象

Mat对象采用了引用计算的方法，A,C,B只是头不同，但都指向相同的数据，每当复制一个Mat对象的头时，引用计数加1，当清除一个头时，引用计数减1，当引用计数为0时，释放资源。为了复制数据，可以采用Mat类中的clone()和copyTo()方法。

2 用Mat类中的方法处理图像

利用at方法改变图像中每一个位置的像素值

Process(Mat & image)
{
   for(int i=0;i<image.rows;i++)
       for(int j=0;j<image.cols;j++)
       {
         if (image.channels() == 1) 
         { // gray-level image
           image.at<uchar>(j,i)= 255; 
         }
         else if (image.channels() == 3) 
         { // color image
           image.at<cv::Vec3b>(j,i)[0]= 255; 
           image.at<cv::Vec3b>(j,i)[1]= 255; 
           image.at<cv::Vec3b>(j,i)[2]= 255; 
        }
      }
}

利用ptr方法可以进行同样的操作

Process(Mat & image)
{  
   int row=image.rows;
   int cn=image.cols*image.channel();//每一行的数据
   for(int i=0;i<row;i++)
  {
      //得到第i行的地址
     uchar* data= image.ptr<uchar>(j);
     for(int j=0;j<cn;j++)
     {
       data[j]=255;
     }
  }
}

 使用迭代器

Process(Mat & image)
{ 
if (image.channels() == 1) 
   { // gray-level image
      Mat_<uchar>::iterator it=image.begin<uchar>();
      Mat_<uchar>::iterator itend=image.end<uchar>();
      for(;it!=itend;it++)
        *it=255;
   }
   else if (image.channels() == 3) 
   { // color image
     Mat_<Vec3b>::iterator it=image.begin<Vec3b>();
     Mat_<Vec3b>::iterator itend=image.end<Vec3b>();
     for(;it！=itend;it++)
     {
        (*it)[0]=255;
        (*it)[1]=255;
        (*it)[2]=255;
     }
   }
}

利用邻域像素点作处理，如图像的锐化

void sharpen(const cv::Mat &image, cv::Mat &result) 
{
// allocate if necessary
result.create(image.size(), image.type()); 
for (int j= 1; j<image.rows-1; j++) 
{ 
 const uchar* previous= 
 image.ptr<const uchar>(j-1); // 前一行
 const uchar* current= 
 image.ptr<const uchar>(j); // 当前行
 const uchar* next= 
 image.ptr<const uchar>(j+1); // 下一行
 uchar* output= result.ptr<uchar>(j); // 输出行
 for (int i=1; i<image.cols-1; i++) 
{
 *output++= cv::saturate_cast<uchar>(
 5*current[i]-current[i-1]
 -current[i+1]-previous[i]-next[i]); 
}
}
// 将未处理的像素设为0
result.row(0).setTo(cv::Scalar(0));
result.row(result.rows-1).setTo(cv::Scalar(0));
result.col(0).setTo(cv::Scalar(0));
result.col(result.cols-1).setTo(cv::Scalar(0));
}

上述过程实际是利用一个3×3的模板对原始图像作卷积，opencv中的函数filter2D可以实现该过程

void sharpen2D(const cv::Mat &image, cv::Mat &result) 
{
// 创建卷积核
cv::Mat kernel(3,3,CV_32F,cv::Scalar(0));
// 设置卷积核的值
kernel.at<float>(1,1)= 5.0;
kernel.at<float>(0,1)= -1.0;
kernel.at<float>(2,1)= -1.0;
kernel.at<float>(1,0)= -1.0;
kernel.at<float>(1,2)= -1.0;
//实现卷积计算
cv::filter2D(image,result,image.depth(),kernel);
}