void YARPLpFirstOrderFlow::_alloc_kernels(void)
{
// LATER: improve this filter. Use separable Kernel.
// defines gauss matrix required for filtering
// this has to be reimplemented completely.
// -the double precision values make no sense.
// -gaussian filtering is separable.
// -I feel ashamed I haven't checked this piece of code before.
float Values[25];
Values[0] = Values[4] = Values[20] = Values[24] = (float)(3.50262697022767075306479859894e-3);
Values[1] = Values[3] = Values[5] = Values[9] = Values[15] = Values[19] = Values[21] = Values[23] = (float)(1.22591943957968476357267950963e-2);
Values[2] = Values[10] = Values[14] = Values[22] = (float)(2.10157618213660245183887915936e-2);
Values[6] = Values[8] = Values[16] = Values[18] = (float)(5.42907180385288966725043782837e-2);
Values[7] = Values[11] = Values[13] = Values[17] = (float)(9.10683012259194395796847635726e-2);
Values[12] = (float)(0.22241681260945709281961471103327);
// Gaussian Kernel
Gauss = iplCreateConvKernelFP (5, 5, 2, 2, Values);
assert (Gauss != NULL);
float KernelValues_Five[5];
KernelValues_Five[0] = (float)-0.0833333;
KernelValues_Five[1] = (float)0.6666667;
KernelValues_Five[2] = 0.0;
KernelValues_Five[3] = (float)-0.6666667;
KernelValues_Five[4] = (float)0.0833333;
// X Derivative Kernel
DerivX = iplCreateConvKernelFP(5, 1, 2, 0, KernelValues_Five);
assert (DerivX != NULL);
// Y Derivative Kernel
DerivY = iplCreateConvKernelFP(1, 5, 0, 2, KernelValues_Five);
assert (DerivY != NULL);
}
IplConvKernelFP* IPLConvKernelFP(CFloatImage kernel, bool vertical = false)
{
// Convert from a floating point image to a floating point kernel
CShape sh = kernel.Shape();
std::vector<float> values; // temporary storage for values
values.resize(sh.width * sh.height);
for (int y = 0, k = 0; y < sh.height; y++)
for (int x = 0; x < sh.width; x++, k++)
values[k] = kernel.Pixel(x, y, 0);
int nCols = (vertical) ? sh.height : sh.width;
int nRows = (vertical) ? sh.width : sh.height;
int anchorX = -kernel.origin[(vertical) ? 1 : 0];
int anchorY = -kernel.origin[(vertical) ? 0 : 1];
return iplCreateConvKernelFP(nCols, nRows, anchorX, anchorY, &values[0]);
}
static int fcaScharr( void )
{
int KerX[15];
int KerY[15];
CvSize KerLens;
int dx,dy;
AtsRandState state;
AtsRandState sizegen;
double Error = 0;
IplImage* src8u;
IplImage* src8s;
IplImage* src32f;
IplImage* src16;
IplImage* dst16;
IplImage* test16;
IplImage* dst32f;
IplImage* test32f;
IplImage* buf;
IplConvKernel* KernelX;
IplConvKernel* KernelY;
IplConvKernelFP* KX;
IplConvKernelFP* KY;
/* Initialization global parameters */
if( !read_param )
{
read_param = 1;
/* Determining which test are needed to run */
trsCaseRead( &data_types,"/u/s/f/a", "a",
"u - unsigned char, s - signed char, f - float, a - all" );
/* Reading test-parameters */
trsiRead( &lMinImageSize, "16", "Image height" );
trsiRead( &lMaxImageSize, "256", "Image width" );
trsiRead( &lTestNum, "20", "Test count" );
}
if( data_types != 3 && data_types != 0 ) return TRS_UNDEF;
atsRandInit(&sizegen,lMinImageSize,lMaxImageSize,0);
/* Creating images for testing */
for(int i = 0; i < lTestNum; i++)
{
lImageWidth = atsRand32s(&sizegen);
lImageHeight = atsRand32s(&sizegen);
src8u= cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_8U, 1);
src8s= cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_8S, 1);
src32f = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
src16 = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_16S, 1);
dst16 = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_16S, 1);
test16 = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_16S, 1);
buf = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
dst32f = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
test32f = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
atsRandInit(&state,0,64,32);
atsFillRandomImageEx(src8u, &state );
atsFillRandomImageEx(src8s, &state );
atsFillRandomImageEx(src32f, &state );
/* Calculating the kernels */
for(dx = 0; dx<=1; dx++)
{
dy=1-dx;
atsCalcKernel(cv8u,dx,dy,CV_SCHARR,(char*)KerX,(char*)KerY,&KerLens,CV_ORIGIN_TL);
KernelX = iplCreateConvKernel(KerLens.width,1,KerLens.width/2,0,KerX,0);
KernelY = iplCreateConvKernel(1,KerLens.height,0,KerLens.height/2,KerY,0);
/* Calculating the convolution */
atsConvert(src8u,src16);
iplSetBorderMode(src16,
IPL_BORDER_REPLICATE,
IPL_SIDE_TOP|IPL_SIDE_BOTTOM|IPL_SIDE_RIGHT|IPL_SIDE_LEFT,
0);
iplConvolveSep2D(src16,dst16,KernelX,KernelY);
cvSobel(src8u,test16,dx,dy,CV_SCHARR);
Error += iplNorm(dst16,test16,IPL_C);
atsConvert(src8s,src16);
iplSetBorderMode(src16,
IPL_BORDER_REPLICATE,
IPL_SIDE_TOP|IPL_SIDE_BOTTOM|IPL_SIDE_RIGHT|IPL_SIDE_LEFT,
0);
iplSetBorderMode(src16,
IPL_BORDER_REPLICATE,
IPL_SIDE_TOP|IPL_SIDE_BOTTOM|IPL_SIDE_RIGHT|IPL_SIDE_LEFT,
0);
iplConvolveSep2D(src16,dst16,KernelX,KernelY);
cvSobel(src8s,test16,dx,dy,CV_SCHARR);
Error += iplNorm(dst16,test16,IPL_C);
atsCalcKernel(IPL_DEPTH_32F,dx,dy,CV_SCHARR,(char*)KerX,(char*)KerY,&KerLens,CV_ORIGIN_TL);
KX = iplCreateConvKernelFP(KerLens.width,1,KerLens.width/2,0,(float*)KerX);
KY = iplCreateConvKernelFP(1,KerLens.height,0,KerLens.height/2,(float*)KerY);
iplSetBorderMode(src32f,
IPL_BORDER_REPLICATE,
IPL_SIDE_TOP|IPL_SIDE_BOTTOM|IPL_SIDE_RIGHT|IPL_SIDE_LEFT,
0);
/* Calculating the convolution */
iplConvolveSep2DFP(src32f,dst32f,KX,KY);
cvSobel(src32f,test32f,dx,dy,CV_SCHARR);
/*for(i = 0; i<lImageHeight; i++)
for(int j = 0; j<lImageWidth; j++)
{
float a = ((float*)(dst32f->imageData))[i*dst32f->widthStep/4+j];
float b = ((float*)(test32f->imageData))[i*test32f->widthStep/4+j];
}
*/
Error += iplNorm(test32f,dst32f,IPL_C);
iplDeleteConvKernel(KernelX);
iplDeleteConvKernel(KernelY);
iplDeleteConvKernelFP(KX);
iplDeleteConvKernelFP(KY);
}
/* Free Memory */
cvReleaseImage( &src8u );
cvReleaseImage( &src8s );
cvReleaseImage( &src32f );
cvReleaseImage( &src16 );
cvReleaseImage( &dst16 );
cvReleaseImage( &test16 );
cvReleaseImage( &dst32f );
cvReleaseImage( &test32f );
cvReleaseImage( &buf);
}
if(Error/lTestNum>=EPSILON)return TRS_FAIL;
return TRS_OK;
} /* fcaSobel8uC1R */
