cv::SparseMat 类参考

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

#include <opencv2/core/mat.hpp>

cv::SparseMat 协作图

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

公开类型
enum	{   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

SparseMatConstIterator cv::SparseMat::const_iterator

iterator

SparseMatIterator cv::SparseMat::iterator

成员枚举文档

匿名枚举

匿名枚举

枚举值 (Enumerator)
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	哈希值 )

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 情况的 generic_type。返回指向矩阵元素的指针。

• 如果元素存在（非零），则返回指向它的指针
• 如果不存在且 createMissing=false，则返回 NULL 指针
• 如果不存在且 createMissing=true，则创建新元素并初始化为 0。返回指向它的指针
• 如果可选的 hashval 指针不为 NULL，则不计算元素哈希值，而是取 *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