static int CvGLCM_gc(lua_State*L)
{
luacv_obj<CvGLCM>*obj=(luacv_obj<CvGLCM>*)luaL_checkudata(L,1,CVGLCM_NAME);
if (obj->dealloc_data)
cvReleaseGLCM(&obj->data);
return 0;
}
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][0])*matrixSideLength ));
CV_CALL( matrices[stepLoop][0] = (double*)cvAlloc( sizeof(matrices[0][0][0])*
matrixSideLength*matrixSideLength ));
memset( matrices[stepLoop][0], 0, matrixSideLength*matrixSideLength*
sizeof(matrices[0][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 );
}
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(destGLCM->descriptors[0][0]) );
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 );
}
int main(void)
{
IplImage *src=NULL;
if (0){
src = cvCreateImageHeader(cvSize(4,4),IPL_DEPTH_8U,1);
char rawdata[4][4] = { {0, 0, 1, 1},
{0, 0, 1, 1},
{0, 2, 2, 2},
{2, 2, 3, 3}};
src->imageData = (char*)(&rawdata);
}else{
src = cvLoadImage("test.png",0);
}
CvGLCM* glcm;
// glcm = cvCreateGLCM(src, 1, NULL, 4, CV_GLCM_OPTIMIZATION_LUT);
glcm = cvCreateGLCM(src, 1, NULL, 4, CV_GLCM_OPTIMIZATION_NONE);
cvCreateGLCMDescriptors(glcm, CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST);
//#define CV_GLCMDESC_ENTROPY 0
//#define CV_GLCMDESC_ENERGY 1
//#define CV_GLCMDESC_HOMOGENITY 2
//#define CV_GLCMDESC_CONTRAST 3
//#define CV_GLCMDESC_CLUSTERTENDENCY 4
//#define CV_GLCMDESC_CLUSTERSHADE 5
//#define CV_GLCMDESC_CORRELATION 6
//#define CV_GLCMDESC_CORRELATIONINFO1 7
//#define CV_GLCMDESC_CORRELATIONINFO2 8
//#define CV_GLCMDESC_MAXIMUMPROBABILITY 9
for (int step=0; step<4; step++){
for (int i=0; i<10; i++){
printf("%.3f,", cvGetGLCMDescriptor(glcm, step, i));
}
printf("\n");
}
IplImage *d0org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1);
cvResize(cvCreateGLCMImage(glcm,0),d0org,CV_INTER_NN);
IplImage *d0 = cvCreateImage(cvGetSize(d0org),IPL_DEPTH_8U,1);
cvConvertScaleAbs(d0org,d0,255,0);
cvNormalize(d0,d0,0,255,CV_MINMAX);
cvSaveImage("d0.png",d0);
IplImage *d1org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1);
cvResize(cvCreateGLCMImage(glcm,1),d1org,CV_INTER_NN);
IplImage *d1 = cvCreateImage(cvGetSize(d1org),IPL_DEPTH_8U,1);
cvConvertScaleAbs(d1org,d1,255,0);
cvNormalize(d1,d1,0,255,CV_MINMAX);
cvSaveImage("d1.png",d1);
IplImage *d2org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1);
cvResize(cvCreateGLCMImage(glcm,2),d2org,CV_INTER_NN);
IplImage *d2 = cvCreateImage(cvGetSize(d2org),IPL_DEPTH_8U,1);
cvConvertScaleAbs(d2org,d2,255,0);
cvNormalize(d2,d2,0,255,CV_MINMAX);
cvSaveImage("d2.png",d2);
IplImage *d3org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1);
cvResize(cvCreateGLCMImage(glcm,3),d3org,CV_INTER_NN);
IplImage *d3 = cvCreateImage(cvGetSize(d3org),IPL_DEPTH_8U,1);
cvConvertScaleAbs(d3org,d3,255,0);
cvNormalize(d3,d3,0,255,CV_MINMAX);
cvSaveImage("d3.png",d3);
cvNamedWindow("D0",1);
cvNamedWindow("D1",1);
cvNamedWindow("D2",1);
cvNamedWindow("D3",1);
cvShowImage("D0",d0);
cvShowImage("D1",d1);
cvShowImage("D2",d2);
cvShowImage("D3",d3);
cvWaitKey(0);
cvReleaseGLCM(glcm,CV_GLCM_ALL);
return 0;
}
