cv::SparseMat Class Reference

#include <core.hpp>

Inheritance diagram for cv::SparseMat:
cv::SparseMat_< _Tp >

List of all members.

Classes

struct  Hdr
 the sparse matrix header More...
struct  Node
 sparse matrix node - element of a hash table More...

Public Types

enum  { MAGIC_VAL = 0x42FD0000, MAX_DIM = CV_MAX_DIM, HASH_SCALE = 0x5bd1e995, HASH_BIT = 0x80000000 }
typedef SparseMatConstIterator const_iterator
typedef SparseMatIterator iterator

Public Member Functions

void addref ()
 manually increments the reference counter to the header.
void assignTo (SparseMat &m, int type=-1) const
int channels () const
 returns the number of channels
void clear ()
 sets all the sparse matrix elements to 0, which means clearing the hash table.
SparseMat clone () const
 creates full copy of the matrix
void convertTo (Mat &m, int rtype, double alpha=1, double beta=0) const
 converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
void convertTo (SparseMat &m, int rtype, double alpha=1) const
 multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type
void copyTo (Mat &m) const
 converts sparse matrix to dense matrix.
void copyTo (SparseMat &m) const
 copies all the data to the destination matrix. All the previous content of m is erased
void create (int dims, const int *_sizes, int _type)
 reallocates sparse matrix.
int depth () const
 returns the depth of sparse matrix elements
int dims () const
 returns the matrix dimensionality
size_t elemSize () const
 returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)
size_t elemSize1 () const
 returns elemSize()/channels()
template<typename _Tp >
SparseMatConstIterator_< _Tp > end () const
 returns the typed read-only sparse matrix iterator at the matrix end
template<typename _Tp >
SparseMatIterator_< _Tp > end ()
 returns the typed sparse matrix iterator at the matrix end
SparseMatConstIterator end () const
 returns the read-only sparse matrix iterator at the matrix end
SparseMatIterator end ()
 returns the sparse matrix iterator at the matrix end
size_t hash (const int *idx) const
 computes the element hash value (nD case)
size_t hash (int i0, int i1, int i2) const
 computes the element hash value (3D case)
size_t hash (int i0, int i1) const
 computes the element hash value (2D case)
size_t hash (int i0) const
 computes the element hash value (1D case)
ucharnewNode (const int *idx, size_t hashval)
const Nodenode (size_t nidx) const
Nodenode (size_t nidx)
size_t nzcount () const
 returns the number of non-zero elements (=the number of hash table nodes)
 operator CvSparseMat * () const
 converts sparse matrix to the old-style representation; all the elements are copied.
SparseMatoperator= (const Mat &m)
 equivalent to the corresponding constructor
SparseMatoperator= (const SparseMat &m)
 assignment operator. This is O(1) operation, i.e. no data is copied
void release ()
void removeNode (size_t hidx, size_t nidx, size_t previdx)
void resizeHashTab (size_t newsize)
int size (int i) const
 returns the size of i-th matrix dimension (or 0)
const int * size () const
 returns the array of sizes, or NULL if the matrix is not allocated
 SparseMat (const CvSparseMat *m)
 converts old-style sparse matrix to the new-style. All the data is copied
 SparseMat (const Mat &m)
 converts dense 2d matrix to the sparse form
 SparseMat (const SparseMat &m)
 copy constructor
 SparseMat (int dims, const int *_sizes, int _type)
 creates matrix of the specified size and type
 SparseMat ()
 default constructor
int type () const
 returns type of sparse matrix elements
template<typename _Tp >
const _Tp & value (const Node *n) const
 returns the value stored in the sparse martix node
template<typename _Tp >
_Tp & value (Node *n)
 returns the value stored in the sparse martix node
 ~SparseMat ()
 the destructor

template<typename _Tp >
SparseMatConstIterator_< _Tp > begin () const
 returns the read-only sparse matrix iterator at the matrix beginning
SparseMatConstIterator begin () const
 returns the read-only sparse matrix iterator at the matrix beginning
template<typename _Tp >
SparseMatIterator_< _Tp > begin ()
 returns the sparse matrix iterator at the matrix beginning
SparseMatIterator begin ()
 returns the sparse matrix iterator at the matrix beginning
void erase (const int *idx, size_t *hashval=0)
 erases the specified element (nD case)
void erase (int i0, int i1, int i2, size_t *hashval=0)
 erases the specified element (3D case)
void erase (int i0, int i1, size_t *hashval=0)
 erases the specified element (2D case)
template<typename _Tp >
const _Tp * find (const int *idx, size_t *hashval=0) const
 returns pointer to the specified element (nD case)
template<typename _Tp >
const _Tp * find (int i0, int i1, int i2, size_t *hashval=0) const
 returns pointer to the specified element (3D case)
template<typename _Tp >
const _Tp * find (int i0, int i1, size_t *hashval=0) const
 returns pointer to the specified element (2D case)
template<typename _Tp >
const _Tp * find (int i0, size_t *hashval=0) const
 returns pointer to the specified element (1D case)

ucharptr (const int *idx, bool createMissing, size_t *hashval=0)
 returns pointer to the specified element (nD case)
ucharptr (int i0, int i1, int i2, bool createMissing, size_t *hashval=0)
 returns pointer to the specified element (3D case)
ucharptr (int i0, int i1, bool createMissing, size_t *hashval=0)
 returns pointer to the specified element (2D case)
ucharptr (int i0, bool createMissing, size_t *hashval=0)
 returns pointer to the specified element (1D case)

template<typename _Tp >
_Tp & ref (const int *idx, size_t *hashval=0)
 returns reference to the specified element (nD case)
template<typename _Tp >
_Tp & ref (int i0, int i1, int i2, size_t *hashval=0)
 returns reference to the specified element (3D case)
template<typename _Tp >
_Tp & ref (int i0, int i1, size_t *hashval=0)
 returns reference to the specified element (2D case)
template<typename _Tp >
_Tp & ref (int i0, size_t *hashval=0)
 returns reference to the specified element (1D case)

template<typename _Tp >
_Tp value (const int *idx, size_t *hashval=0) const
 returns value of the specified element (nD case)
template<typename _Tp >
_Tp value (int i0, int i1, int i2, size_t *hashval=0) const
 returns value of the specified element (3D case)
template<typename _Tp >
_Tp value (int i0, int i1, size_t *hashval=0) const
 returns value of the specified element (2D case)
template<typename _Tp >
_Tp value (int i0, size_t *hashval=0) const
 returns value of the specified element (1D case)

Public Attributes

int flags
Hdrhdr

Detailed Description

Sparse matrix class.

The class represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements of any type that cv::Mat is able to store. "Sparse" means that only non-zero elements are stored (though, as a result of some operations on a sparse matrix, some of its stored elements can actually become 0. It's user responsibility to detect such elements and delete them using cv::SparseMat::erase(). The non-zero elements are stored in a hash table that grows when it's filled enough, so that the search time remains O(1) in average. Elements can be accessed using the following methods:

  1. Query operations: cv::SparseMat::ptr() and the higher-level cv::SparseMat::ref(), cv::SparseMat::value() and cv::SparseMat::find, for example:

     const int dims = 5;
     int size[] = {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()%sparse_mat.size(k);
         sparse_mat.ref<float>(idx) += 1.f;
     }
    

  2. Sparse matrix iterators. Like cv::Mat iterators and unlike cv::Mat iterators, the sparse matrix iterators are STL-style, that is, the iteration is done as following:

     // prints elements of a sparse floating-point matrix and the sum of elements.
     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)
     {
         // print element indices and the element value
         const Node* n = it.node();
         printf("(")
         for(int i = 0; i < dims; i++)
            printf("%3d%c", n->idx[i], i < dims-1 ? ',' : ')');
         printf(": %f\n", *it);    
         s += *it;
     }
     printf("Element sum is %g\n", s);
    

    If you run this loop, you will notice that elements are enumerated in no any logical order (lexicographical etc.), they come in the same order as they stored in the hash table, i.e. semi-randomly.

    You may collect pointers to the nodes and sort them to get the proper ordering. Note, however, that pointers to the nodes may become invalid when you add more elements to the matrix; this is because of possible buffer reallocation.

  3. A combination of the above 2 methods when you need to process 2 or more sparse matrices simultaneously, e.g. this is how you can compute unnormalized cross-correlation of the 2 floating-point sparse matrices:
     double crossCorr(const SparseMat& a, const SparseMat& b)
     {
         const SparseMat *_a = &a, *_b = &b;
         // if b contains less elements than a,
         // it's faster to iterate through 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)
         {
             // take the next element from the first matrix
             float avalue = *it;
             const Node* anode = it.node();
             // and try to find element with the same index in the second matrix.
             // since the hash value depends only on the element index,
             // we reuse hashvalue stored in the node
             float bvalue = _b->value<float>(anode->idx,&anode->hashval);
             ccorr += avalue*bvalue;
         }
         return ccorr;
     }
    

Member Typedef Documentation

Reimplemented in cv::SparseMat_< _Tp >.

Reimplemented in cv::SparseMat_< _Tp >.


Member Enumeration Documentation

anonymous enum
Enumerator:
MAGIC_VAL 
MAX_DIM 
HASH_SCALE 
HASH_BIT 

Constructor & Destructor Documentation

cv::SparseMat::SparseMat (  )  [inline]

default constructor

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

creates matrix of the specified size and type

cv::SparseMat::SparseMat ( const SparseMat m  )  [inline]

copy constructor

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

converts dense 2d matrix to the sparse form

Parameters:
m the input matrix
try1d if true and m is a single-column matrix (Nx1), then the sparse matrix will be 1-dimensional.
cv::SparseMat::SparseMat ( const CvSparseMat m  ) 

converts old-style sparse matrix to the new-style. All the data is copied

cv::SparseMat::~SparseMat (  )  [inline]

the destructor


Member Function Documentation

void cv::SparseMat::addref (  )  [inline]

manually increments the reference counter to the header.

void cv::SparseMat::assignTo ( SparseMat m,
int  type = -1 
) const [inline]
template<typename _Tp >
SparseMatConstIterator_<_Tp> cv::SparseMat::begin (  )  const [inline]

returns the read-only sparse matrix iterator at the matrix beginning

Reimplemented in cv::SparseMat_< _Tp >.

SparseMatConstIterator_< _Tp > cv::SparseMat::begin (  )  const [inline]

returns the read-only sparse matrix iterator at the matrix beginning

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
SparseMatIterator_<_Tp> cv::SparseMat::begin (  )  [inline]

returns the sparse matrix iterator at the matrix beginning

Reimplemented in cv::SparseMat_< _Tp >.

SparseMatIterator_< _Tp > cv::SparseMat::begin (  )  [inline]

returns the sparse matrix iterator at the matrix beginning

return the sparse matrix iterator pointing to the first sparse matrix element

Reimplemented in cv::SparseMat_< _Tp >.

int cv::SparseMat::channels (  )  const [inline]

returns the number of channels

Reimplemented in cv::SparseMat_< _Tp >.

void cv::SparseMat::clear (  ) 

sets all the sparse matrix elements to 0, which means clearing the hash table.

SparseMat cv::SparseMat::clone (  )  const [inline]

creates full copy of the matrix

Reimplemented in cv::SparseMat_< _Tp >.

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

converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.

Parameters:
rtype The output matrix data type. When it is =-1, the output array will have the same data type as (*this)
alpha The scale factor
beta The optional delta added to the scaled values before the conversion
void cv::SparseMat::convertTo ( SparseMat m,
int  rtype,
double  alpha = 1 
) const

multiplies all the matrix elements by the specified scale factor alpha and converts the results to the specified data type

void cv::SparseMat::copyTo ( Mat m  )  const

converts sparse matrix to dense matrix.

void cv::SparseMat::copyTo ( SparseMat m  )  const

copies all the data to the destination matrix. All the previous content of m is erased

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

reallocates sparse matrix.

If the matrix already had the proper size and type, it is simply cleared with clear(), otherwise, the old matrix is released (using release()) and the new one is allocated.

int cv::SparseMat::depth (  )  const [inline]

returns the depth of sparse matrix elements

Reimplemented in cv::SparseMat_< _Tp >.

int cv::SparseMat::dims (  )  const [inline]

returns the matrix dimensionality

size_t cv::SparseMat::elemSize (  )  const [inline]

returns the size of each element in bytes (not including the overhead - the space occupied by SparseMat::Node elements)

size_t cv::SparseMat::elemSize1 (  )  const [inline]

returns elemSize()/channels()

template<typename _Tp >
SparseMatConstIterator_<_Tp> cv::SparseMat::end (  )  const [inline]

returns the typed read-only sparse matrix iterator at the matrix end

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
SparseMatIterator_<_Tp> cv::SparseMat::end (  )  [inline]

returns the typed sparse matrix iterator at the matrix end

Reimplemented in cv::SparseMat_< _Tp >.

SparseMatConstIterator_< _Tp > cv::SparseMat::end (  )  const [inline]

returns the read-only sparse matrix iterator at the matrix end

Reimplemented in cv::SparseMat_< _Tp >.

SparseMatIterator_< _Tp > cv::SparseMat::end (  )  [inline]

returns the sparse matrix iterator at the matrix end

return the sparse matrix iterator pointing to the element following the last sparse matrix element

Reimplemented in cv::SparseMat_< _Tp >.

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

erases the specified element (nD case)

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

erases the specified element (3D case)

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

erases the specified element (2D case)

template<typename _Tp >
const _Tp * cv::SparseMat::find ( const int *  idx,
size_t *  hashval = 0 
) const [inline]

returns pointer to the specified element (nD case)

template<typename _Tp >
const _Tp * cv::SparseMat::find ( int  i0,
int  i1,
int  i2,
size_t *  hashval = 0 
) const [inline]

returns pointer to the specified element (3D case)

template<typename _Tp >
const _Tp * cv::SparseMat::find ( int  i0,
int  i1,
size_t *  hashval = 0 
) const [inline]

returns pointer to the specified element (2D case)

template<typename _Tp >
const _Tp * cv::SparseMat::find ( int  i0,
size_t *  hashval = 0 
) const [inline]

returns pointer to the specified element (1D case)

Return pointer to the specified sparse matrix element if it exists

find<_Tp>(i0,...[,hashval]) is equivalent to (_const Tp*)ptr(i0,...false[,hashval]).

If the specified element does not exist, the methods return NULL.

size_t cv::SparseMat::hash ( const int *  idx  )  const [inline]

computes the element hash value (nD case)

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

computes the element hash value (3D case)

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

computes the element hash value (2D case)

size_t cv::SparseMat::hash ( int  i0  )  const [inline]

computes the element hash value (1D case)

uchar* cv::SparseMat::newNode ( const int *  idx,
size_t  hashval 
)
const SparseMat::Node * cv::SparseMat::node ( size_t  nidx  )  const [inline]
SparseMat::Node * cv::SparseMat::node ( size_t  nidx  )  [inline]
size_t cv::SparseMat::nzcount (  )  const [inline]

returns the number of non-zero elements (=the number of hash table nodes)

cv::SparseMat::operator CvSparseMat * (  )  const

converts sparse matrix to the old-style representation; all the elements are copied.

Reimplemented in cv::SparseMat_< _Tp >.

SparseMat & cv::SparseMat::operator= ( const Mat m  )  [inline]

equivalent to the corresponding constructor

Reimplemented in cv::SparseMat_< _Tp >.

SparseMat & cv::SparseMat::operator= ( const SparseMat m  )  [inline]

assignment operator. This is O(1) operation, i.e. no data is copied

Reimplemented in cv::SparseMat_< _Tp >.

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

returns pointer to the specified element (nD case)

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

returns pointer to the specified element (3D case)

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

returns pointer to the specified element (2D case)

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

returns pointer to the specified element (1D case)

specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case.

return pointer to the matrix element.

  • if the element is there (it's non-zero), the pointer to it is returned
  • if it's not there and createMissing=false, NULL pointer is returned
  • if it's not there and createMissing=true, then the new element is created and initialized with 0. Pointer to it is returned
  • if the optional hashval pointer is not NULL, the element hash value is not computed, but *hashval is taken instead.
template<typename _Tp >
_Tp & cv::SparseMat::ref ( const int *  idx,
size_t *  hashval = 0 
) [inline]

returns reference to the specified element (nD case)

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
_Tp & cv::SparseMat::ref ( int  i0,
int  i1,
int  i2,
size_t *  hashval = 0 
) [inline]

returns reference to the specified element (3D case)

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
_Tp & cv::SparseMat::ref ( int  i0,
int  i1,
size_t *  hashval = 0 
) [inline]

returns reference to the specified element (2D case)

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
_Tp & cv::SparseMat::ref ( int  i0,
size_t *  hashval = 0 
) [inline]

returns reference to the specified element (1D case)

return read-write reference to the specified sparse matrix element.

ref<_Tp>(i0,...[,hashval]) is equivalent to *(_Tp*)ptr(i0,...,true[,hashval]). The methods always return a valid reference. If the element did not exist, it is created and initialiazed with 0.

Reimplemented in cv::SparseMat_< _Tp >.

void cv::SparseMat::release (  )  [inline]
void cv::SparseMat::removeNode ( size_t  hidx,
size_t  nidx,
size_t  previdx 
)
void cv::SparseMat::resizeHashTab ( size_t  newsize  ) 
int cv::SparseMat::size ( int  i  )  const [inline]

returns the size of i-th matrix dimension (or 0)

const int * cv::SparseMat::size (  )  const [inline]

returns the array of sizes, or NULL if the matrix is not allocated

int cv::SparseMat::type (  )  const [inline]

returns type of sparse matrix elements

Reimplemented in cv::SparseMat_< _Tp >.

template<typename _Tp >
const _Tp & cv::SparseMat::value ( const Node n  )  const [inline]

returns the value stored in the sparse martix node

template<typename _Tp >
_Tp & cv::SparseMat::value ( Node n  )  [inline]

returns the value stored in the sparse martix node

template<typename _Tp >
_Tp cv::SparseMat::value ( const int *  idx,
size_t *  hashval = 0 
) const [inline]

returns value of the specified element (nD case)

template<typename _Tp >
_Tp cv::SparseMat::value ( int  i0,
int  i1,
int  i2,
size_t *  hashval = 0 
) const [inline]

returns value of the specified element (3D case)

template<typename _Tp >
_Tp cv::SparseMat::value ( int  i0,
int  i1,
size_t *  hashval = 0 
) const [inline]

returns value of the specified element (2D case)

template<typename _Tp >
_Tp cv::SparseMat::value ( int  i0,
size_t *  hashval = 0 
) const [inline]

returns value of the specified element (1D case)

return value of the specified sparse matrix element.

value<_Tp>(i0,...[,hashval]) is equivalent

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

That is, if the element did not exist, the methods return 0.


Member Data Documentation


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Thu Dec 23 11:40:55 2010 for opencv by  doxygen 1.6.3