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	迭代器

公有成员函数
	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)
	擦除指定元素（n 维情况）
void	erase (int i0, int i1, int i2, size_t *hashval=0)
	擦除指定元素（3 维情况）
void	erase (int i0, int i1, size_t *hashval=0)
	擦除指定元素（2 维情况）
size_t	hash (const int *idx) const
	计算元素哈希值（n 维情况）
size_t	hash (int i0) const
	计算元素哈希值（1 维情况）
size_t	hash (int i0, int i1) const
	计算元素哈希值（2 维情况）
size_t	hash (int i0, int i1, int i2) const
	计算元素哈希值（3 维情况）
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)
	返回指向指定元素的指针（1 维情况）
uchar *	ptr (int i0, int i1, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（2 维情况）
uchar *	ptr (int i0, int i1, int i2, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（3 维情况）
uchar *	ptr (const int *idx, bool createMissing, size_t *hashval=0)
	返回指向指定元素的指针（n 维情况）
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)
	返回对指定元素的引用（n 维情况）
template<typename _Tp >
_Tp	value (int i0, size_t *hashval=0) const
	返回指定元素的值（1 维情况）
template<typename _Tp >
_Tp	value (int i0, int i1, size_t *hashval=0) const
	返回指定元素的值（2 维情况）
template<typename _Tp >
_Tp	value (int i0, int i1, int i2, size_t *hashval=0) const
	返回指定元素的值（3 维情况）
template<typename _Tp >
_Tp	value (const int *idx, size_t *hashval=0) const
	返回指定元素的值（n 维情况）
template<typename _Tp >
const _Tp *	find (int i0, size_t *hashval=0) const
	返回指向指定元素的指针（1 维情况）
template<typename _Tp >
const _Tp *	find (int i0, int i1, size_t *hashval=0) const
	返回指向指定元素的指针（2 维情况）
template<typename _Tp >
const _Tp *	find (int i0, int i1, int i2, size_t *hashval=0) const
	返回指向指定元素的指针（3 维情况）
template<typename _Tp >
const _Tp *	find (const int *idx, size_t *hashval=0) const
	返回指向指定元素的指针（n 维情况）
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;
  }

成员 Typedef 文档

const_iterator

SparseMatConstIterator cv::SparseMat::const_iterator

iterator

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 )

显式

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于其接受的参数。

参数

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，这意味着清空哈希表。

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 维矩阵，可选进行类型转换和缩放。

参数

[输出]	m	- 输出矩阵；如果操作前它没有适当的大小或类型，则会重新分配。
[输入]	rtype	- 期望的输出矩阵类型，或者更确切地说，是深度，因为通道数与输入相同；如果 rtype 为负，则输出矩阵将具有与输入相同的类型。
[输入]	alpha	- 可选的缩放因子
[输入]	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 )

擦除指定元素（n 维情况）

erase() [2/3]

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

擦除指定元素（3 维情况）

erase() [3/3]

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

擦除指定元素（2 维情况）

find() [1/4]

template<typename _Tp >

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

返回指向指定元素的指针（n 维情况）

find() [2/4]

template<typename _Tp >

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

返回指向指定元素的指针（3 维情况）

find() [3/4]

template<typename _Tp >

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

返回指向指定元素的指针（2 维情况）

find() [4/4]

template<typename _Tp >

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

返回指向指定元素的指针（1 维情况）

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

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

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

hash() [1/4]

size_t cv::SparseMat::hash

(

const int *

idx

)

const

计算元素哈希值（n 维情况）

hash() [2/4]

size_t cv::SparseMat::hash

(

int

i0

)

const

计算元素哈希值（1 维情况）

hash() [3/4]

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

计算元素哈希值（2 维情况）

hash() [4/4]

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

计算元素哈希值（3 维情况）

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 )

返回指向指定元素的指针（n 维情况）

ptr() [2/4]

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

返回指向指定元素的指针（1 维情况）

针对 1D、2D、3D 情况的专用变体，以及针对 n-D 情况的通用类型变体。返回指向矩阵元素的指针。

• 如果元素存在（非零），则返回指向它的指针
• 如果不存在且 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 )

返回指向指定元素的指针（2 维情况）

ptr() [4/4]

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

返回指向指定元素的指针（3 维情况）

ref() [1/4]

template<typename _Tp >

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

返回对指定元素的引用（n 维情况）

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

返回指定元素的值（n 维情况）

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

返回指定元素的值（3 维情况）

value() [4/6]

template<typename _Tp >

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

返回指定元素的值（2 维情况）

value() [5/6]

template<typename _Tp >

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

返回指定元素的值（1 维情况）

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

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