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)
	返回指定元素的指针（一维情况）
uchar *	ptr (int i0, int i1, bool createMissing, size_t *hashval=0)
	返回指定元素的指针（二维情况）
uchar *	ptr (int i0, int i1, int i2, bool createMissing, size_t *hashval=0)
	返回指定元素的指针（三维情况）
uchar *	ptr (const int *idx, bool createMissing, size_t *hashval=0)
	返回指定元素的指针（n维情况）
template<typename _Tp >
_Tp &	ref (int i0, size_t *hashval=0)
	返回指定元素的引用（一维情况）
template<typename _Tp >
_Tp &	ref (int i0, int i1, size_t *hashval=0)
	返回指定元素的引用（二维情况）
template<typename _Tp >
_Tp &	ref (int i0, int i1, int i2, size_t *hashval=0)
	返回指定元素的引用（三维情况）
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
	返回指定元素的值（一维情况）
template<typename _Tp >
_Tp	value (int i0, int i1, size_t *hashval=0) const
	返回指定元素的值（二维情况）
template<typename _Tp >
_Tp	value (int i0, int i1, int i2, size_t *hashval=0) const
	返回指定元素的值（三维情况）
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
	返回指定元素的指针（一维情况）
template<typename _Tp >
const _Tp *	find (int i0, int i1, size_t *hashval=0) const
	返回指定元素的指针（二维情况）
template<typename _Tp >
const _Tp *	find (int i0, int i1, int i2, size_t *hashval=0) const
	返回指定元素的指针（三维情况）
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;
  }

成员类型定义文档

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 )

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

参数

[输出]	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 )

删除指定的元素（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

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

find() [2/4]

template<typename _Tp >

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

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

find() [3/4]

template<typename _Tp >

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

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

find() [4/4]

template<typename _Tp >

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

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

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

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 )

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

ptr() [2/4]

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

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

针对一维、二维、三维情况的专用变体以及用于n维情况的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 )

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

ptr() [4/4]

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

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

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 )

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

ref() [3/4]

template<typename _Tp >

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

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

ref() [4/4]

template<typename _Tp >

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

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

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

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

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

value() [4/6]

template<typename _Tp >

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

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

value() [5/6]

template<typename _Tp >

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

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

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

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