+++ /dev/null
-/*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*/
-
-/****************************************************************************************\
-
- Calculation of a texture descriptors from GLCM (Grey Level Co-occurrence Matrix'es)
- The code was submitted by Daniel Eaton [danieljameseaton@yahoo.com]
-
-\****************************************************************************************/
-
-#include "_cvaux.h"
-
-#include <math.h>
-#include <assert.h>
-
-#define CV_MAX_NUM_GREY_LEVELS_8U 256
-
-struct CvGLCM
-{
- int matrixSideLength;
- int numMatrices;
- double*** matrices;
-
- int numLookupTableElements;
- int forwardLookupTable[CV_MAX_NUM_GREY_LEVELS_8U];
- int reverseLookupTable[CV_MAX_NUM_GREY_LEVELS_8U];
-
- double** descriptors;
- int numDescriptors;
- int descriptorOptimizationType;
- int optimizationType;
-};
-
-
-static void icvCreateGLCM_LookupTable_8u_C1R( const uchar* srcImageData, int srcImageStep,
- CvSize srcImageSize, CvGLCM* destGLCM,
- int* steps, int numSteps, int* memorySteps );
-
-static void
-icvCreateGLCMDescriptors_AllowDoubleNest( CvGLCM* destGLCM, int matrixIndex );
-
-
-CV_IMPL CvGLCM*
-cvCreateGLCM( const IplImage* srcImage,
- int stepMagnitude,
- const int* srcStepDirections,/* should be static array..
- or if not the user should handle de-allocation */
- int numStepDirections,
- int optimizationType )
-{
- static const int defaultStepDirections[] = { 0,1, -1,1, -1,0, -1,-1 };
-
- int* memorySteps = 0;
- CvGLCM* newGLCM = 0;
- int* stepDirections = 0;
-
- CV_FUNCNAME( "cvCreateGLCM" );
-
- __BEGIN__;
-
- uchar* srcImageData = 0;
- CvSize srcImageSize;
- int srcImageStep;
- int stepLoop;
- const int maxNumGreyLevels8u = CV_MAX_NUM_GREY_LEVELS_8U;
-
- if( !srcImage )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( srcImage->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, "Number of channels must be 1");
-
- if( srcImage->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, "Depth must be equal IPL_DEPTH_8U");
-
- // no Directions provided, use the default ones - 0 deg, 45, 90, 135
- if( !srcStepDirections )
- {
- srcStepDirections = defaultStepDirections;
- }
-
- CV_CALL( stepDirections = (int*)cvAlloc( numStepDirections*2*sizeof(stepDirections[0])));
- memcpy( stepDirections, srcStepDirections, numStepDirections*2*sizeof(stepDirections[0]));
-
- cvGetImageRawData( srcImage, &srcImageData, &srcImageStep, &srcImageSize );
-
- // roll together Directions and magnitudes together with knowledge of image (step)
- CV_CALL( memorySteps = (int*)cvAlloc( numStepDirections*sizeof(memorySteps[0])));
-
- for( stepLoop = 0; stepLoop < numStepDirections; stepLoop++ )
- {
- stepDirections[stepLoop*2 + 0] *= stepMagnitude;
- stepDirections[stepLoop*2 + 1] *= stepMagnitude;
-
- memorySteps[stepLoop] = stepDirections[stepLoop*2 + 0]*srcImageStep +
- stepDirections[stepLoop*2 + 1];
- }
-
- CV_CALL( newGLCM = (CvGLCM*)cvAlloc(sizeof(newGLCM)));
- memset( newGLCM, 0, sizeof(newGLCM) );
-
- newGLCM->matrices = 0;
- newGLCM->numMatrices = numStepDirections;
- newGLCM->optimizationType = optimizationType;
-
- if( optimizationType <= CV_GLCM_OPTIMIZATION_LUT )
- {
- int lookupTableLoop, imageColLoop, imageRowLoop, lineOffset = 0;
-
- // if optimization type is set to lut, then make one for the image
- if( optimizationType == CV_GLCM_OPTIMIZATION_LUT )
- {
- for( imageRowLoop = 0; imageRowLoop < srcImageSize.height;
- imageRowLoop++, lineOffset += srcImageStep )
- {
- for( imageColLoop = 0; imageColLoop < srcImageSize.width; imageColLoop++ )
- {
- newGLCM->forwardLookupTable[srcImageData[lineOffset+imageColLoop]]=1;
- }
- }
-
- newGLCM->numLookupTableElements = 0;
-
- for( lookupTableLoop = 0; lookupTableLoop < maxNumGreyLevels8u; lookupTableLoop++ )
- {
- if( newGLCM->forwardLookupTable[ lookupTableLoop ] != 0 )
- {
- newGLCM->forwardLookupTable[ lookupTableLoop ] =
- newGLCM->numLookupTableElements;
- newGLCM->reverseLookupTable[ newGLCM->numLookupTableElements ] =
- lookupTableLoop;
-
- newGLCM->numLookupTableElements++;
- }
- }
- }
- // otherwise make a "LUT" which contains all the gray-levels (for code-reuse)
- else if( optimizationType == CV_GLCM_OPTIMIZATION_NONE )
- {
- for( lookupTableLoop = 0; lookupTableLoop <maxNumGreyLevels8u; lookupTableLoop++ )
- {
- newGLCM->forwardLookupTable[ lookupTableLoop ] = lookupTableLoop;
- newGLCM->reverseLookupTable[ lookupTableLoop ] = lookupTableLoop;
- }
- newGLCM->numLookupTableElements = maxNumGreyLevels8u;
- }
-
- newGLCM->matrixSideLength = newGLCM->numLookupTableElements;
- icvCreateGLCM_LookupTable_8u_C1R( srcImageData, srcImageStep, srcImageSize,
- newGLCM, stepDirections,
- numStepDirections, memorySteps );
- }
- else if( optimizationType == CV_GLCM_OPTIMIZATION_HISTOGRAM )
- {
- CV_ERROR( CV_StsBadFlag, "Histogram-based method is not implemented" );
-
- /* newGLCM->numMatrices *= 2;
- newGLCM->matrixSideLength = maxNumGreyLevels8u*2;
-
- icvCreateGLCM_Histogram_8uC1R( srcImageStep, srcImageSize, srcImageData,
- newGLCM, numStepDirections,
- stepDirections, memorySteps );
- */
- }
-
- __END__;
-
- cvFree( &memorySteps );
- cvFree( &stepDirections );
-
- if( cvGetErrStatus() < 0 )
- {
- cvFree( &newGLCM );
- }
-
- return newGLCM;
-}
-
-
-CV_IMPL void
-cvReleaseGLCM( CvGLCM** GLCM, int flag )
-{
- CV_FUNCNAME( "cvReleaseGLCM" );
-
- __BEGIN__;
-
- int matrixLoop;
-
- if( !GLCM )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( *GLCM )
- EXIT; // repeated deallocation: just skip it.
-
- if( (flag == CV_GLCM_GLCM || flag == CV_GLCM_ALL) && (*GLCM)->matrices )
- {
- for( matrixLoop = 0; matrixLoop < (*GLCM)->numMatrices; matrixLoop++ )
- {
- if( (*GLCM)->matrices[ matrixLoop ] )
- {
- cvFree( (*GLCM)->matrices[matrixLoop] );
- cvFree( (*GLCM)->matrices + matrixLoop );
- }
- }
-
- cvFree( &((*GLCM)->matrices) );
- }
-
- if( (flag == CV_GLCM_DESC || flag == CV_GLCM_ALL) && (*GLCM)->descriptors )
- {
- for( matrixLoop = 0; matrixLoop < (*GLCM)->numMatrices; matrixLoop++ )
- {
- cvFree( (*GLCM)->descriptors + matrixLoop );
- }
- cvFree( &((*GLCM)->descriptors) );
- }
-
- if( flag == CV_GLCM_ALL )
- {
- cvFree( GLCM );
- }
-
- __END__;
-}
-
-
-static void
-icvCreateGLCM_LookupTable_8u_C1R( const uchar* srcImageData,
- int srcImageStep,
- CvSize srcImageSize,
- CvGLCM* destGLCM,
- int* steps,
- int numSteps,
- int* memorySteps )
-{
- int* stepIncrementsCounter = 0;
-
- CV_FUNCNAME( "icvCreateGLCM_LookupTable_8u_C1R" );
-
- __BEGIN__;
-
- int matrixSideLength = destGLCM->matrixSideLength;
- int stepLoop, sideLoop1, sideLoop2;
- int colLoop, rowLoop, lineOffset = 0;
- double*** matrices = 0;
-
- // allocate memory to the matrices
- CV_CALL( destGLCM->matrices = (double***)cvAlloc( sizeof(matrices[0])*numSteps ));
- matrices = destGLCM->matrices;
-
- for( stepLoop=0; stepLoop<numSteps; stepLoop++ )
- {
- CV_CALL( matrices[stepLoop] = (double**)cvAlloc( sizeof(matrices[0])*matrixSideLength ));
- CV_CALL( matrices[stepLoop][0] = (double*)cvAlloc( sizeof(matrices[0][0])*
- matrixSideLength*matrixSideLength ));
-
- memset( matrices[stepLoop][0], 0, matrixSideLength*matrixSideLength*
- sizeof(matrices[0][0]) );
-
- for( sideLoop1 = 1; sideLoop1 < matrixSideLength; sideLoop1++ )
- {
- matrices[stepLoop][sideLoop1] = matrices[stepLoop][sideLoop1-1] + matrixSideLength;
- }
- }
-
- CV_CALL( stepIncrementsCounter = (int*)cvAlloc( numSteps*sizeof(stepIncrementsCounter[0])));
- memset( stepIncrementsCounter, 0, numSteps*sizeof(stepIncrementsCounter[0]) );
-
- // generate GLCM for each step
- for( rowLoop=0; rowLoop<srcImageSize.height; rowLoop++, lineOffset+=srcImageStep )
- {
- for( colLoop=0; colLoop<srcImageSize.width; colLoop++ )
- {
- int pixelValue1 = destGLCM->forwardLookupTable[srcImageData[lineOffset + colLoop]];
-
- for( stepLoop=0; stepLoop<numSteps; stepLoop++ )
- {
- int col2, row2;
- row2 = rowLoop + steps[stepLoop*2 + 0];
- col2 = colLoop + steps[stepLoop*2 + 1];
-
- if( col2>=0 && row2>=0 && col2<srcImageSize.width && row2<srcImageSize.height )
- {
- int memoryStep = memorySteps[ stepLoop ];
- int pixelValue2 = destGLCM->forwardLookupTable[ srcImageData[ lineOffset + colLoop + memoryStep ] ];
-
- // maintain symmetry
- matrices[stepLoop][pixelValue1][pixelValue2] ++;
- matrices[stepLoop][pixelValue2][pixelValue1] ++;
-
- // incremenet counter of total number of increments
- stepIncrementsCounter[stepLoop] += 2;
- }
- }
- }
- }
-
- // normalize matrices. each element is a probability of gray value i,j adjacency in direction/magnitude k
- for( sideLoop1=0; sideLoop1<matrixSideLength; sideLoop1++ )
- {
- for( sideLoop2=0; sideLoop2<matrixSideLength; sideLoop2++ )
- {
- for( stepLoop=0; stepLoop<numSteps; stepLoop++ )
- {
- matrices[stepLoop][sideLoop1][sideLoop2] /= double(stepIncrementsCounter[stepLoop]);
- }
- }
- }
-
- destGLCM->matrices = matrices;
-
- __END__;
-
- cvFree( &stepIncrementsCounter );
-
- if( cvGetErrStatus() < 0 )
- cvReleaseGLCM( &destGLCM, CV_GLCM_GLCM );
-}
-
-
-CV_IMPL void
-cvCreateGLCMDescriptors( CvGLCM* destGLCM, int descriptorOptimizationType )
-{
- CV_FUNCNAME( "cvCreateGLCMDescriptors" );
-
- __BEGIN__;
-
- int matrixLoop;
-
- if( !destGLCM )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( !(destGLCM->matrices) )
- CV_ERROR( CV_StsNullPtr, "Matrices are not allocated" );
-
- CV_CALL( cvReleaseGLCM( &destGLCM, CV_GLCM_DESC ));
-
- if( destGLCM->optimizationType != CV_GLCM_OPTIMIZATION_HISTOGRAM )
- {
- destGLCM->descriptorOptimizationType = destGLCM->numDescriptors = descriptorOptimizationType;
- }
- else
- {
- CV_ERROR( CV_StsBadFlag, "Histogram-based method is not implemented" );
-// destGLCM->descriptorOptimizationType = destGLCM->numDescriptors = CV_GLCMDESC_OPTIMIZATION_HISTOGRAM;
- }
-
- CV_CALL( destGLCM->descriptors = (double**)
- cvAlloc( destGLCM->numMatrices*sizeof(destGLCM->descriptors[0])));
-
- for( matrixLoop = 0; matrixLoop < destGLCM->numMatrices; matrixLoop ++ )
- {
- CV_CALL( destGLCM->descriptors[ matrixLoop ] =
- (double*)cvAlloc( destGLCM->numDescriptors*sizeof(destGLCM->descriptors[0][0])));
- memset( destGLCM->descriptors[matrixLoop], 0, destGLCM->numDescriptors*sizeof(double) );
-
- switch( destGLCM->descriptorOptimizationType )
- {
- case CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST:
- icvCreateGLCMDescriptors_AllowDoubleNest( destGLCM, matrixLoop );
- break;
- default:
- CV_ERROR( CV_StsBadFlag,
- "descriptorOptimizationType different from CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST\n"
- "is not supported" );
- /*
- case CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST:
- icvCreateGLCMDescriptors_AllowTripleNest( destGLCM, matrixLoop );
- break;
- case CV_GLCMDESC_OPTIMIZATION_HISTOGRAM:
- if(matrixLoop < destGLCM->numMatrices>>1)
- icvCreateGLCMDescriptors_Histogram( destGLCM, matrixLoop);
- break;
- */
- }
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 )
- cvReleaseGLCM( &destGLCM, CV_GLCM_DESC );
-}
-
-
-static void
-icvCreateGLCMDescriptors_AllowDoubleNest( CvGLCM* destGLCM, int matrixIndex )
-{
- int sideLoop1, sideLoop2;
- int matrixSideLength = destGLCM->matrixSideLength;
-
- double** matrix = destGLCM->matrices[ matrixIndex ];
- double* descriptors = destGLCM->descriptors[ matrixIndex ];
-
- double* marginalProbability =
- (double*)cvAlloc( matrixSideLength * sizeof(marginalProbability[0]));
- memset( marginalProbability, 0, matrixSideLength * sizeof(double) );
-
- double maximumProbability = 0;
- double marginalProbabilityEntropy = 0;
- double correlationMean = 0, correlationStdDeviation = 0, correlationProductTerm = 0;
-
- for( sideLoop1=0; sideLoop1<matrixSideLength; sideLoop1++ )
- {
- int actualSideLoop1 = destGLCM->reverseLookupTable[ sideLoop1 ];
-
- for( sideLoop2=0; sideLoop2<matrixSideLength; sideLoop2++ )
- {
- double entryValue = matrix[ sideLoop1 ][ sideLoop2 ];
-
- int actualSideLoop2 = destGLCM->reverseLookupTable[ sideLoop2 ];
- int sideLoopDifference = actualSideLoop1 - actualSideLoop2;
- int sideLoopDifferenceSquared = sideLoopDifference*sideLoopDifference;
-
- marginalProbability[ sideLoop1 ] += entryValue;
- correlationMean += actualSideLoop1*entryValue;
-
- maximumProbability = MAX( maximumProbability, entryValue );
-
- if( actualSideLoop2 > actualSideLoop1 )
- {
- descriptors[ CV_GLCMDESC_CONTRAST ] += sideLoopDifferenceSquared * entryValue;
- }
-
- descriptors[ CV_GLCMDESC_HOMOGENITY ] += entryValue / ( 1.0 + sideLoopDifferenceSquared );
-
- if( entryValue > 0 )
- {
- descriptors[ CV_GLCMDESC_ENTROPY ] += entryValue * log( entryValue );
- }
-
- descriptors[ CV_GLCMDESC_ENERGY ] += entryValue*entryValue;
- }
-
- if( marginalProbability>0 )
- marginalProbabilityEntropy += marginalProbability[ actualSideLoop1 ]*log(marginalProbability[ actualSideLoop1 ]);
- }
-
- marginalProbabilityEntropy = -marginalProbabilityEntropy;
-
- descriptors[ CV_GLCMDESC_CONTRAST ] += descriptors[ CV_GLCMDESC_CONTRAST ];
- descriptors[ CV_GLCMDESC_ENTROPY ] = -descriptors[ CV_GLCMDESC_ENTROPY ];
- descriptors[ CV_GLCMDESC_MAXIMUMPROBABILITY ] = maximumProbability;
-
- double HXY = 0, HXY1 = 0, HXY2 = 0;
-
- HXY = descriptors[ CV_GLCMDESC_ENTROPY ];
-
- for( sideLoop1=0; sideLoop1<matrixSideLength; sideLoop1++ )
- {
- double sideEntryValueSum = 0;
- int actualSideLoop1 = destGLCM->reverseLookupTable[ sideLoop1 ];
-
- for( sideLoop2=0; sideLoop2<matrixSideLength; sideLoop2++ )
- {
- double entryValue = matrix[ sideLoop1 ][ sideLoop2 ];
-
- sideEntryValueSum += entryValue;
-
- int actualSideLoop2 = destGLCM->reverseLookupTable[ sideLoop2 ];
-
- correlationProductTerm += (actualSideLoop1 - correlationMean) * (actualSideLoop2 - correlationMean) * entryValue;
-
- double clusterTerm = actualSideLoop1 + actualSideLoop2 - correlationMean - correlationMean;
-
- descriptors[ CV_GLCMDESC_CLUSTERTENDENCY ] += clusterTerm * clusterTerm * entryValue;
- descriptors[ CV_GLCMDESC_CLUSTERSHADE ] += clusterTerm * clusterTerm * clusterTerm * entryValue;
-
- double HXYValue = marginalProbability[ actualSideLoop1 ] * marginalProbability[ actualSideLoop2 ];
- if( HXYValue>0 )
- {
- double HXYValueLog = log( HXYValue );
- HXY1 += entryValue * HXYValueLog;
- HXY2 += HXYValue * HXYValueLog;
- }
- }
-
- correlationStdDeviation += (actualSideLoop1-correlationMean) * (actualSideLoop1-correlationMean) * sideEntryValueSum;
- }
-
- HXY1 =- HXY1;
- HXY2 =- HXY2;
-
- descriptors[ CV_GLCMDESC_CORRELATIONINFO1 ] = ( HXY - HXY1 ) / ( correlationMean );
- descriptors[ CV_GLCMDESC_CORRELATIONINFO2 ] = sqrt( 1.0 - exp( -2.0 * (HXY2 - HXY ) ) );
-
- correlationStdDeviation = sqrt( correlationStdDeviation );
-
- descriptors[ CV_GLCMDESC_CORRELATION ] = correlationProductTerm / (correlationStdDeviation*correlationStdDeviation );
-
- delete [] marginalProbability;
-}
-
-
-CV_IMPL double cvGetGLCMDescriptor( CvGLCM* GLCM, int step, int descriptor )
-{
- double value = DBL_MAX;
-
- CV_FUNCNAME( "cvGetGLCMDescriptor" );
-
- __BEGIN__;
-
- if( !GLCM )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( !(GLCM->descriptors) )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( (unsigned)step >= (unsigned)(GLCM->numMatrices))
- CV_ERROR( CV_StsOutOfRange, "step is not in 0 .. GLCM->numMatrices - 1" );
-
- if( (unsigned)descriptor >= (unsigned)(GLCM->numDescriptors))
- CV_ERROR( CV_StsOutOfRange, "descriptor is not in 0 .. GLCM->numDescriptors - 1" );
-
- value = GLCM->descriptors[step][descriptor];
-
- __END__;
-
- return value;
-}
-
-
-CV_IMPL void
-cvGetGLCMDescriptorStatistics( CvGLCM* GLCM, int descriptor,
- double* _average, double* _standardDeviation )
-{
- CV_FUNCNAME( "cvGetGLCMDescriptorStatistics" );
-
- if( _average )
- *_average = DBL_MAX;
-
- if( _standardDeviation )
- *_standardDeviation = DBL_MAX;
-
- __BEGIN__;
-
- int matrixLoop, numMatrices;
- double average = 0, squareSum = 0;
-
- if( !GLCM )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( !(GLCM->descriptors))
- CV_ERROR( CV_StsNullPtr, "Descriptors are not calculated" );
-
- if( (unsigned)descriptor >= (unsigned)(GLCM->numDescriptors) )
- CV_ERROR( CV_StsOutOfRange, "Descriptor index is out of range" );
-
- numMatrices = GLCM->numMatrices;
-
- for( matrixLoop = 0; matrixLoop < numMatrices; matrixLoop++ )
- {
- double temp = GLCM->descriptors[ matrixLoop ][ descriptor ];
- average += temp;
- squareSum += temp*temp;
- }
-
- average /= numMatrices;
-
- if( _average )
- *_average = average;
-
- if( _standardDeviation )
- *_standardDeviation = sqrt( (squareSum - average*average*numMatrices)/(numMatrices-1));
-
- __END__;
-}
-
-
-CV_IMPL IplImage*
-cvCreateGLCMImage( CvGLCM* GLCM, int step )
-{
- IplImage* dest = 0;
-
- CV_FUNCNAME( "cvCreateGLCMImage" );
-
- __BEGIN__;
-
- float* destData;
- int sideLoop1, sideLoop2;
-
- if( !GLCM )
- CV_ERROR( CV_StsNullPtr, "" );
-
- if( !(GLCM->matrices) )
- CV_ERROR( CV_StsNullPtr, "Matrices are not allocated" );
-
- if( (unsigned)step >= (unsigned)(GLCM->numMatrices) )
- CV_ERROR( CV_StsOutOfRange, "The step index is out of range" );
-
- dest = cvCreateImage( cvSize( GLCM->matrixSideLength, GLCM->matrixSideLength ), IPL_DEPTH_32F, 1 );
- destData = (float*)(dest->imageData);
-
- for( sideLoop1 = 0; sideLoop1 < GLCM->matrixSideLength;
- sideLoop1++, (float*&)destData += dest->widthStep )
- {
- for( sideLoop2=0; sideLoop2 < GLCM->matrixSideLength; sideLoop2++ )
- {
- double matrixValue = GLCM->matrices[step][sideLoop1][sideLoop2];
- destData[ sideLoop2 ] = (float)matrixValue;
- }
- }
-
- __END__;
-
- if( cvGetErrStatus() < 0 )
- cvReleaseImage( &dest );
-
- return dest;
-}
-
projects / opencv / blobdiff