cv::SparseMat 类参考

类 SparseMat 表示多维稀疏数值数组。更多...

#include <opencv2/core/mat.hpp>

cv::SparseMat 协作图

类
结构体	Hdr
	稀疏矩阵头文件 更多...
结构体	Node
	稀疏矩阵节点 - 哈希表元素 更多...

公共类型
枚举	{   MAGIC_VAL =0x42FD0000 ,   MAX_DIM =32 ,   HASH_SCALE =0x5bd1e995 ,   HASH_BIT =0x80000000 }
typedef SparseMatConstIterator	const_iterator
typedef SparseMatIterator	iterator

公共成员函数
	SparseMat ()
	各种 SparseMat 构造函数。
	SparseMat (const Mat &m)
	SparseMat (const SparseMat &m)
	SparseMat (int dims, const int *_sizes, int _type)
	~SparseMat ()
	析构函数
void	addref ()
	手动增加头文件的引用计数。
void	assignTo (SparseMat &m, int type=-1) const
int	channels () const
	返回通道数
void	clear ()
	将所有稀疏矩阵元素设置为 0，这意味着清除哈希表。
CV_NODISCARD_STD SparseMat	clone () const
	创建矩阵的完整副本
void	convertTo (Mat &m, int rtype, double alpha=1, double beta=0) const
	将稀疏矩阵转换为密集 n 维矩阵，可选类型转换和缩放。
void	convertTo (SparseMat &m, int rtype, double alpha=1) const
	将所有矩阵元素乘以指定的缩放因子 alpha，并将结果转换为指定的数据类型
void	copyTo (Mat &m) const
	将稀疏矩阵转换为密集矩阵。
void	copyTo (SparseMat &m) const
	将所有数据复制到目标矩阵。m 中所有之前的内容都将被清除
void	create (int dims, const int *_sizes, int _type)
	重新分配稀疏矩阵。
int	depth () const
	返回稀疏矩阵元素的深度
int	dims () const
	返回矩阵维数
size_t	elemSize () const
	将稀疏矩阵转换为旧式表示形式；所有元素都将被复制。
size_t	elemSize1 () const
	返回 elemSize()/channels()
SparseMatIterator	end ()
	返回矩阵末端的稀疏矩阵迭代器
template<typename _Tp >
SparseMatIterator_< _Tp >	end ()
	返回矩阵末端的类型化稀疏矩阵迭代器
SparseMatConstIterator	end () const
	返回矩阵末端的只读稀疏矩阵迭代器
template<typename _Tp >
SparseMatConstIterator_< _Tp >	end () const
	返回矩阵末端的类型化只读稀疏矩阵迭代器
void	erase (const int *idx, size_t *hashval=0)
	删除指定元素（nD 案例）
void	erase (int i0, int i1, int i2, size_t *hashval=0)
	删除指定元素（3D 案例）
void	erase (int i0, int i1, size_t *hashval=0)
	删除指定元素（2D 案例）
size_t	hash (const int *idx) const
	计算元素哈希值（nD 案例）
size_t	hash (int i0) const
	计算元素哈希值（1D 案例）
size_t	hash (int i0, int i1) const
	计算元素哈希值（2D 案例）
size_t	hash (int i0, int i1, int i2) const
	计算元素哈希值（3D 案例）
uchar *	newNode (const int *idx, size_t hashval)
Node *	node (size_t nidx)
const Node *	node (size_t nidx) const
size_t	nzcount () const
	返回非零元素的数量（= 哈希表节点的数量）
SparseMat &	operator= (const Mat &m)
	等效于相应的构造函数
SparseMat &	operator= (const SparseMat &m)
	赋值运算符。这是一个 O(1) 操作，即没有数据被复制
void	release ()
void	removeNode (size_t hidx, size_t nidx, size_t previdx)
void	resizeHashTab (size_t newsize)
const int *	size () const
	返回大小数组，如果矩阵未分配则返回 NULL
int	size (int i) const
	返回第 i 个矩阵维度的尺寸（或 0）
int	type () const
	返回稀疏矩阵元素的类型
template<typename _Tp >
const _Tp &	value (const Node *n) const
	返回稀疏矩阵节点中存储的值
template<typename _Tp >
_Tp &	value (Node *n)
	返回稀疏矩阵节点中存储的值
uchar *	ptr (int i0, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（1D 案例）
uchar *	ptr (int i0, int i1, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（2D 案例）
uchar *	ptr (int i0, int i1, int i2, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（3D 案例）
uchar *	ptr (const int *idx, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（nD 案例）
template<typename _Tp >
_Tp &	ref (int i0, size_t *hashval=0)
	返回指向指定元素的引用（1D 案例）
template<typename _Tp >
_Tp &	ref (int i0, int i1, size_t *hashval=0)
	返回指向指定元素的引用（2D 案例）
template<typename _Tp >
_Tp &	ref (int i0, int i1, int i2, size_t *hashval=0)
	返回指向指定元素的引用（3D 案例）
template<typename _Tp >
_Tp &	ref (const int *idx, size_t *hashval=0)
	返回指向指定元素的引用（nD 案例）
template<typename _Tp >
_Tp	value (int i0, size_t *hashval=0) const
	返回指定元素的值（1D 案例）
template<typename _Tp >
_Tp	value (int i0, int i1, size_t *hashval=0) const
	返回指定元素的值（2D 案例）
template<typename _Tp >
_Tp	value (int i0, int i1, int i2, size_t *hashval=0) const
	返回指定元素的值（3D 案例）
template<typename _Tp >
_Tp	value (const int *idx, size_t *hashval=0) const
	返回指定元素的值（nD 案例）
template<typename _Tp >
const _Tp *	find (int i0, size_t *hashval=0) const
	返回指向指定元素的指针（1D 案例）
template<typename _Tp >
const _Tp *	find (int i0, int i1, size_t *hashval=0) const
	返回指向指定元素的指针（2D 案例）
template<typename _Tp >
const _Tp *	find (int i0, int i1, int i2, size_t *hashval=0) const
	返回指向指定元素的指针（3D 案例）
template<typename _Tp >
const _Tp *	find (const int *idx, size_t *hashval=0) const
	返回指向指定元素的指针（nD 案例）
SparseMatIterator	begin ()
	返回矩阵开头的稀疏矩阵迭代器
template<typename _Tp >
SparseMatIterator_< _Tp >	begin ()
	返回矩阵开头的稀疏矩阵迭代器
SparseMatConstIterator	begin () const
	返回矩阵开头的只读稀疏矩阵迭代器
template<typename _Tp >
SparseMatConstIterator_< _Tp >	begin () const
	返回矩阵开头的只读稀疏矩阵迭代器

公共属性
int	flags
Hdr *	hdr

详细描述

类 SparseMat 表示多维稀疏数值数组。

这种稀疏数组可以存储 Mat 可以存储的任何类型的元素。稀疏意味着只存储非零元素（尽管，由于对稀疏矩阵的操作，它的一些存储元素实际上可能变为 0。由您来检测这些元素并使用 SparseMat::erase 删除它们）。非零元素存储在一个哈希表中，当哈希表被填满时会增长，因此平均搜索时间为 O(1)（无论元素是否存在）。可以使用以下方法访问元素

• 查询操作（SparseMat::ptr 和更高级别的 SparseMat::ref，SparseMat::value 和 SparseMat::find），例如

  const int dims = 5;
  int size[5] = {10, 10, 10, 10, 10};
  SparseMat sparse_mat(dims, size, CV_32F);
  for(int i = 0; i < 1000; i++)
  {
      int idx[dims];
      for(int k = 0; k < dims; k++)
  idx[k] = rand() % size[k];
  sparse_mat.ref<float>(idx) += 1.f;
  }
  cout << "nnz = " << sparse_mat.nzcount() << endl;

• 稀疏矩阵迭代器。它们类似于 MatIterator 但不同于 NAryMatIterator。也就是说，迭代循环对于 STL 用户来说很熟悉

  // 打印稀疏浮点数矩阵的元素
  // 和元素的总和。
  SparseMatConstIterator_<float>
  it = sparse_mat.begin<float>(),
  it_end = sparse_mat.end<float>();
  double s = 0;
  int dims = sparse_mat.dims();
  for(; it != it_end; ++it)
  {
      // 打印元素索引和元素值
      const SparseMat::Node* n = it.node();
  printf("(");
      for(int i = 0; i < dims; i++)
  printf("%d%s", n->idx[i], i < dims-1 ? ", " : ")");
  printf(": %g\n", it.value<float>());
  s += *it;
  }
  printf("Element sum is %g\n", s);

  如果您运行此循环，您会注意到元素不是按逻辑顺序枚举的（字典序等）。它们以它们在哈希表中存储的相同顺序出现（半随机）。您可以收集指向节点的指针并对它们进行排序以获得正确的排序。但是请注意，当您向矩阵添加更多元素时，指向节点的指针可能会失效。这可能是由于可能的缓冲区重新分配造成的。
• 当您需要同时处理两个或多个稀疏矩阵时，这两种方法的组合。例如，您可以使用以下方法计算两个浮点稀疏矩阵的未归一化互相关

  double cross_corr(const SparseMat& a, const SparseMat& b)
  {
      const SparseMat *_a = &a, *_b = &b;
      // 如果 b 包含的元素少于 a，
      // 遍历 b 更快
      if(_a->nzcount() > _b->nzcount())
  std::swap(_a, _b);
      SparseMatConstIterator_<float> it = _a->begin<float>(),
  it_end = _a->end<float>();
      double ccorr = 0;
      for(; it != it_end; ++it)
      {
          // 从第一个矩阵中获取下一个元素
          float avalue = *it;
          const Node* anode = it.node();
          // 尝试在第二个矩阵中找到具有相同索引的元素。
          // 由于哈希值仅取决于元素索引，
          // 重用存储在节点中的哈希值
          float bvalue = _b->value<float>(anode->idx,&anode->hashval);
  ccorr += avalue*bvalue;
      }
      return ccorr;
  }

成员类型定义文档

const_iterator

typedef SparseMatConstIterator cv::SparseMat::const_iterator

iterator

typedef SparseMatIterator cv::SparseMat::iterator

成员枚举文档

匿名枚举

匿名枚举

枚举值
MAGIC_VAL
MAX_DIM
HASH_SCALE
HASH_BIT

构造函数和析构函数文档

SparseMat() [1/4]

cv::SparseMat::SparseMat

(

)

各种 SparseMat 构造函数。

SparseMat() [2/4]

cv::SparseMat::SparseMat	(	int	dims,
		const int *	_sizes,
		int	_type
	)

这是一个重载的成员函数，为了方便起见提供。它与上面的函数的不同之处仅在于它接受的参数。

参数

dims	数组维数。
_sizes	所有维度上的稀疏矩阵大小。
_type	稀疏矩阵数据类型。

SparseMat() [3/4]

cv::SparseMat::SparseMat

(

const SparseMat &

m

)

这是一个重载的成员函数，为了方便起见提供。它与上面的函数的不同之处仅在于它接受的参数。

参数

m	复制构造函数的源矩阵。如果 m 是密集矩阵（ocvMat），那么它将被转换为稀疏表示。

SparseMat() [4/4]

cv::SparseMat::SparseMat ( const Mat &  m )

explicit

这是一个重载的成员函数，为了方便起见提供。它与上面的函数的不同之处仅在于它接受的参数。

参数

m	复制构造函数的源矩阵。如果 m 是密集矩阵（ocvMat），那么它将被转换为稀疏表示。

~SparseMat()

cv::SparseMat::~SparseMat

(

)

析构函数

成员函数文档

addref()

void cv::SparseMat::addref

(

)

手动增加头文件的引用计数。

assignTo()

void cv::SparseMat::assignTo	(	SparseMat &	m,
		int	type = -1
	)		const

begin() [1/4]

SparseMatIterator cv::SparseMat::begin

(

)

返回矩阵开头的稀疏矩阵迭代器

返回指向第一个稀疏矩阵元素的稀疏矩阵迭代器

begin() [2/4]

template<typename _Tp >

SparseMatIterator_< _Tp > cv::SparseMat::begin

(

)

返回矩阵开头的稀疏矩阵迭代器

begin() [3/4]

SparseMatConstIterator cv::SparseMat::begin

(

)

const

返回矩阵开头的只读稀疏矩阵迭代器

begin() [4/4]

template<typename _Tp >

SparseMatConstIterator_< _Tp > cv::SparseMat::begin

(

)

const

返回矩阵开头的只读稀疏矩阵迭代器

channels()

int cv::SparseMat::channels

(

)

const

返回通道数

clear()

void cv::SparseMat::clear

(

)

将所有稀疏矩阵元素设置为 0，这意味着清除哈希表。

clone()

CV_NODISCARD_STD SparseMat cv::SparseMat::clone

(

)

const

创建矩阵的完整副本

convertTo() [1/2]

void cv::SparseMat::convertTo	(	Mat &	m,
		int	rtype,
		double	alpha = 1,
		double	beta = 0
	)		const

将稀疏矩阵转换为密集 n 维矩阵，可选类型转换和缩放。

参数

[out]	m	- 输出矩阵；如果在操作之前没有适当的大小或类型，则重新分配
[in]	rtype	- 期望的输出矩阵类型，或者更确切地说是深度，因为通道数与输入相同；如果 rtype 为负，则输出矩阵将与输入具有相同的类型。
[in]	alpha	- 可选的缩放因子
[in]	beta	- 可选的添加到缩放值的增量

convertTo() [2/2]

void cv::SparseMat::convertTo	(	SparseMat &	m,
		int	rtype,
		double	alpha = 1
	)		const

将所有矩阵元素乘以指定的缩放因子 alpha，并将结果转换为指定的数据类型

copyTo() [1/2]

void cv::SparseMat::copyTo

(

Mat &

m

)

const

将稀疏矩阵转换为密集矩阵。

copyTo() [2/2]

void cv::SparseMat::copyTo

(

SparseMat &

m

)

const

将所有数据复制到目标矩阵。m 中所有之前的内容都将被清除

create()

void cv::SparseMat::create	(	int	dims,
		const int *	_sizes,
		int	_type
	)

重新分配稀疏矩阵。

如果矩阵已经具有适当的大小和类型，则它将简单地使用 clear() 清除，否则，旧矩阵将被释放（使用 release()），并分配新的矩阵。

depth()

int cv::SparseMat::depth

(

)

const

返回稀疏矩阵元素的深度

dims()

int cv::SparseMat::dims

(

)

const

返回矩阵维数

elemSize()

size_t cv::SparseMat::elemSize

(

)

const

将稀疏矩阵转换为旧式表示形式；所有元素都将被复制。

返回每个元素的大小（以字节为单位）（不包括开销 - SparseMat::Node 元素占用的空间）

elemSize1()

size_t cv::SparseMat::elemSize1

(

)

const

返回 elemSize()/channels()

end() [1/4]

SparseMatIterator cv::SparseMat::end

(

)

返回矩阵末端的稀疏矩阵迭代器

返回指向最后一个稀疏矩阵元素后的元素的稀疏矩阵迭代器

end() [2/4]

template<typename _Tp >

SparseMatIterator_< _Tp > cv::SparseMat::end

(

)

返回矩阵末端的类型化稀疏矩阵迭代器

end() [3/4]

SparseMatConstIterator cv::SparseMat::end

(

)

const

返回矩阵末端的只读稀疏矩阵迭代器

end() [4/4]

template<typename _Tp >

SparseMatConstIterator_< _Tp > cv::SparseMat::end

(

)

const

返回矩阵末端的类型化只读稀疏矩阵迭代器

erase() [1/3]

void cv::SparseMat::erase	(	const int *	idx,
		size_t *	hashval = 0
	)

删除指定元素（nD 案例）

erase() [2/3]

void cv::SparseMat::erase	(	int	i0,
		int	i1,
		int	i2,
		size_t *	hashval = 0
	)

删除指定元素（3D 案例）

erase() [3/3]

void cv::SparseMat::erase	(	int	i0,
		int	i1,
		size_t *	hashval = 0
	)

删除指定元素（2D 案例）

find() [1/4]

template<typename _Tp >

const _Tp * cv::SparseMat::find	(	const int *	idx,
		size_t *	hashval = 0
	)		const

返回指向指定元素的指针（nD 案例）

find() [2/4]

template<typename _Tp >

const _Tp * cv::SparseMat::find	(	int	i0,
		int	i1,
		int	i2,
		size_t *	hashval = 0
	)		const

返回指向指定元素的指针（3D 案例）

find() [3/4]

template<typename _Tp >

const _Tp * cv::SparseMat::find	(	int	i0,
		int	i1,
		size_t *	hashval = 0
	)		const

返回指向指定元素的指针（2D 案例）

find() [4/4]

template<typename _Tp >

const _Tp * cv::SparseMat::find	(	int	i0,
		size_t *	hashval = 0
	)		const

返回指向指定元素的指针（1D 案例）

如果存在，返回指向指定稀疏矩阵元素的指针

find<_Tp>(i0,...[,hashval]) 等效于 (_const Tp*)ptr(i0,...false[,hashval])。

如果指定的元素不存在，则方法返回 NULL。

hash() [1/4]

size_t cv::SparseMat::hash

(

const int *

idx

)

const

计算元素哈希值（nD 案例）

hash() [2/4]

size_t cv::SparseMat::hash

(

int

i0

)

const

计算元素哈希值（1D 案例）

hash() [3/4]

size_t cv::SparseMat::hash	(	int	i0,
		int	i1
	)		const

计算元素哈希值（2D 案例）

hash() [4/4]

size_t cv::SparseMat::hash	(	int	i0,
		int	i1,
		int	i2
	)		const

计算元素哈希值（3D 案例）

newNode()

uchar * cv::SparseMat::newNode	(	const int *	idx,
		size_t	hashval
	)

node() [1/2]

Node * cv::SparseMat::node

(

size_t

nidx

)

node() [2/2]

const Node * cv::SparseMat::node

(

size_t

nidx

)

const

nzcount()

size_t cv::SparseMat::nzcount

(

)

const

返回非零元素的数量（= 哈希表节点的数量）

operator=() [1/2]

SparseMat & cv::SparseMat::operator=

(

const Mat &

m

)

等效于相应的构造函数

operator=() [2/2]

SparseMat & cv::SparseMat::operator=

(

const SparseMat &

m

)

赋值运算符。这是一个 O(1) 操作，即没有数据被复制

ptr() [1/4]

uchar * cv::SparseMat::ptr	(	const int *	idx,
		bool	createMissing,
		size_t *	hashval = 0
	)

返回指向指定元素的指针（nD 案例）

ptr() [2/4]

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

返回指向指定元素的指针（1D 案例）

1D、2D、3D 案例的专用变体和 n-D 案例的泛型类型变体。返回指向矩阵元素的指针。

• 如果元素存在（它是非零的），则返回指向它的指针
• 如果它不存在且 createMissing=false，则返回 NULL 指针
• 如果它不存在且 createMissing=true，则创建新的元素并将其初始化为 0。返回指向它的指针
• 如果可选的 hashval 指针不为空，则不会计算元素哈希值，而是使用 *hashval。

ptr() [3/4]

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

返回指向指定元素的指针（2D 案例）

ptr() [4/4]

uchar * cv::SparseMat::ptr	(	int	i0,
		int	i1,
		int	i2,
		bool	createMissing,
		size_t *	hashval = 0
	)

返回指向指定元素的指针（3D 案例）

ref() [1/4]

template<typename _Tp >

_Tp & cv::SparseMat::ref	(	const int *	idx,
		size_t *	hashval = 0
	)

返回指向指定元素的引用（nD 案例）

ref() [2/4]

template<typename _Tp >

_Tp & cv::SparseMat::ref	(	int	i0,
		int	i1,
		int	i2,
		size_t *	hashval = 0
	)

返回指向指定元素的引用（3D 案例）

ref() [3/4]

template<typename _Tp >

_Tp & cv::SparseMat::ref	(	int	i0,
		int	i1,
		size_t *	hashval = 0
	)

返回指向指定元素的引用（2D 案例）

ref() [4/4]

template<typename _Tp >

_Tp & cv::SparseMat::ref	(	int	i0,
		size_t *	hashval = 0
	)

返回指向指定元素的引用（1D 案例）

返回指向指定稀疏矩阵元素的读写引用。

ref<_Tp>(i0,...[,hashval]) 等效于 *(_Tp*)ptr(i0,...,true[,hashval])。该方法始终返回有效的引用。如果元素不存在，则创建它并将其初始化为 0。

release()

void cv::SparseMat::release

(

)

removeNode()

void cv::SparseMat::removeNode	(	size_t	hidx,
		size_t	nidx,
		size_t	previdx
	)

resizeHashTab()

void cv::SparseMat::resizeHashTab

(

size_t

newsize

)

size() [1/2]

const int * cv::SparseMat::size

(

)

const

返回大小数组，如果矩阵未分配则返回 NULL

size() [2/2]

int cv::SparseMat::size

(

int

i

)

const

返回第 i 个矩阵维度的尺寸（或 0）

type()

int cv::SparseMat::type

(

)

const

返回稀疏矩阵元素的类型

value() [1/6]

template<typename _Tp >

_Tp cv::SparseMat::value	(	const int *	idx,
		size_t *	hashval = 0
	)		const

返回指定元素的值（nD 案例）

value() [2/6]

template<typename _Tp >

const _Tp & cv::SparseMat::value

(

const Node *

n

)

const

返回稀疏矩阵节点中存储的值

value() [3/6]

template<typename _Tp >

_Tp cv::SparseMat::value	(	int	i0,
		int	i1,
		int	i2,
		size_t *	hashval = 0
	)		const

返回指定元素的值（3D 案例）

value() [4/6]

template<typename _Tp >

_Tp cv::SparseMat::value	(	int	i0,
		int	i1,
		size_t *	hashval = 0
	)		const

返回指定元素的值（2D 案例）

value() [5/6]

template<typename _Tp >

_Tp cv::SparseMat::value	(	int	i0,
		size_t *	hashval = 0
	)		const

返回指定元素的值（1D 案例）

返回指定稀疏矩阵元素的值。

value<_Tp>(i0,...[,hashval]) 等效于

{ const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); }

也就是说，如果元素不存在，则方法返回 0。

value() [6/6]

template<typename _Tp >

_Tp & cv::SparseMat::value

(

Node *

n

)

返回稀疏矩阵节点中存储的值

成员数据文档

flags

int cv::SparseMat::flags

hdr

Hdr* cv::SparseMat::hdr

---

该类的文档是从以下文件生成的

• opencv2/core/mat.hpp