学习opencv（4）图像和大型数组类型

为了访问二维数组，可以使用指针来指定某一行，这个工作由cv::Mat的成员函数ptr<>()完成，由于at、ptr都是模板函数，所以需要一个类型名进行实例化。函数接收一个整型参数来指示希望指针指向的行，函数将返回一个和矩阵原始数据类型相同的数据指针。

例：mtx.ptr(3) 将返回 mtx的第三行 指向的第一个元素的 第一个通道的指针。

注：有两种方式可以获得一个指向矩阵mtx的数据区域的指针：一种是使用 ptr<>()成员函数，另一种是直接使用数据指针data，然后使用成员数组step来计算地址，更像C语言中的 *** 作（不推荐）。

成员函数isContinuous()将告诉你数组是否被连续的打包，如果是连续的，就饿可以通过获得第一行第一个元素的指针，然后在整个数组中遍历。

迭代器机制

另一种序列存储的方式是使用cv::Mat内嵌的迭代器机制。

用于只读（const）数组的迭代器：cv::MatConstIterator<>

用于非只读（ono-const）数组的迭代器：cv::MatIterator<>

cv::Mat的成员函数begin() && end() 会返回这种类型的对象。

例：使用迭代器计算三通道三维数组中的“最长”元素

int main
{
    int sz[3] = {4, 4, 4};
    cv::Mat m(3, sz, CV_32FC3);
    cv::randu(m, -1.0f, 1.0f);
    
    float max = 0.0f;
    cv::MatConstIterator it = m.begin();
    while(it != m.end())
    {
        len2 = (*it)[0]*(*it)[0]+(*it)[1]*(*it)[1]+(*it)[2]*(*it)[2];
        if (len2 > max)
        {
            max = len2;
        }
        it++;
    }
}

这个迭代器只要求被迭代的数组有相同的几何结构（维度以及每一个维度的范围）。

该迭代器不会返回一个用于迭代的单独元素，而通过返回一堆数组来进行N-ary迭代器 *** 作，这些返回的数组也称为“面”（plane）。一个面表示输入数组有连续内存的部分（一般来说是一维或二维的片段）。

面所包含的内容全部都是从被迭代的多维度数组的内容中分离出来的。

例：按面进行多维数组相加

int main()
{
	int sz[] = { 5, 5, 5 };
	cv::Mat n_mat(3, sz, CV_32FC1);

	cv::RNG rng;
	rng.fill(n_mat, cv::RNG::UNIFORM, 0.f, 1.f);

	const cv::Mat* arrays[] = { &n_mat, 0 };
	cv::Mat my_planes[1];
	cv::NAryMatIterator it(arrays, my_planes);
	
	float s = 0.f;
	int n = 0;
	for (int p = 0; p < it.nplanes; p++, ++it)
	{
		s += cv::sum(it.planes[0])[0];
		n++;
	}

	return EXIT_SUCCESS;
}

面的数量（每一个数组都一样，有相同的几何结构）始终由it.planes所决定。N-ary迭代器包含C风格数组planes,它为每个输入数组保存当前平面的头。

例4-2：使用N-ary将两个数组相加

int main
{
	int sz[] = { 5, 5, 5 };
	cv::Mat n_mat0(3, sz, CV_32FC1);
	cv::Mat n_mat1(3, sz, CV_32FC1);

	cv::RNG rng;
	rng.fill(n_mat0, cv::RNG::UNIFORM, 0.f, 1.f);
	rng.fill(n_mat1, cv::RNG::UNIFORM, 0.f, 1.f);

	const cv::Mat* arrays[] = { &n_mat0, &n_mat1, 0 };

	cv::Mat my_planes[2];
	cv::NAryMatIterator it(arrays, my_planes);

	float s = 0.f;
	int n = 0;
	for (int p = 0; p < it.nplanes; p++, ++it)
	{
		s += cv::sum(it.planes[0])[0];
		s += cv::sum(it.planes[1])[0];
		n++;
	}

	return EXIT_SUCCESS;
}

需要将一个数组的子集作为另一个数组访问，这个子集可能是一行或一列，也可能是原始数组的一个子集。

cv::Mat区块访问

所有的方法都是cv::Mat的成员函数，并且都返回我们所请求的数组的子集。

使用以上函数并没有将数据复制到新的数组中，只是创建一个新的数组头。

"数组"表示一般的cv::Mat的对象，"矩阵"表示作为一个数学对象。

矩阵表达式可用的运算 *** 作

矩阵求逆 *** 作inv（）是一系列矩阵求逆 *** 作的接口。

在Opencv中，有一些 *** 作由溢出的风险，为了处理这种情况，实现了一个称为“饱和转换”的构造。

在进行算术或其他 *** 作时会自动检查是否上溢出和下溢出，这个库函数会将结果值转换为相对最小或者最大的可行值。

模板函数是：cv::saturate_cast<>()，它允许你指定喜欢的类型来转换参数。

例:

uchar &vxy = m0.at(y, x);
vxy = cv::saturate_cast((vxy - 128) * 2 + 128);

cv::Mat类的更多函数成员

cv::SparesMat类在数组非0元素非常少的情况下使用。

OpenCV的稀疏矩阵类cv::SparesMat的函数在很多方面都类似于稠密矩阵类cv::Mat, 它们的定义十分相似，支持大多数相同的 *** 作，并且可以包含相同的数据类型。

稀疏矩阵内部内存为一个hash表，其值为0的元素其实并没有占用内存空间，只存储其值为非零的元素，值为0的元素不占用内存空间，同时为了保证查找速度快 内部使用一个hash表进程存储。

稀疏数组和稠密数组最重要的区别：元素的访问。

稀疏数组提供四种访问机制：cv::SparesMat::ptr(), cv::SparesMat::ref(), cv::SparesMat::value() 和cv::SparesMat::find().

uchar *cv::SparesMat::ptr(int i0, bool createMissing, size_t* hashval = 0);

这个特定版本用于访问一维数组。

参数：
    i0:请求元素的索引
    createMissing：元素是否应该被创建（如果不存在，函数调用时则会创建该元素，并且一个合理的非0指针将指向这个新的元素，如果存在，它将直接返回指向这个元素的指针）
    hashval:cv::SparesMat的诗句存储格式为哈希表，在cv::SparesMat::ptr（）的例子中，如果参数hashval是默认的NULL，哈希key将被计算，如果提供一个key，他将会被使用。

cv::SparesMat::ptr()的变体允许使用两个或三个索引，也有第一个参数是一个整型数组指针的版本（const int* idx）,它要求这个索引的元素数量和被访问的数组的维度一样多。

访问器模板函数cv::SparesMat::ref<>()用于返回一个指向数组中特定元素的引用，允许使用一个、两个或三个索引，或者一个索引数组，并且支持可选的用于查找的哈希值。

a_sparse_mat.ref(i0, i1) += 1.0f;

模板方法cv::SparesMat::value<>()和 cv::SparesMat::ref<>()彼此独立，它将返回一个值而不是返回值的引用，因此这个方法也叫“只读方法”。

访问器函数cv::SparesMat::find<>()返回一个请求对象的指针。cv::SparesMat::find<>()的指针类型是由模板指定的，所以不需要再次转换。

迭代器访问稀疏数组的元素

模板化的迭代器是cv::SparseMatIterator_<>() and cv::SparseMatConstIterator_<>()（const形式的begin（）和end()将返回const的迭代器）。

非模板化的迭代器：cv::SparseMatIterator() and cv::SparseMatConstIterator() ，它们将返回一个非模板的SparseMat::begin() 和 SparseMat::end()

//示例4-3：打印一个系数矩阵中的所有非零元素
int main()
{
	int size[] = {10, 10};
	cv::SparseMat sm(2, size, CV_32F);

	for (int i = 0; i < 10; i++)
	{
		int idx[2];
		idx[0] = size[0] * rand();
		idx[1] = size[1] * rand();

		sm.ref(idx) += 1.0f; 
	}
    
   
	cv::SparseMatConstIterator_ it = sm.begin();
	cv::SparseMatConstIterator_ it_end = sm.end();

	for (; it != it_end; ++it)
	{
		const cv::SparseMat::Node* node = it.node();
		cout << "(" << node->idx[0] << ", " << node->idx[1] << ")" << endl;
	}
	return EXIT_SUCCESS;
}

定义在迭代器中的方法node().node()返回一个指向被迭代其索引指向的系数矩阵的实际数据区域。

稀疏矩阵只保留矩阵中的非零数据，个人理解，不算一个完整矩阵，仅是完整矩阵的非零数据的索引矩阵。

node()将返回一个类型为cv::SparseMat::Node的对象：

struct Node
{
    size_t hashval;
    size_t next;
    int idx[cv::MAX_DIM];
};

这个结构既包含指向对应元素的哈希值的索引（索引是一个int数组）；还包含元素对应的哈希值。

cv::SparseMat中额外的类成员函数

int main()
{
	int i0, i1, x, y;
	cv::Mat m(10, 10, CV_32FC2);
	//访问元素时
	cv::Vec2f(x, y) = m.at(i0, i1);

	//使用模板
	cv::Mat_ m1(10, 10);
	cv::Vec2f(x, y) = m1.at(i0,i1);
	cv::Vec2f(x, y) = m1(i0, i1);

	return EXIT_SUCCESS;
}

//4-4 打印矩阵
template  void print_matrix( const cv::SparseMat_* sm ) {
  cv::SparseMatConstIterator_ it = sm->begin();
  cv::SparseMatConstIterator_ it_end = sm->end();

  for(; it != it_end; ++it) {
    const typename cv::SparseMat_::Node* node = it.node();
    cout <<"( " <idx[0] <<", " <idx[1]
         <<" ) = " <<*it < sm( ndim, size );

  // Create a sparse matrix with a few nonzero elements
  //
  for( int i=0; i<4; i++ ) { // Fill the array
    int idx[2];
    idx[0] = size[0] * rand();
    idx[1] = size[1] * rand();
    sm.ref( idx ) += 1.0f;
  }

  print_matrix( &sm );
}

void calling_function2( void ) {

  int ndim = 2;
  int size[] = {4,4};

  cv::SparseMat sm( ndim, size, CV_32F );

  // Create a sparse matrix with a few nonzero elements
  //
  for( int i=0; i<4; i++ ) { // Fill the array
    int idx[2];
    idx[0] = size[0] * rand();
    idx[1] = size[1] * rand();
    sm.ref( idx ) += 1.0f;
  }

  print_matrix( (cv::SparseMat_*) &sm );
}