/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "_cv.h"
/* Creates new histogram */
CvHistogram *
cvCreateHist( int dims, int *sizes, CvHistType type, float** ranges, int uniform )
{
CvHistogram *hist = 0;
CV_FUNCNAME( "cvCreateHist" );
__BEGIN__;
if( (unsigned)dims > CV_MAX_DIM )
CV_ERROR( CV_BadOrder, "Number of dimensions is out of range" );
if( !sizes )
CV_ERROR( CV_HeaderIsNull, "Null <sizes> pointer" );
CV_CALL( hist = (CvHistogram *)cvAlloc( sizeof( CvHistogram )));
hist->type = CV_HIST_MAGIC_VAL;
hist->thresh2 = 0;
hist->bins = 0;
if( type == CV_HIST_ARRAY )
{
CV_CALL( hist->bins = cvInitMatNDHeader( &hist->mat, dims, sizes,
CV_HIST_DEFAULT_TYPE ));
CV_CALL( cvCreateData( hist->bins ));
}
else if( type == CV_HIST_SPARSE )
{
CV_CALL( hist->bins = cvCreateSparseMat( dims, sizes, CV_HIST_DEFAULT_TYPE ));
}
else
{
CV_ERROR( CV_StsBadArg, "Invalid histogram type" );
}
if( ranges )
CV_CALL( cvSetHistBinRanges( hist, ranges, uniform ));
__END__;
if( cvGetErrStatus() < 0 )
cvReleaseHist( &hist );
return hist;
}
/* Creates histogram wrapping header for given array */
CV_IMPL CvHistogram*
cvMakeHistHeaderForArray( int dims, int *sizes, CvHistogram *hist,
float *data, float **ranges, int uniform )
{
CvHistogram* result = 0;
CV_FUNCNAME( "cvMakeHistHeaderForArray" );
__BEGIN__;
if( !hist )
CV_ERROR( CV_StsNullPtr, "Null histogram header pointer" );
if( !data )
CV_ERROR( CV_StsNullPtr, "Null data pointer" );
hist->thresh2 = 0;
hist->type = CV_HIST_MAGIC_VAL;
CV_CALL( hist->bins = cvInitMatNDHeader( &hist->mat, dims, sizes,
CV_HIST_DEFAULT_TYPE, data ));
if( ranges )
{
if( !uniform )
CV_ERROR( CV_StsBadArg, "Only uniform bin ranges can be used here "
"(to avoid memory allocation)" );
CV_CALL( cvSetHistBinRanges( hist, ranges, uniform ));
}
result = hist;
__END__;
if( cvGetErrStatus() < 0 && hist )
{
hist->type = 0;
hist->bins = 0;
}
return result;
}
CV_IMPL void
cvReleaseHist( CvHistogram **hist )
{
CV_FUNCNAME( "cvReleaseHist" );
__BEGIN__;
if( !hist )
CV_ERROR( CV_StsNullPtr, "" );
if( *hist )
{
CvHistogram* temp = *hist;
if( !CV_IS_HIST(temp))
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
*hist = 0;
if( CV_IS_SPARSE_HIST( temp ))
cvRelease( &temp->bins );
else
{
cvReleaseData( temp->bins );
temp->bins = 0;
}
if( temp->thresh2 )
cvFree( &temp->thresh2 );
cvFree( &temp );
}
__END__;
}
CV_IMPL void
cvClearHist( CvHistogram *hist )
{
CV_FUNCNAME( "cvClearHist" );
__BEGIN__;
if( !CV_IS_HIST(hist) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
cvZero( hist->bins );
__END__;
}
// Clears histogram bins that are below than threshold
CV_IMPL void
cvThreshHist( CvHistogram* hist, double thresh )
{
CV_FUNCNAME( "cvThreshHist" );
__BEGIN__;
if( !CV_IS_HIST(hist) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
if( !CV_IS_SPARSE_MAT(hist->bins) )
{
CvMat mat;
CV_CALL( cvGetMat( hist->bins, &mat, 0, 1 ));
CV_CALL( cvThreshold( &mat, &mat, thresh, 0, CV_THRESH_TOZERO ));
}
else
{
CvSparseMat* mat = (CvSparseMat*)hist->bins;
CvSparseMatIterator iterator;
CvSparseNode *node;
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
float* val = (float*)CV_NODE_VAL( mat, node );
if( *val <= thresh )
*val = 0;
}
}
__END__;
}
// Normalizes histogram (make sum of the histogram bins == factor)
CV_IMPL void
cvNormalizeHist( CvHistogram* hist, double factor )
{
double sum = 0;
CV_FUNCNAME( "cvNormalizeHist" );
__BEGIN__;
if( !CV_IS_HIST(hist) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
if( !CV_IS_SPARSE_HIST(hist) )
{
CvMat mat;
CV_CALL( cvGetMat( hist->bins, &mat, 0, 1 ));
CV_CALL( sum = cvSum( &mat ).val[0] );
if( fabs(sum) < DBL_EPSILON )
sum = 1;
CV_CALL( cvScale( &mat, &mat, factor/sum, 0 ));
}
else
{
CvSparseMat* mat = (CvSparseMat*)hist->bins;
CvSparseMatIterator iterator;
CvSparseNode *node;
float scale;
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
sum += *(float*)CV_NODE_VAL(mat,node);
}
if( fabs(sum) < DBL_EPSILON )
sum = 1;
scale = (float)(factor/sum);
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
*(float*)CV_NODE_VAL(mat,node) *= scale;
}
}
__END__;
}
// Retrieves histogram global min, max and their positions
CV_IMPL void
cvGetMinMaxHistValue( const CvHistogram* hist,
float *value_min, float* value_max,
int* idx_min, int* idx_max )
{
double minVal, maxVal;
CV_FUNCNAME( "cvGetMinMaxHistValue" );
__BEGIN__;
int i, dims, size[CV_MAX_DIM];
if( !CV_IS_HIST(hist) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
dims = cvGetDims( hist->bins, size );
if( !CV_IS_SPARSE_HIST(hist) )
{
CvMat mat;
CvPoint minPt, maxPt;
CV_CALL( cvGetMat( hist->bins, &mat, 0, 1 ));
CV_CALL( cvMinMaxLoc( &mat, &minVal, &maxVal, &minPt, &maxPt ));
if( dims == 1 )
{
if( idx_min )
*idx_min = minPt.y + minPt.x;
if( idx_max )
*idx_max = maxPt.y + maxPt.x;
}
else if( dims == 2 )
{
if( idx_min )
idx_min[0] = minPt.y, idx_min[1] = minPt.x;
if( idx_max )
idx_max[0] = maxPt.y, idx_max[1] = maxPt.x;
}
else if( idx_min || idx_max )
{
int imin = minPt.y*mat.cols + minPt.x;
int imax = maxPt.y*mat.cols + maxPt.x;
int i;
for( i = dims - 1; i >= 0; i-- )
{
if( idx_min )
{
int t = imin / size[i];
idx_min[i] = imin - t*size[i];
imin = t;
}
if( idx_max )
{
int t = imax / size[i];
idx_max[i] = imax - t*size[i];
imax = t;
}
}
}
}
else
{
CvSparseMat* mat = (CvSparseMat*)hist->bins;
CvSparseMatIterator iterator;
CvSparseNode *node;
int minv = INT_MAX;
int maxv = INT_MIN;
CvSparseNode* minNode = 0;
CvSparseNode* maxNode = 0;
const int *_idx_min = 0, *_idx_max = 0;
Cv32suf m;
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
int value = *(int*)CV_NODE_VAL(mat,node);
value = CV_TOGGLE_FLT(value);
if( value < minv )
{
minv = value;
minNode = node;
}
if( value > maxv )
{
maxv = value;
maxNode = node;
}
}
if( minNode )
{
_idx_min = CV_NODE_IDX(mat,minNode);
_idx_max = CV_NODE_IDX(mat,maxNode);
m.i = CV_TOGGLE_FLT(minv); minVal = m.f;
m.i = CV_TOGGLE_FLT(maxv); maxVal = m.f;
}
else
{
minVal = maxVal = 0;
}
for( i = 0; i < dims; i++ )
{
if( idx_min )
idx_min[i] = _idx_min ? _idx_min[i] : -1;
if( idx_max )
idx_max[i] = _idx_max ? _idx_max[i] : -1;
}
}
if( value_min )
*value_min = (float)minVal;
if( value_max )
*value_max = (float)maxVal;
__END__;
}
// Compares two histograms using one of a few methods
CV_IMPL double
cvCompareHist( const CvHistogram* hist1,
const CvHistogram* hist2,
int method )
{
double _result = -1;
CV_FUNCNAME( "cvCompareHist" );
__BEGIN__;
int i, dims1, dims2;
int size1[CV_MAX_DIM], size2[CV_MAX_DIM], total = 1;
double result = 0;
if( !CV_IS_HIST(hist1) || !CV_IS_HIST(hist2) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header[s]" );
if( CV_IS_SPARSE_MAT(hist1->bins) != CV_IS_SPARSE_MAT(hist2->bins))
CV_ERROR(CV_StsUnmatchedFormats, "One of histograms is sparse and other is not");
CV_CALL( dims1 = cvGetDims( hist1->bins, size1 ));
CV_CALL( dims2 = cvGetDims( hist2->bins, size2 ));
if( dims1 != dims2 )
CV_ERROR( CV_StsUnmatchedSizes,
"The histograms have different numbers of dimensions" );
for( i = 0; i < dims1; i++ )
{
if( size1[i] != size2[i] )
CV_ERROR( CV_StsUnmatchedSizes, "The histograms have different sizes" );
total *= size1[i];
}
if( !CV_IS_SPARSE_MAT(hist1->bins))
{
union { float* fl; uchar* ptr; } v;
float *ptr1, *ptr2;
v.fl = 0;
CV_CALL( cvGetRawData( hist1->bins, &v.ptr ));
ptr1 = v.fl;
CV_CALL( cvGetRawData( hist2->bins, &v.ptr ));
ptr2 = v.fl;
switch( method )
{
case CV_COMP_CHISQR:
for( i = 0; i < total; i++ )
{
double a = ptr1[i] - ptr2[i];
double b = ptr1[i] + ptr2[i];
if( fabs(b) > DBL_EPSILON )
result += a*a/b;
}
break;
case CV_COMP_CORREL:
{
double s1 = 0, s11 = 0;
double s2 = 0, s22 = 0;
double s12 = 0;
double num, denom2, scale = 1./total;
for( i = 0; i < total; i++ )
{
double a = ptr1[i];
double b = ptr2[i];
s12 += a*b;
s1 += a;
s11 += a*a;
s2 += b;
s22 += b*b;
}
num = s12 - s1*s2*scale;
denom2 = (s11 - s1*s1*scale)*(s22 - s2*s2*scale);
result = fabs(denom2) > DBL_EPSILON ? num/sqrt(denom2) : 1;
}
break;
case CV_COMP_INTERSECT:
for( i = 0; i < total; i++ )
{
float a = ptr1[i];
float b = ptr2[i];
if( a <= b )
result += a;
else
result += b;
}
break;
case CV_COMP_BHATTACHARYYA:
{
double s1 = 0, s2 = 0;
for( i = 0; i < total; i++ )
{
double a = ptr1[i];
double b = ptr2[i];
result += sqrt(a*b);
s1 += a;
s2 += b;
}
s1 *= s2;
s1 = fabs(s1) > FLT_EPSILON ? 1./sqrt(s1) : 1.;
result = 1. - result*s1;
result = sqrt(MAX(result,0.));
}
break;
default:
CV_ERROR( CV_StsBadArg, "Unknown comparison method" );
}
}
else
{
CvSparseMat* mat1 = (CvSparseMat*)(hist1->bins);
CvSparseMat* mat2 = (CvSparseMat*)(hist2->bins);
CvSparseMatIterator iterator;
CvSparseNode *node1, *node2;
if( mat1->heap->active_count > mat2->heap->active_count )
{
CvSparseMat* t;
CV_SWAP( mat1, mat2, t );
}
switch( method )
{
case CV_COMP_CHISQR:
for( node1 = cvInitSparseMatIterator( mat1, &iterator );
node1 != 0; node1 = cvGetNextSparseNode( &iterator ))
{
double v1 = *(float*)CV_NODE_VAL(mat1,node1);
uchar* node2_data = cvPtrND( mat2, CV_NODE_IDX(mat1,node1), 0, 0, &node1->hashval );
if( !node2_data )
result += v1;
else
{
double v2 = *(float*)node2_data;
double a = v1 - v2;
double b = v1 + v2;
if( fabs(b) > DBL_EPSILON )
result += a*a/b;
}
}
for( node2 = cvInitSparseMatIterator( mat2, &iterator );
node2 != 0; node2 = cvGetNextSparseNode( &iterator ))
{
double v2 = *(float*)CV_NODE_VAL(mat2,node2);
if( !cvPtrND( mat1, CV_NODE_IDX(mat2,node2), 0, 0, &node2->hashval ))
result += v2;
}
break;
case CV_COMP_CORREL:
{
double s1 = 0, s11 = 0;
double s2 = 0, s22 = 0;
double s12 = 0;
double num, denom2, scale = 1./total;
for( node1 = cvInitSparseMatIterator( mat1, &iterator );
node1 != 0; node1 = cvGetNextSparseNode( &iterator ))
{
double v1 = *(float*)CV_NODE_VAL(mat1,node1);
uchar* node2_data = cvPtrND( mat2, CV_NODE_IDX(mat1,node1),
0, 0, &node1->hashval );
if( node2_data )
{
double v2 = *(float*)node2_data;
s12 += v1*v2;
}
s1 += v1;
s11 += v1*v1;
}
for( node2 = cvInitSparseMatIterator( mat2, &iterator );
node2 != 0; node2 = cvGetNextSparseNode( &iterator ))
{
double v2 = *(float*)CV_NODE_VAL(mat2,node2);
s2 += v2;
s22 += v2*v2;
}
num = s12 - s1*s2*scale;
denom2 = (s11 - s1*s1*scale)*(s22 - s2*s2*scale);
result = fabs(denom2) > DBL_EPSILON ? num/sqrt(denom2) : 1;
}
break;
case CV_COMP_INTERSECT:
{
for( node1 = cvInitSparseMatIterator( mat1, &iterator );
node1 != 0; node1 = cvGetNextSparseNode( &iterator ))
{
float v1 = *(float*)CV_NODE_VAL(mat1,node1);
uchar* node2_data = cvPtrND( mat2, CV_NODE_IDX(mat1,node1),
0, 0, &node1->hashval );
if( node2_data )
{
float v2 = *(float*)node2_data;
if( v1 <= v2 )
result += v1;
else
result += v2;
}
}
}
break;
case CV_COMP_BHATTACHARYYA:
{
double s1 = 0, s2 = 0;
for( node1 = cvInitSparseMatIterator( mat1, &iterator );
node1 != 0; node1 = cvGetNextSparseNode( &iterator ))
{
double v1 = *(float*)CV_NODE_VAL(mat1,node1);
uchar* node2_data = cvPtrND( mat2, CV_NODE_IDX(mat1,node1),
0, 0, &node1->hashval );
s1 += v1;
if( node2_data )
{
double v2 = *(float*)node2_data;
result += sqrt(v1 * v2);
}
}
for( node1 = cvInitSparseMatIterator( mat2, &iterator );
node1 != 0; node1 = cvGetNextSparseNode( &iterator ))
{
double v2 = *(float*)CV_NODE_VAL(mat2,node1);
s2 += v2;
}
s1 *= s2;
s1 = fabs(s1) > FLT_EPSILON ? 1./sqrt(s1) : 1.;
result = 1. - result*s1;
result = sqrt(MAX(result,0.));
}
break;
default:
CV_ERROR( CV_StsBadArg, "Unknown comparison method" );
}
}
_result = result;
__END__;
return _result;
}
// copies one histogram to another
CV_IMPL void
cvCopyHist( const CvHistogram* src, CvHistogram** _dst )
{
CV_FUNCNAME( "cvCopyHist" );
__BEGIN__;
int eq = 0;
int is_sparse;
int i, dims1, dims2;
int size1[CV_MAX_DIM], size2[CV_MAX_DIM], total = 1;
float* ranges[CV_MAX_DIM];
float** thresh = 0;
CvHistogram* dst;
if( !_dst )
CV_ERROR( CV_StsNullPtr, "Destination double pointer is NULL" );
dst = *_dst;
if( !CV_IS_HIST(src) || (dst && !CV_IS_HIST(dst)) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header[s]" );
is_sparse = CV_IS_SPARSE_MAT(src->bins);
CV_CALL( dims1 = cvGetDims( src->bins, size1 ));
for( i = 0; i < dims1; i++ )
total *= size1[i];
if( dst && is_sparse == CV_IS_SPARSE_MAT(dst->bins))
{
CV_CALL( dims2 = cvGetDims( dst->bins, size2 ));
if( dims1 == dims2 )
{
for( i = 0; i < dims1; i++ )
if( size1[i] != size2[i] )
break;
}
eq = i == dims1;
}
if( !eq )
{
cvReleaseHist( _dst );
CV_CALL( dst = cvCreateHist( dims1, size1,
!is_sparse ? CV_HIST_ARRAY : CV_HIST_SPARSE, 0, 0 ));
*_dst = dst;
}
if( CV_HIST_HAS_RANGES( src ))
{
if( CV_IS_UNIFORM_HIST( src ))
{
for( i = 0; i < dims1; i++ )
ranges[i] = (float*)src->thresh[i];
thresh = ranges;
}
else
thresh = src->thresh2;
CV_CALL( cvSetHistBinRanges( dst, thresh, CV_IS_UNIFORM_HIST(src)));
}
CV_CALL( cvCopy( src->bins, dst->bins ));
__END__;
}
// Sets a value range for every histogram bin
CV_IMPL void
cvSetHistBinRanges( CvHistogram* hist, float** ranges, int uniform )
{
CV_FUNCNAME( "cvSetHistBinRanges" );
__BEGIN__;
int dims, size[CV_MAX_DIM], total = 0;
int i, j;
if( !ranges )
CV_ERROR( CV_StsNullPtr, "NULL ranges pointer" );
if( !CV_IS_HIST(hist) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
CV_CALL( dims = cvGetDims( hist->bins, size ));
for( i = 0; i < dims; i++ )
total += size[i]+1;
if( uniform )
{
for( i = 0; i < dims; i++ )
{
if( !ranges[i] )
CV_ERROR( CV_StsNullPtr, "One of <ranges> elements is NULL" );
hist->thresh[i][0] = ranges[i][0];
hist->thresh[i][1] = ranges[i][1];
}
hist->type |= CV_HIST_UNIFORM_FLAG + CV_HIST_RANGES_FLAG;
}
else
{
float* dim_ranges;
if( !hist->thresh2 )
{
CV_CALL( hist->thresh2 = (float**)cvAlloc(
dims*sizeof(hist->thresh2[0])+
total*sizeof(hist->thresh2[0][0])));
}
dim_ranges = (float*)(hist->thresh2 + dims);
for( i = 0; i < dims; i++ )
{
float val0 = -FLT_MAX;
if( !ranges[i] )
CV_ERROR( CV_StsNullPtr, "One of <ranges> elements is NULL" );
for( j = 0; j <= size[i]; j++ )
{
float val = ranges[i][j];
if( val <= val0 )
CV_ERROR(CV_StsOutOfRange, "Bin ranges should go in ascenting order");
val0 = dim_ranges[j] = val;
}
hist->thresh2[i] = dim_ranges;
dim_ranges += size[i] + 1;
}
hist->type |= CV_HIST_RANGES_FLAG;
hist->type &= ~CV_HIST_UNIFORM_FLAG;
}
__END__;
}
#define ICV_HIST_DUMMY_IDX (INT_MIN/3)
static CvStatus
icvCalcHistLookupTables8u( const CvHistogram* hist, int dims, int* size, int* tab )
{
const int lo = 0, hi = 256;
int is_sparse = CV_IS_SPARSE_HIST( hist );
int have_range = CV_HIST_HAS_RANGES(hist);
int i, j;
if( !have_range || CV_IS_UNIFORM_HIST(hist))
{
for( i = 0; i < dims; i++ )
{
double a = have_range ? hist->thresh[i][0] : 0;
double b = have_range ? hist->thresh[i][1] : 256;
int sz = size[i];
double scale = sz/(b - a);
int step = 1;
if( !is_sparse )
step = ((CvMatND*)(hist->bins))->dim[i].step/sizeof(float);
for( j = lo; j < hi; j++ )
{
int idx = cvFloor((j - a)*scale);
if( (unsigned)idx < (unsigned)sz )
idx *= step;
else
idx = ICV_HIST_DUMMY_IDX;
tab[i*(hi - lo) + j - lo] = idx;
}
}
}
else
{
for( i = 0; i < dims; i++ )
{
double limit = hist->thresh2[i][0];
int idx = -1, write_idx = ICV_HIST_DUMMY_IDX, sz = size[i];
int step = 1;
if( !is_sparse )
step = ((CvMatND*)(hist->bins))->dim[i].step/sizeof(float);
if( limit > hi )
limit = hi;
j = lo;
for(;;)
{
for( ; j < limit; j++ )
tab[i*(hi - lo) + j - lo] = write_idx;
if( (unsigned)(++idx) < (unsigned)sz )
{
limit = hist->thresh2[i][idx+1];
if( limit > hi )
limit = hi;
write_idx = idx*step;
}
else
{
for( ; j < hi; j++ )
tab[i*(hi - lo) + j - lo] = ICV_HIST_DUMMY_IDX;
break;
}
}
}
}
return CV_OK;
}
/***************************** C A L C H I S T O G R A M *************************/
// Calculates histogram for one or more 8u arrays
static CvStatus CV_STDCALL
icvCalcHist_8u_C1R( uchar** img, int step, uchar* mask, int maskStep,
CvSize size, CvHistogram* hist )
{
int* tab;
int is_sparse = CV_IS_SPARSE_HIST(hist);
int dims, histsize[CV_MAX_DIM];
int i, x;
CvStatus status;
dims = cvGetDims( hist->bins, histsize );
tab = (int*)cvStackAlloc( dims*256*sizeof(int));
status = icvCalcHistLookupTables8u( hist, dims, histsize, tab );
if( status < 0 )
return status;
if( !is_sparse )
{
int total = 1;
int* bins = ((CvMatND*)(hist->bins))->data.i;
for( i = 0; i < dims; i++ )
total *= histsize[i];
if( dims <= 3 && total >= -ICV_HIST_DUMMY_IDX )
return CV_BADSIZE_ERR; // too big histogram
switch( dims )
{
case 1:
{
int tab1d[256];
memset( tab1d, 0, sizeof(tab1d));
for( ; size.height--; img[0] += step )
{
uchar* ptr = img[0];
if( !mask )
{
for( x = 0; x <= size.width - 4; x += 4 )
{
int v0 = ptr[x];
int v1 = ptr[x+1];
tab1d[v0]++;
tab1d[v1]++;
v0 = ptr[x+2];
v1 = ptr[x+3];
tab1d[v0]++;
tab1d[v1]++;
}
for( ; x < size.width; x++ )
tab1d[ptr[x]]++;
}
else
{
for( x = 0; x < size.width; x++ )
if( mask[x] )
tab1d[ptr[x]]++;
mask += maskStep;
}
}
for( i = 0; i < 256; i++ )
{
int idx = tab[i];
if( idx >= 0 )
bins[idx] += tab1d[i];
}
}
break;
case 2:
for( ; size.height--; img[0] += step, img[1] += step )
{
uchar* ptr0 = img[0];
uchar* ptr1 = img[1];
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int idx = tab[v0] + tab[256+v1];
if( idx >= 0 )
bins[idx]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int idx = tab[v0] + tab[256+v1];
if( idx >= 0 )
bins[idx]++;
}
}
mask += maskStep;
}
}
break;
case 3:
for( ; size.height--; img[0] += step, img[1] += step, img[2] += step )
{
uchar* ptr0 = img[0];
uchar* ptr1 = img[1];
uchar* ptr2 = img[2];
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int v2 = ptr2[x];
int idx = tab[v0] + tab[256+v1] + tab[512+v2];
if( idx >= 0 )
bins[idx]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int v2 = ptr2[x];
int idx = tab[v0] + tab[256+v1] + tab[512+v2];
if( idx >= 0 )
bins[idx]++;
}
}
mask += maskStep;
}
}
break;
default:
for( ; size.height--; )
{
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
int* binptr = bins;
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
binptr += idx;
}
if( i == dims )
binptr[0]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
int* binptr = bins;
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
binptr += idx;
}
if( i == dims )
binptr[0]++;
}
}
mask += maskStep;
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
int node_idx[CV_MAX_DIM];
for( ; size.height--; )
{
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
node_idx[i] = idx;
}
if( i == dims )
{
int* bin = (int*)cvPtrND( mat, node_idx, 0, 1 );
bin[0]++;
}
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
node_idx[i] = idx;
}
if( i == dims )
{
int* bin = (int*)cvPtrND( mat, node_idx, 0, 1, 0 );
bin[0]++;
}
}
}
mask += maskStep;
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
return CV_OK;
}
// Calculates histogram for one or more 32f arrays
static CvStatus CV_STDCALL
icvCalcHist_32f_C1R( float** img, int step, uchar* mask, int maskStep,
CvSize size, CvHistogram* hist )
{
int is_sparse = CV_IS_SPARSE_HIST(hist);
int uniform = CV_IS_UNIFORM_HIST(hist);
int dims, histsize[CV_MAX_DIM];
double uni_range[CV_MAX_DIM][2];
int i, x;
dims = cvGetDims( hist->bins, histsize );
step /= sizeof(img[0][0]);
if( uniform )
{
for( i = 0; i < dims; i++ )
{
double t = histsize[i]/((double)hist->thresh[i][1] - hist->thresh[i][0]);
uni_range[i][0] = t;
uni_range[i][1] = -t*hist->thresh[i][0];
}
}
if( !is_sparse )
{
CvMatND* mat = (CvMatND*)(hist->bins);
int* bins = mat->data.i;
if( uniform )
{
switch( dims )
{
case 1:
{
double a = uni_range[0][0], b = uni_range[0][1];
int sz = histsize[0];
for( ; size.height--; img[0] += step )
{
float* ptr = img[0];
if( !mask )
{
for( x = 0; x <= size.width - 4; x += 4 )
{
int v0 = cvFloor(ptr[x]*a + b);
int v1 = cvFloor(ptr[x+1]*a + b);
if( (unsigned)v0 < (unsigned)sz )
bins[v0]++;
if( (unsigned)v1 < (unsigned)sz )
bins[v1]++;
v0 = cvFloor(ptr[x+2]*a + b);
v1 = cvFloor(ptr[x+3]*a + b);
if( (unsigned)v0 < (unsigned)sz )
bins[v0]++;
if( (unsigned)v1 < (unsigned)sz )
bins[v1]++;
}
for( ; x < size.width; x++ )
{
int v0 = cvFloor(ptr[x]*a + b);
if( (unsigned)v0 < (unsigned)sz )
bins[v0]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
if( mask[x] )
{
int v0 = cvFloor(ptr[x]*a + b);
if( (unsigned)v0 < (unsigned)sz )
bins[v0]++;
}
mask += maskStep;
}
}
}
break;
case 2:
{
double a0 = uni_range[0][0], b0 = uni_range[0][1];
double a1 = uni_range[1][0], b1 = uni_range[1][1];
int sz0 = histsize[0], sz1 = histsize[1];
int step0 = ((CvMatND*)(hist->bins))->dim[0].step/sizeof(float);
for( ; size.height--; img[0] += step, img[1] += step )
{
float* ptr0 = img[0];
float* ptr1 = img[1];
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
int v0 = cvFloor( ptr0[x]*a0 + b0 );
int v1 = cvFloor( ptr1[x]*a1 + b1 );
if( (unsigned)v0 < (unsigned)sz0 &&
(unsigned)v1 < (unsigned)sz1 )
bins[v0*step0 + v1]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
int v0 = cvFloor( ptr0[x]*a0 + b0 );
int v1 = cvFloor( ptr1[x]*a1 + b1 );
if( (unsigned)v0 < (unsigned)sz0 &&
(unsigned)v1 < (unsigned)sz1 )
bins[v0*step0 + v1]++;
}
}
mask += maskStep;
}
}
}
break;
default:
for( ; size.height--; )
{
if( !mask )
{
for( x = 0; x < size.width; x++ )
{
int* binptr = bins;
for( i = 0; i < dims; i++ )
{
int idx = cvFloor((double)img[i][x]*uni_range[i][0]
+ uni_range[i][1]);
if( (unsigned)idx >= (unsigned)histsize[i] )
break;
binptr += idx*(mat->dim[i].step/sizeof(float));
}
if( i == dims )
binptr[0]++;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( mask[x] )
{
int* binptr = bins;
for( i = 0; i < dims; i++ )
{
int idx = cvFloor((double)img[i][x]*uni_range[i][0]
+ uni_range[i][1]);
if( (unsigned)idx >= (unsigned)histsize[i] )
break;
binptr += idx*(mat->dim[i].step/sizeof(float));
}
if( i == dims )
binptr[0]++;
}
}
mask += maskStep;
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
}
else
{
for( ; size.height--; )
{
for( x = 0; x < size.width; x++ )
{
if( !mask || mask[x] )
{
int* binptr = bins;
for( i = 0; i < dims; i++ )
{
float v = img[i][x];
float* thresh = hist->thresh2[i];
int idx = -1, sz = histsize[i];
while( v >= thresh[idx+1] && ++idx < sz )
/* nop */;
if( (unsigned)idx >= (unsigned)sz )
break;
binptr += idx*(mat->dim[i].step/sizeof(float));
}
if( i == dims )
binptr[0]++;
}
}
for( i = 0; i < dims; i++ )
img[i] += step;
if( mask )
mask += maskStep;
}
}
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
int node_idx[CV_MAX_DIM];
for( ; size.height--; )
{
if( uniform )
{
for( x = 0; x < size.width; x++ )
{
if( !mask || mask[x] )
{
for( i = 0; i < dims; i++ )
{
int idx = cvFloor(img[i][x]*uni_range[i][0]
+ uni_range[i][1]);
if( (unsigned)idx >= (unsigned)histsize[i] )
break;
node_idx[i] = idx;
}
if( i == dims )
{
int* bin = (int*)cvPtrND( mat, node_idx, 0, 1, 0 );
bin[0]++;
}
}
}
}
else
{
for( x = 0; x < size.width; x++ )
{
if( !mask || mask[x] )
{
for( i = 0; i < dims; i++ )
{
float v = img[i][x];
float* thresh = hist->thresh2[i];
int idx = -1, sz = histsize[i];
while( v >= thresh[idx+1] && ++idx < sz )
/* nop */;
if( (unsigned)idx >= (unsigned)sz )
break;
node_idx[i] = idx;
}
if( i == dims )
{
int* bin = (int*)cvPtrND( mat, node_idx, 0, 1, 0 );
bin[0]++;
}
}
}
}
for( i = 0; i < dims; i++ )
img[i] += step;
if( mask )
mask += maskStep;
}
}
return CV_OK;
}
CV_IMPL void
cvCalcArrHist( CvArr** img, CvHistogram* hist,
int do_not_clear, const CvArr* mask )
{
CV_FUNCNAME( "cvCalcHist" );
__BEGIN__;
uchar* ptr[CV_MAX_DIM];
uchar* maskptr = 0;
int maskstep = 0, step = 0;
int i, dims;
int cont_flag = -1;
CvMat stub0, *mat0 = 0;
CvMatND dense;
CvSize size;
if( !CV_IS_HIST(hist))
CV_ERROR( CV_StsBadArg, "Bad histogram pointer" );
if( !img )
CV_ERROR( CV_StsNullPtr, "Null double array pointer" );
CV_CALL( dims = cvGetDims( hist->bins ));
for( i = 0; i < dims; i++ )
{
CvMat stub, *mat = (CvMat*)img[i];
CV_CALL( mat = cvGetMat( mat, i == 0 ? &stub0 : &stub, 0, 1 ));
if( CV_MAT_CN( mat->type ) != 1 )
CV_ERROR( CV_BadNumChannels, "Only 1-channel arrays are allowed here" );
if( i == 0 )
{
mat0 = mat;
step = mat0->step;
}
else
{
if( !CV_ARE_SIZES_EQ( mat0, mat ))
CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal sizes" );
if( mat0->step != mat->step )
CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal steps" );
if( !CV_ARE_TYPES_EQ( mat0, mat ))
CV_ERROR( CV_StsUnmatchedFormats, "Not all the planes have equal types" );
}
cont_flag &= mat->type;
ptr[i] = mat->data.ptr;
}
if( mask )
{
CvMat stub, *mat = (CvMat*)mask;
CV_CALL( mat = cvGetMat( mat, &stub, 0, 1 ));
if( !CV_IS_MASK_ARR(mat))
CV_ERROR( CV_StsBadMask, "Bad mask array" );
if( !CV_ARE_SIZES_EQ( mat0, mat ))
CV_ERROR( CV_StsUnmatchedSizes,
"Mask size does not match to other arrays\' size" );
maskptr = mat->data.ptr;
maskstep = mat->step;
cont_flag &= mat->type;
}
size = cvGetMatSize(mat0);
if( CV_IS_MAT_CONT( cont_flag ))
{
size.width *= size.height;
size.height = 1;
maskstep = step = CV_STUB_STEP;
}
if( !CV_IS_SPARSE_HIST(hist))
{
dense = *(CvMatND*)hist->bins;
dense.type = (dense.type & ~CV_MAT_TYPE_MASK) | CV_32SC1;
}
if( !do_not_clear )
{
CV_CALL( cvZero( hist->bins ));
}
else if( !CV_IS_SPARSE_HIST(hist))
{
CV_CALL( cvConvert( (CvMatND*)hist->bins, &dense ));
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
CvSparseMatIterator iterator;
CvSparseNode* node;
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
Cv32suf* val = (Cv32suf*)CV_NODE_VAL( mat, node );
val->i = cvRound( val->f );
}
}
if( CV_MAT_DEPTH(mat0->type) > CV_8S && !CV_HIST_HAS_RANGES(hist))
CV_ERROR( CV_StsBadArg, "histogram ranges must be set (via cvSetHistBinRanges) "
"before calling the function" );
switch( CV_MAT_DEPTH(mat0->type) )
{
case CV_8U:
IPPI_CALL( icvCalcHist_8u_C1R( ptr, step, maskptr, maskstep, size, hist ));
break;
case CV_32F:
{
union { uchar** ptr; float** fl; } v;
v.ptr = ptr;
IPPI_CALL( icvCalcHist_32f_C1R( v.fl, step, maskptr, maskstep, size, hist ));
}
break;
default:
CV_ERROR( CV_StsUnsupportedFormat, "Unsupported array type" );
}
if( !CV_IS_SPARSE_HIST(hist))
{
CV_CALL( cvConvert( &dense, (CvMatND*)hist->bins ));
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
CvSparseMatIterator iterator;
CvSparseNode* node;
for( node = cvInitSparseMatIterator( mat, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
Cv32suf* val = (Cv32suf*)CV_NODE_VAL( mat, node );
val->f = (float)val->i;
}
}
__END__;
}
/***************************** B A C K P R O J E C T *****************************/
// Calculates back project for one or more 8u arrays
static CvStatus CV_STDCALL
icvCalcBackProject_8u_C1R( uchar** img, int step, uchar* dst, int dstStep,
CvSize size, const CvHistogram* hist )
{
const int small_hist_size = 1<<12;
int* tab = 0;
int is_sparse = CV_IS_SPARSE_HIST(hist);
int dims, histsize[CV_MAX_DIM];
int i, x;
CvStatus status;
dims = cvGetDims( hist->bins, histsize );
tab = (int*)cvStackAlloc( dims*256*sizeof(int));
status = icvCalcHistLookupTables8u( hist, dims, histsize, tab );
if( status < 0 )
return status;
if( !is_sparse )
{
int total = 1;
CvMatND* mat = (CvMatND*)(hist->bins);
float* bins = mat->data.fl;
uchar* buffer = 0;
for( i = 0; i < dims; i++ )
total *= histsize[i];
if( dims <= 3 && total >= -ICV_HIST_DUMMY_IDX )
return CV_BADSIZE_ERR; // too big histogram
if( dims > 1 && total <= small_hist_size && CV_IS_MAT_CONT(mat->type))
{
buffer = (uchar*)cvAlloc(total);
if( !buffer )
return CV_OUTOFMEM_ERR;
for( i = 0; i < total; i++ )
{
int v = cvRound(bins[i]);
buffer[i] = CV_CAST_8U(v);
}
}
switch( dims )
{
case 1:
{
uchar tab1d[256];
for( i = 0; i < 256; i++ )
{
int idx = tab[i];
if( idx >= 0 )
{
int v = cvRound(bins[idx]);
tab1d[i] = CV_CAST_8U(v);
}
else
tab1d[i] = 0;
}
for( ; size.height--; img[0] += step, dst += dstStep )
{
uchar* ptr = img[0];
for( x = 0; x <= size.width - 4; x += 4 )
{
uchar v0 = tab1d[ptr[x]];
uchar v1 = tab1d[ptr[x+1]];
dst[x] = v0;
dst[x+1] = v1;
v0 = tab1d[ptr[x+2]];
v1 = tab1d[ptr[x+3]];
dst[x+2] = v0;
dst[x+3] = v1;
}
for( ; x < size.width; x++ )
dst[x] = tab1d[ptr[x]];
}
}
break;
case 2:
for( ; size.height--; img[0] += step, img[1] += step, dst += dstStep )
{
uchar* ptr0 = img[0];
uchar* ptr1 = img[1];
if( buffer )
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int idx = tab[v0] + tab[256+v1];
int v = 0;
if( idx >= 0 )
v = buffer[idx];
dst[x] = (uchar)v;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int idx = tab[v0] + tab[256+v1];
int v = 0;
if( idx >= 0 )
{
v = cvRound(bins[idx]);
v = CV_CAST_8U(v);
}
dst[x] = (uchar)v;
}
}
}
break;
case 3:
for( ; size.height--; img[0] += step, img[1] += step,
img[2] += step, dst += dstStep )
{
uchar* ptr0 = img[0];
uchar* ptr1 = img[1];
uchar* ptr2 = img[2];
if( buffer )
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int v2 = ptr2[x];
int idx = tab[v0] + tab[256+v1] + tab[512+v2];
int v = 0;
if( idx >= 0 )
v = buffer[idx];
dst[x] = (uchar)v;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
int v0 = ptr0[x];
int v1 = ptr1[x];
int v2 = ptr2[x];
int idx = tab[v0] + tab[256+v1] + tab[512+v2];
int v = 0;
if( idx >= 0 )
{
v = cvRound(bins[idx]);
v = CV_CAST_8U(v);
}
dst[x] = (uchar)v;
}
}
}
break;
default:
for( ; size.height--; dst += dstStep )
{
if( buffer )
{
for( x = 0; x < size.width; x++ )
{
uchar* binptr = buffer;
int v = 0;
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
binptr += idx;
}
if( i == dims )
v = binptr[0];
dst[x] = (uchar)v;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
float* binptr = bins;
int v = 0;
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
binptr += idx;
}
if( i == dims )
{
v = cvRound( binptr[0] );
v = CV_CAST_8U(v);
}
dst[x] = (uchar)v;
}
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
cvFree( &buffer );
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
int node_idx[CV_MAX_DIM];
for( ; size.height--; dst += dstStep )
{
for( x = 0; x < size.width; x++ )
{
int v = 0;
for( i = 0; i < dims; i++ )
{
int idx = tab[i*256 + img[i][x]];
if( idx < 0 )
break;
node_idx[i] = idx;
}
if( i == dims )
{
float* bin = (float*)cvPtrND( mat, node_idx, 0, 1, 0 );
v = cvRound(bin[0]);
v = CV_CAST_8U(v);
}
dst[x] = (uchar)v;
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
return CV_OK;
}
// Calculates back project for one or more 32f arrays
static CvStatus CV_STDCALL
icvCalcBackProject_32f_C1R( float** img, int step, float* dst, int dstStep,
CvSize size, const CvHistogram* hist )
{
int is_sparse = CV_IS_SPARSE_HIST(hist);
int uniform = CV_IS_UNIFORM_HIST(hist);
int dims, histsize[CV_MAX_DIM];
double uni_range[CV_MAX_DIM][2];
int i, x;
dims = cvGetDims( hist->bins, histsize );
step /= sizeof(img[0][0]);
dstStep /= sizeof(dst[0]);
if( uniform )
{
for( i = 0; i < dims; i++ )
{
double t = ((double)histsize[i])/
((double)hist->thresh[i][1] - hist->thresh[i][0]);
uni_range[i][0] = t;
uni_range[i][1] = -t*hist->thresh[i][0];
}
}
if( !is_sparse )
{
CvMatND* mat = (CvMatND*)(hist->bins);
float* bins = mat->data.fl;
if( uniform )
{
switch( dims )
{
case 1:
{
double a = uni_range[0][0], b = uni_range[0][1];
int sz = histsize[0];
for( ; size.height--; img[0] += step, dst += dstStep )
{
float* ptr = img[0];
for( x = 0; x <= size.width - 4; x += 4 )
{
int v0 = cvFloor(ptr[x]*a + b);
int v1 = cvFloor(ptr[x+1]*a + b);
if( (unsigned)v0 < (unsigned)sz )
dst[x] = bins[v0];
else
dst[x] = 0;
if( (unsigned)v1 < (unsigned)sz )
dst[x+1] = bins[v1];
else
dst[x+1] = 0;
v0 = cvFloor(ptr[x+2]*a + b);
v1 = cvFloor(ptr[x+3]*a + b);
if( (unsigned)v0 < (unsigned)sz )
dst[x+2] = bins[v0];
else
dst[x+2] = 0;
if( (unsigned)v1 < (unsigned)sz )
dst[x+3] = bins[v1];
else
dst[x+3] = 0;
}
for( ; x < size.width; x++ )
{
int v0 = cvFloor(ptr[x]*a + b);
if( (unsigned)v0 < (unsigned)sz )
dst[x] = bins[v0];
else
dst[x] = 0;
}
}
}
break;
case 2:
{
double a0 = uni_range[0][0], b0 = uni_range[0][1];
double a1 = uni_range[1][0], b1 = uni_range[1][1];
int sz0 = histsize[0], sz1 = histsize[1];
int step0 = ((CvMatND*)(hist->bins))->dim[0].step/sizeof(float);
for( ; size.height--; img[0] += step, img[1] += step, dst += dstStep )
{
float* ptr0 = img[0];
float* ptr1 = img[1];
for( x = 0; x < size.width; x++ )
{
int v0 = cvFloor( ptr0[x]*a0 + b0 );
int v1 = cvFloor( ptr1[x]*a1 + b1 );
if( (unsigned)v0 < (unsigned)sz0 &&
(unsigned)v1 < (unsigned)sz1 )
dst[x] = bins[v0*step0 + v1];
else
dst[x] = 0;
}
}
}
break;
default:
for( ; size.height--; dst += dstStep )
{
for( x = 0; x < size.width; x++ )
{
float* binptr = bins;
for( i = 0; i < dims; i++ )
{
int idx = cvFloor(img[i][x]*uni_range[i][0]
+ uni_range[i][1]);
if( (unsigned)idx >= (unsigned)histsize[i] )
break;
binptr += idx*(mat->dim[i].step/sizeof(float));
}
if( i == dims )
dst[x] = binptr[0];
else
dst[x] = 0;
}
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
else
{
for( ; size.height--; dst += dstStep )
{
for( x = 0; x < size.width; x++ )
{
float* binptr = bins;
for( i = 0; i < dims; i++ )
{
float v = img[i][x];
float* thresh = hist->thresh2[i];
int idx = -1, sz = histsize[i];
while( v >= thresh[idx+1] && ++idx < sz )
/* nop */;
if( (unsigned)idx >= (unsigned)sz )
break;
binptr += idx*(mat->dim[i].step/sizeof(float));
}
if( i == dims )
dst[x] = binptr[0];
else
dst[x] = 0;
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
}
else
{
CvSparseMat* mat = (CvSparseMat*)(hist->bins);
int node_idx[CV_MAX_DIM];
for( ; size.height--; dst += dstStep )
{
if( uniform )
{
for( x = 0; x < size.width; x++ )
{
for( i = 0; i < dims; i++ )
{
int idx = cvFloor(img[i][x]*uni_range[i][0]
+ uni_range[i][1]);
if( (unsigned)idx >= (unsigned)histsize[i] )
break;
node_idx[i] = idx;
}
if( i == dims )
{
float* bin = (float*)cvPtrND( mat, node_idx, 0, 1, 0 );
dst[x] = bin[0];
}
else
dst[x] = 0;
}
}
else
{
for( x = 0; x < size.width; x++ )
{
for( i = 0; i < dims; i++ )
{
float v = img[i][x];
float* thresh = hist->thresh2[i];
int idx = -1, sz = histsize[i];
while( v >= thresh[idx+1] && ++idx < sz )
/* nop */;
if( (unsigned)idx >= (unsigned)sz )
break;
node_idx[i] = idx;
}
if( i == dims )
{
float* bin = (float*)cvPtrND( mat, node_idx, 0, 1, 0 );
dst[x] = bin[0];
}
else
dst[x] = 0;
}
}
for( i = 0; i < dims; i++ )
img[i] += step;
}
}
return CV_OK;
}
CV_IMPL void
cvCalcArrBackProject( CvArr** img, CvArr* dst, const CvHistogram* hist )
{
CV_FUNCNAME( "cvCalcArrBackProject" );
__BEGIN__;
uchar* ptr[CV_MAX_DIM];
uchar* dstptr = 0;
int dststep = 0, step = 0;
int i, dims;
int cont_flag = -1;
CvMat stub0, *mat0 = 0;
CvSize size;
if( !CV_IS_HIST(hist))
CV_ERROR( CV_StsBadArg, "Bad histogram pointer" );
if( !img )
CV_ERROR( CV_StsNullPtr, "Null double array pointer" );
CV_CALL( dims = cvGetDims( hist->bins ));
for( i = 0; i <= dims; i++ )
{
CvMat stub, *mat = (CvMat*)(i < dims ? img[i] : dst);
CV_CALL( mat = cvGetMat( mat, i == 0 ? &stub0 : &stub, 0, 1 ));
if( CV_MAT_CN( mat->type ) != 1 )
CV_ERROR( CV_BadNumChannels, "Only 1-channel arrays are allowed here" );
if( i == 0 )
{
mat0 = mat;
step = mat0->step;
}
else
{
if( !CV_ARE_SIZES_EQ( mat0, mat ))
CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal sizes" );
if( mat0->step != mat->step )
CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal steps" );
if( !CV_ARE_TYPES_EQ( mat0, mat ))
CV_ERROR( CV_StsUnmatchedFormats, "Not all the planes have equal types" );
}
cont_flag &= mat->type;
if( i < dims )
ptr[i] = mat->data.ptr;
else
{
dstptr = mat->data.ptr;
dststep = mat->step;
}
}
size = cvGetMatSize(mat0);
if( CV_IS_MAT_CONT( cont_flag ))
{
size.width *= size.height;
size.height = 1;
dststep = step = CV_STUB_STEP;
}
if( CV_MAT_DEPTH(mat0->type) > CV_8S && !CV_HIST_HAS_RANGES(hist))
CV_ERROR( CV_StsBadArg, "histogram ranges must be set (via cvSetHistBinRanges) "
"before calling the function" );
switch( CV_MAT_DEPTH(mat0->type) )
{
case CV_8U:
IPPI_CALL( icvCalcBackProject_8u_C1R( ptr, step, dstptr, dststep, size, hist ));
break;
case CV_32F:
{
union { uchar** ptr; float** fl; } v;
v.ptr = ptr;
IPPI_CALL( icvCalcBackProject_32f_C1R( v.fl, step,
(float*)dstptr, dststep, size, hist ));
}
break;
default:
CV_ERROR( CV_StsUnsupportedFormat, "Unsupported array type" );
}
__END__;
}
////////////////////// B A C K P R O J E C T P A T C H /////////////////////////
CV_IMPL void
cvCalcArrBackProjectPatch( CvArr** arr, CvArr* dst, CvSize patch_size, CvHistogram* hist,
int method, double norm_factor )
{
CvHistogram* model = 0;
CV_FUNCNAME( "cvCalcArrBackProjectPatch" );
__BEGIN__;
IplImage imgstub[CV_MAX_DIM], *img[CV_MAX_DIM];
IplROI roi;
CvMat dststub, *dstmat;
int i, dims;
int x, y;
CvSize size;
if( !CV_IS_HIST(hist))
CV_ERROR( CV_StsBadArg, "Bad histogram pointer" );
if( !arr )
CV_ERROR( CV_StsNullPtr, "Null double array pointer" );
if( norm_factor <= 0 )
CV_ERROR( CV_StsOutOfRange,
"Bad normalization factor (set it to 1.0 if unsure)" );
if( patch_size.width <= 0 || patch_size.height <= 0 )
CV_ERROR( CV_StsBadSize, "The patch width and height must be positive" );
CV_CALL( dims = cvGetDims( hist->bins ));
CV_CALL( cvCopyHist( hist, &model ));
CV_CALL( cvNormalizeHist( hist, norm_factor ));
for( i = 0; i < dims; i++ )
{
CvMat stub, *mat;
CV_CALL( mat = cvGetMat( arr[i], &stub, 0, 0 ));
CV_CALL( img[i] = cvGetImage( mat, &imgstub[i] ));
img[i]->roi = &roi;
}
CV_CALL( dstmat = cvGetMat( dst, &dststub, 0, 0 ));
if( CV_MAT_TYPE( dstmat->type ) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Resultant image must have 32fC1 type" );
if( dstmat->cols != img[0]->width - patch_size.width + 1 ||
dstmat->rows != img[0]->height - patch_size.height + 1 )
CV_ERROR( CV_StsUnmatchedSizes,
"The output map must be (W-w+1 x H-h+1), "
"where the input images are (W x H) each and the patch is (w x h)" );
size = cvGetMatSize(dstmat);
roi.coi = 0;
roi.width = patch_size.width;
roi.height = patch_size.height;
for( y = 0; y < size.height; y++ )
{
for( x = 0; x < size.width; x++ )
{
double result;
roi.xOffset = x;
roi.yOffset = y;
CV_CALL( cvCalcHist( img, model ));
CV_CALL( cvNormalizeHist( model, norm_factor ));
CV_CALL( result = cvCompareHist( model, hist, method ));
CV_MAT_ELEM( *dstmat, float, y, x ) = (float)result;
}
}
__END__;
cvReleaseHist( &model );
}
// Calculates Bayes probabilistic histograms
CV_IMPL void
cvCalcBayesianProb( CvHistogram** src, int count, CvHistogram** dst )
{
CV_FUNCNAME( "cvCalcBayesianProb" );
__BEGIN__;
int i;
if( !src || !dst )
CV_ERROR( CV_StsNullPtr, "NULL histogram array pointer" );
if( count < 2 )
CV_ERROR( CV_StsOutOfRange, "Too small number of histograms" );
for( i = 0; i < count; i++ )
{
if( !CV_IS_HIST(src[i]) || !CV_IS_HIST(dst[i]) )
CV_ERROR( CV_StsBadArg, "Invalid histogram header" );
if( !CV_IS_MATND(src[i]->bins) || !CV_IS_MATND(dst[i]->bins) )
CV_ERROR( CV_StsBadArg, "The function supports dense histograms only" );
}
cvZero( dst[0]->bins );
// dst[0] = src[0] + ... + src[count-1]
for( i = 0; i < count; i++ )
CV_CALL( cvAdd( src[i]->bins, dst[0]->bins, dst[0]->bins ));
CV_CALL( cvDiv( 0, dst[0]->bins, dst[0]->bins ));
// dst[i] = src[i]*(1/dst[0])
for( i = count - 1; i >= 0; i-- )
CV_CALL( cvMul( src[i]->bins, dst[0]->bins, dst[i]->bins ));
__END__;
}
CV_IMPL void
cvCalcProbDensity( const CvHistogram* hist, const CvHistogram* hist_mask,
CvHistogram* hist_dens, double scale )
{
CV_FUNCNAME( "cvCalcProbDensity" );
__BEGIN__;
if( scale <= 0 )
CV_ERROR( CV_StsOutOfRange, "scale must be positive" );
if( !CV_IS_HIST(hist) || !CV_IS_HIST(hist_mask) || !CV_IS_HIST(hist_dens) )
CV_ERROR( CV_StsBadArg, "Invalid histogram pointer[s]" );
{
CvArr* arrs[] = { hist->bins, hist_mask->bins, hist_dens->bins };
CvMatND stubs[3];
CvNArrayIterator iterator;
CV_CALL( cvInitNArrayIterator( 3, arrs, 0, stubs, &iterator ));
if( CV_MAT_TYPE(iterator.hdr[0]->type) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "All histograms must have 32fC1 type" );
do
{
const float* srcdata = (const float*)(iterator.ptr[0]);
const float* maskdata = (const float*)(iterator.ptr[1]);
float* dstdata = (float*)(iterator.ptr[2]);
int i;
for( i = 0; i < iterator.size.width; i++ )
{
float s = srcdata[i];
float m = maskdata[i];
if( s > FLT_EPSILON )
if( m <= s )
dstdata[i] = (float)(m*scale/s);
else
dstdata[i] = (float)scale;
else
dstdata[i] = (float)0;
}
}
while( cvNextNArraySlice( &iterator ));
}
__END__;
}
CV_IMPL void cvEqualizeHist( const CvArr* src, CvArr* dst )
{
CvHistogram* hist = 0;
CvMat* lut = 0;
CV_FUNCNAME( "cvEqualizeHist" );
__BEGIN__;
int i, hist_sz = 256;
CvSize img_sz;
float scale;
float* h;
int sum = 0;
int type;
CV_CALL( type = cvGetElemType( src ));
if( type != CV_8UC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Only 8uC1 images are supported" );
CV_CALL( hist = cvCreateHist( 1, &hist_sz, CV_HIST_ARRAY ));
CV_CALL( lut = cvCreateMat( 1, 256, CV_8UC1 ));
CV_CALL( cvCalcArrHist( (CvArr**)&src, hist ));
CV_CALL( img_sz = cvGetSize( src ));
scale = 255.f/(img_sz.width*img_sz.height);
h = (float*)cvPtr1D( hist->bins, 0 );
for( i = 0; i < hist_sz; i++ )
{
sum += cvRound(h[i]);
lut->data.ptr[i] = (uchar)cvRound(sum*scale);
}
lut->data.ptr[0] = 0;
CV_CALL( cvLUT( src, dst, lut ));
__END__;
cvReleaseHist(&hist);
cvReleaseMat(&lut);
}
/* Implementation of RTTI and Generic Functions for CvHistogram */
#define CV_TYPE_NAME_HIST "opencv-hist"
static int icvIsHist( const void * ptr ){
return CV_IS_HIST( ((CvHistogram*)ptr) );
}
static CvHistogram * icvCloneHist( const CvHistogram * src ){
CvHistogram * dst=NULL;
cvCopyHist(src, &dst);
return dst;
}
static void *icvReadHist( CvFileStorage * fs, CvFileNode * node ){
CvHistogram * h = 0;
int is_uniform = 0;
int have_ranges = 0;
CV_FUNCNAME("icvReadHist");
__BEGIN__;
CV_CALL( h = (CvHistogram *) cvAlloc( sizeof(CvHistogram) ));
is_uniform = cvReadIntByName( fs, node, "is_uniform", 0 );
have_ranges = cvReadIntByName( fs, node, "have_ranges", 0);
h->type = CV_HIST_MAGIC_VAL |
(is_uniform ? CV_HIST_UNIFORM_FLAG : 0) |
(have_ranges ? CV_HIST_RANGES_FLAG : 0);
if(is_uniform){
// read histogram bins
CvMatND * mat = (CvMatND *) cvReadByName( fs, node, "mat" );
int sizes[CV_MAX_DIM];
int i;
if(!CV_IS_MATND(mat)){
CV_ERROR( CV_StsError, "Expected CvMatND");
}
for(i=0; i<mat->dims; i++){
sizes[i] = mat->dim[i].size;
}
cvInitMatNDHeader( &(h->mat), mat->dims, sizes, mat->type, mat->data.ptr );
h->bins = &(h->mat);
// take ownership of refcount pointer as well
h->mat.refcount = mat->refcount;
// increase refcount so freeing temp header doesn't free data
cvIncRefData( mat );
// free temporary header
cvReleaseMatND( &mat );
}
else{
h->bins = cvReadByName( fs, node, "bins" );
if(!CV_IS_SPARSE_MAT(h->bins)){
CV_ERROR( CV_StsError, "Unknown Histogram type");
}
}
// read thresholds
if(have_ranges){
int i;
int dims;
int size[CV_MAX_DIM];
int total = 0;
CvSeqReader reader;
CvFileNode * thresh_node;
CV_CALL( dims = cvGetDims( h->bins, size ));
for( i = 0; i < dims; i++ ){
total += size[i]+1;
}
thresh_node = cvGetFileNodeByName( fs, node, "thresh" );
if(!thresh_node){
CV_ERROR( CV_StsError, "'thresh' node is missing");
}
cvStartReadRawData( fs, thresh_node, &reader );
if(is_uniform){
for(i=0; i<dims; i++){
cvReadRawDataSlice( fs, &reader, 2, h->thresh[i], "f" );
}
h->thresh2 = NULL;
}
else{
float* dim_ranges;
CV_CALL( h->thresh2 = (float**)cvAlloc(
dims*sizeof(h->thresh2[0])+
total*sizeof(h->thresh2[0][0])));
dim_ranges = (float*)(h->thresh2 + dims);
for(i=0; i < dims; i++){
h->thresh2[i] = dim_ranges;
cvReadRawDataSlice( fs, &reader, size[i]+1, dim_ranges, "f" );
dim_ranges += size[i] + 1;
}
}
}
__END__;
return h;
}
static void icvWriteHist( CvFileStorage* fs, const char* name, const void* struct_ptr,
CvAttrList /*attributes*/ ){
const CvHistogram * hist = (const CvHistogram *) struct_ptr;
int sizes[CV_MAX_DIM];
int dims;
int i;
int is_uniform, have_ranges;
CV_FUNCNAME("icvWriteHist");
__BEGIN__;
cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_HIST );
is_uniform = (CV_IS_UNIFORM_HIST(hist) ? 1 : 0);
have_ranges = (hist->type & CV_HIST_RANGES_FLAG ? 1 : 0);
cvWriteInt( fs, "is_uniform", is_uniform );
cvWriteInt( fs, "have_ranges", have_ranges );
if(CV_IS_UNIFORM_HIST(hist)){
cvWrite( fs, "mat", &(hist->mat) );
}
else if(CV_IS_SPARSE_HIST(hist)){
cvWrite( fs, "bins", hist->bins );
}
else{
CV_ERROR( CV_StsError, "Unknown Histogram Type" );
}
// write thresholds
if(have_ranges){
dims = cvGetDims( hist->bins, sizes );
cvStartWriteStruct( fs, "thresh", CV_NODE_SEQ + CV_NODE_FLOW );
if(is_uniform){
for(i=0; i<dims; i++){
cvWriteRawData( fs, hist->thresh[i], 2, "f" );
}
}
else{
for(i=0; i<dims; i++){
cvWriteRawData( fs, hist->thresh2[i], sizes[i]+1, "f" );
}
}
cvEndWriteStruct( fs );
}
cvEndWriteStruct( fs );
__END__;
}
CvType hist_type( CV_TYPE_NAME_HIST, icvIsHist, (CvReleaseFunc)cvReleaseHist,
icvReadHist, icvWriteHist, (CvCloneFunc)icvCloneHist );
/* End of file. */