inline void subtract_maskf(BitPlane* mask, BitPlane* result, BitPlane* backgrnd, BitPlane* src, DWORD border)
{
diffBitPlane(result,backgrnd,src,border);
andBitPlane(result, mask, result, 0x10101010);
monochrome(result,result);
createmaskf(result,result,border);
maskFilter(result,src,result);
}
void P6::Monochrome(const char* filename)
{
if (isGrayMonochrome() == true)
{
cout << "The image is already monochrome \n";
return;
}
else
{
char* newName = ChangeFileName(filename, "_monochrome.ppm");
ofstream outFile(newName, ios::out);
if (!outFile)
{
cerr << "Cannot write P6 file \n";
return;
}
char magic_pbm[3] = "P6";
outFile << magic_pbm << endl << getWidth() << " " << getHeight() << endl << getMaxNum() << endl;
int r = 0, g = 0, b = 0;
for (int i = 0; i < getHeight(); i++)
{
for (int j = 0; j < getWidth(); j++)
{
r = getPixels()[i][j].getRed();
g = getPixels()[i][j].getGreen();
b = getPixels()[i][j].getBlue();
int gray = grayscale(r, g, b);
int m = monochrome(gray);
outFile.write((const char*)&m, sizeof(char));
outFile.write((const char*)&m, sizeof(char));
outFile.write((const char*)&m, sizeof(char));
}
}
outFile.flush();
outFile.close();
delete[] newName;
}
}
int runFilter(int argc, char *argv[])
{
char * filenameInput=argv[1];
char * filenameOutput=argv[2];
unsigned int inputType = guessFilenameTypeStupid(filenameInput);
struct Image * inputImage = readImage(filenameInput,inputType,0);
struct Image * outputImage = 0; //This will get allocated when and if needed
if (inputImage!=0)
{
unsigned int outputType = guessFilenameTypeStupid(filenameOutput);
unsigned int i=0;
for (i=0; i<argc; i++)
{
if ( strcmp(argv[i],"--learn")==0 )
{
destroyImage(inputImage);
learnImage(filenameInput,atoi(argv[i+1]),atoi(argv[i+2]));
exit(0);
} else
if ( strcmp(argv[i],"--rgbcube")==0 )
{
unsigned int dim=32;
unsigned char R = (char) atoi(argv[i]+1);
unsigned char G = (char) atoi(argv[i]+2);
unsigned char B = (char) atoi(argv[i]+3);
outputImage = createImage( dim , dim , 3 , 8 );
bitbltColorRGB(outputImage->pixels , 0 , 0 , dim , dim , R , G , B , dim-1 , dim-1);
writeImageFile(outputImage,PPM_CODEC ,"new_mX.pnm");
writeImageFile(outputImage,PPM_CODEC ,"new_pX.pnm");
writeImageFile(outputImage,PPM_CODEC ,"new_mY.pnm");
writeImageFile(outputImage,PPM_CODEC ,"new_pY.pnm");
writeImageFile(outputImage,PPM_CODEC ,"new_mZ.pnm");
writeImageFile(outputImage,PPM_CODEC ,"new_pZ.pnm");
destroyImage(outputImage);
} else
if ( strcmp(argv[i],"--envcube")==0 )
{
fprintf(stdout,"Converting Environment Cube \n");
unsigned int outputType = guessFilenameTypeStupid(filenameOutput);
//outputImage = createSameDimensionsImage(inputImage);
unsigned int outputWidth = inputImage->width;
unsigned int outputHeight = (unsigned int ) (3*inputImage->width)/4;
outputImage = createImage( outputWidth , outputHeight , 3 , 8 );
createCubeMapFace( outputImage->pixels , outputImage->width , outputImage->height , outputImage->channels , outputImage->bitsperpixel ,
inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels , inputImage->bitsperpixel
);
struct Image * partImg=0;
unsigned int outX=0 , outY=0 , outWidth=0 , outHeight=0;
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ -1 , /*y*/ 0 , /*z*/ 0 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_mX.pnm"); destroyImage(partImg);
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ 1 , /*y*/ 0 , /*z*/ 0 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_pX.pnm"); destroyImage(partImg);
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ 0 , /*y*/ -1 , /*z*/ 0 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_mY.pnm"); destroyImage(partImg);
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ 0 , /*y*/ 1 , /*z*/ 0 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_pY.pnm"); destroyImage(partImg);
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ 0 , /*y*/ 0 , /*z*/ -1 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_mZ.pnm"); destroyImage(partImg);
getCubeMap2DCoords(outputWidth,outputHeight, /*x*/ 0 , /*y*/ 0 , /*z*/ 1 , &outX , &outY , &outWidth , &outHeight );
partImg=createImageBitBlt( outputImage , outX , outY , outWidth , outHeight );
writeImageFile(partImg,PPM_CODEC ,"new_pZ.pnm"); destroyImage(partImg);
} else
if ( strcmp(argv[i],"--compare")==0 )
{
unsigned int outputType = guessFilenameTypeStupid(filenameOutput);
outputImage = readImage(filenameOutput,outputType ,0);
float noise = calculatePSNR( outputImage->pixels , outputImage->width , outputImage->height , outputImage->channels ,
inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels );
fprintf(stdout,"Compared Detected Noise is %0.4f dB \n",noise);
exit(0);
} else
if ( strcmp(argv[i],"--gaussian")==0 )
{
monochrome(inputImage);
outputImage = createSameDimensionsImage(inputImage);
unsigned int normalizeGaussianKernel=1;
unsigned int kernelWidth=5;
unsigned int kernelHeight=5;
float * convolutionMatrix=allocateGaussianKernel(kernelWidth,kernelHeight,normalizeGaussianKernel);
float divisor=1.0;
float * inF = copyUCharImage2Float(inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels );
float * outF = (float*) malloc(sizeof(float) * outputImage->width * outputImage->height * outputImage->channels );
convolutionFilter1ChF(
outF , outputImage->width , outputImage->height ,
inF, inputImage->width , inputImage->height ,
convolutionMatrix , kernelWidth , kernelHeight , &divisor
);
free(convolutionMatrix);
castFloatImage2UChar(outputImage->pixels, outF, outputImage->width , outputImage->height , outputImage->channels );
free(inF);
free(outF);
} else
if ( strcmp(argv[i],"--ctbilateral")==0 )
{
monochrome(inputImage);
outputImage = createSameDimensionsImage(inputImage);
float sigma = atof(argv[i+1]);
constantTimeBilateralFilter(
inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels ,
outputImage->pixels , outputImage->width , outputImage->height
,&sigma //sigma
,atoi(argv[i+2]) //bins
,atoi(argv[i+3]) //useDeriche
);
} else
if ( strcmp(argv[i],"--deriche")==0 )
{
monochrome(inputImage);
outputImage = createSameDimensionsImage(inputImage);
float sigma = atof(argv[i+1]);
dericheRecursiveGaussianGray( outputImage->pixels , outputImage->width , outputImage->height , inputImage->channels ,
inputImage->pixels , inputImage->width , inputImage->height ,
&sigma , atoi(argv[i+2])
);
} else
if ( strcmp(argv[i],"--dericheF")==0 )
{
fprintf(stderr,"This is a test call for casting code , this shouldnt be normally used..\n");
monochrome(inputImage);
outputImage = createSameDimensionsImage(inputImage);
float sigma = atof(argv[i+1]);
//outputImage = copyImage(inputImage);
float * inF = copyUCharImage2Float(inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels );
float * outF = (float*) malloc(sizeof(float) * outputImage->width * outputImage->height * outputImage->channels );
dericheRecursiveGaussianGrayF( outF , outputImage->width , outputImage->height , inputImage->channels ,
inF , inputImage->width , inputImage->height ,
&sigma , atoi(argv[i+2])
);
castFloatImage2UChar(outputImage->pixels, outF, outputImage->width , outputImage->height , outputImage->channels );
free(inF);
free(outF);
} else
if ( strcmp(argv[i],"--median")==0 )
{
outputImage = copyImage(inputImage);
medianFilter3ch(
outputImage->pixels , outputImage->width , outputImage->height ,
inputImage->pixels , inputImage->width , inputImage->height ,
atoi(argv[i+1]) , atoi(argv[i+2])
);
} else
if ( strcmp(argv[i],"--meansat")==0 )
{
outputImage = copyImage(inputImage);
meanFilterSAT(
outputImage->pixels , outputImage->width , outputImage->height , outputImage->channels ,
inputImage->pixels , inputImage->width , inputImage->height , inputImage->channels ,
atoi(argv[i+1]) , atoi(argv[i+2])
);
} else
if ( strcmp(argv[i],"--monochrome")==0 )
{
outputImage = copyImage(inputImage);
monochrome(outputImage);
} else
if ( strcmp(argv[i],"--bilateral")==0 )
{
outputImage = copyImage(inputImage);
bilateralFilter( outputImage->pixels , outputImage->width , outputImage->height ,
inputImage->pixels , inputImage->width , inputImage->height ,
atof(argv[i+1]) , atof(argv[i+2]) , atoi(argv[i+3])
);
} else
if ( strcmp(argv[i],"--contrast")==0 )
{
outputImage = copyImage(inputImage);
contrast(outputImage,atof(argv[i+1]));
} else
if ( strcmp(argv[i],"--sattest")==0 )
{
float * tmp = allocateGaussianKernel(3,5.0,1);
if (tmp!=0) { free(tmp); }
tmp = allocateGaussianKernel(9,5.0,1);
if (tmp!=0) { free(tmp); }
tmp = allocateGaussianKernel(15,5.0,1);
if (tmp!=0) { free(tmp); }
summedAreaTableTest();
unsigned int * integralImageOutput = 0;
integralImageOutput = generateSummedAreaTableRGB(inputImage->pixels , inputImage->width , inputImage->height);
if (integralImageOutput!=0)
{
free(integralImageOutput);
fprintf(stderr,"integralImage test was successful\n");
}
}
}
writeImageFile(outputImage,outputType ,filenameOutput);
destroyImage(outputImage);
destroyImage(inputImage);
return 1;
}
return 0;
}
int openCV_SURFDetector(struct Image * pattern,struct Image * img)
{
StartTimer(FIND_OBJECTS_DELAY);
monochrome(img);
IplImage * image = cvCreateImage( cvSize(img->width,img->height), IPL_DEPTH_8U, img->depth);
char * opencvImagePointerRetainer = image->imageData; // UGLY HACK
image->imageData = (char*) img->pixels; // UGLY HACK
//cvCvtColor( image, image, CV_RGB2GRAY);
monochrome(pattern);
IplImage * object = cvCreateImage( cvSize(pattern->width,pattern->height), IPL_DEPTH_8U, pattern->depth);
char * opencvObjectPointerRetainer = object->imageData; // UGLY HACK
object->imageData = (char*) pattern->pixels; // UGLY HACK
//cvCvtColor( object, object, CV_RGB2GRAY);
CvMemStorage* storage = cvCreateMemStorage(0);
static CvScalar colors[] = { {{0,0,255}}, {{0,128,255}}, {{0,255,255}}, {{0,255,0}}, {{255,128,0}}, {{255,255,0}}, {{255,0,0}}, {{255,0,255}}, {{255,255,255}} };
IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
cvCvtColor( object, object_color, CV_GRAY2BGR );
CvSeq* objectKeypoints = 0, *objectDescriptors = 0;
CvSeq* imageKeypoints = 0, *imageDescriptors = 0;
int i;
CvSURFParams params = cvSURFParams(500, 1);
double tt = (double)cvGetTickCount();
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params , 0 );
//printf("Object Descriptors: %d\n", objectDescriptors->total);
cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params , 0 );
//printf("Image Descriptors: %d\n", imageDescriptors->total);
tt = (double)cvGetTickCount() - tt;
//printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
//IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
//cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
//cvCopy( object, correspond , 0 );
//cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
//cvCopy( image, correspond , 0 );
//cvResetImageROI( correspond );
if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
//cvLine( correspond, cvPoint(r1.x, r1.y+object->height ), cvPoint(r2.x, r2.y+object->height ), colors[8] , 1 ,8 ,0 );
}
}
struct pairList * ptpairs = 0;
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
printf(" Found %u pairs \n",(int) ptpairs->currentItems);
image->imageData = opencvImagePointerRetainer; // UGLY HACK
cvReleaseImage( &image );
image->imageData = opencvObjectPointerRetainer; // UGLY HACK
cvReleaseImage( &object );
EndTimer(FIND_OBJECTS_DELAY);
/*
for( i = 0; i < (int)ptpairs->currentItems; i++ )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs->item[i].p1; );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs->item[i].p2; );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}
cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color );
cvWaitKey(0);
cvDestroyWindow("Object");
cvDestroyWindow("Object Correspond");
*/
return 1;
}
