VglSimpleBGModel::VglSimpleBGModel(VglImage* img_in, float std_thresh, int window_size, int num_training_images){
this->width = img_in->shape[VGL_WIDTH];
this->height = img_in->shape[VGL_HEIGHT];
this->nChannels = img_in->nChannels;
this->depth = img_in->depth;
if (depth != IPL_DEPTH_8U){
printf("VglSimpleBGModel: Error: depth must be IPL_DEPTH_8U\n");
return;
}
if (num_training_images < 2){
printf("VglSimpleBGModel: Error: num_training_images must be >= 2\n");
return;
}
if (std_thresh <= 0.0){
printf("VglSimpleBGModel: Error: std_thresh must be > 0.0\n");
return;
}
if (window_size < 1){
printf("VglSimpleBGModel: Error: window_size must be >= 1\n");
return;
}
this->num_training_images = num_training_images;
this->std_thresh = std_thresh;
this->window_size = window_size;
foreground = vglCreateImage(img_in); // should be single channel
foregroundClose = vglCreateImage(img_in); // should be single channel
buf = vglCreateImage(img_in); // should be single channel
background32 = vglCreateImage(cvSize(width, height), IPL_DEPTH_32F, nChannels); // should be float
variance32 = vglCreateImage(cvSize(width, height), IPL_DEPTH_32F, nChannels); // should be float
vglClear(foreground, 0.0, 0.0, 0.0);
vglClear(foregroundClose, 0.0, 0.0, 0.0);
vglClear(buf, 0.0, 0.0, 0.0);
vglClear(background32, 0.0, 0.0, 0.0);
vglClear(variance32, 0.0, 0.0, 0.0);
curr_training_image = 0;
sobel = 0;
color = 0;
grayx = 0;
grayy = 0;
//TrainVglSimpleBGModel(img_in);
vglSetContext(foreground, VGL_GL_CONTEXT);
vglSetContext(foregroundClose, VGL_GL_CONTEXT);
vglSetContext(buf, VGL_GL_CONTEXT);
vglSetContext(background32, VGL_GL_CONTEXT);
vglSetContext(variance32, VGL_GL_CONTEXT);
}
/** Function for loading TIFF images.
Function for loading TIFF images. Supports RGB (8 bits) and
grayscale (8 and 16 bits) images, 2D and 3D. Alternative version with simpler code.
*/
VglImage* vglLoadTiffAlt(char* inFilename)
{
TIFF* tif;
VglImage* img;
uint16 pageNumber, numberPages, subfileType;
tif = TIFFOpen(inFilename, "r");
if (tif == NULL){
fprintf(stderr, "%s:%s: Error: File %s not found.\n", __FILE__, __FUNCTION__, inFilename);
return NULL;
}
int width = tif_Width(tif);
int height = tif_Height(tif);
int is3d = tif_Is3d(tif);
int layers = tif_Layers(tif);
int depth = tif_BytesPerPixel(tif); // bytes per pixel
int iplDepth = convertDepthTiffToVgl(depth); // depth \in {IPL_DEPTH_8U, ...}
int nChannels = tif_nChannels(tif); // number of channels
if (is3d)
{
img = vglCreate3dImage(cvSize(width,height), iplDepth, nChannels, layers, 0);
}
else
{
img = vglCreateImage(cvSize(width,height), iplDepth, nChannels);
}
char* imageData = img->getImageData();
int widthStep = img->getWidthStep();
char* buffer = (char*) tif_Malloc(tif);
int pixelsPerLine = img->getWidth()*img->getNChannels();
int bytesPerLine = pixelsPerLine*depth;
int i = 0;
int offset = 0;
do
{
/*
for(int i = 0; i < height; i++)
{
printf("i = %d\n", i);
TIFFReadScanline(tif, buffer, i);
memcpy(imageData + offset, buffer, bytesPerLine);
offset += widthStep;
}
*/
TIFFReadRGBAImage(tif, width, height, (uint32*) buffer, 0);
memcpy(imageData + offset, buffer, widthStep*height);
offset += widthStep + height;
}
while(TIFFReadDirectory(tif));
TIFFClose(tif);
vglSetContext(img, VGL_RAM_CONTEXT);
return img;
}
/** Function for loading TIFF images.
Function for loading TIFF images. Supports RGB (8 bits) and
grayscale (8 and 16 bits) images, 2D and 3D.
*/
VglImage* vglLoadTiff(char* inFilename)
{
TIFF* tif;
VglImage* img;
uint16 pageNumber, numberPages, subfileType;
tif = TIFFOpen(inFilename, "r");
if (tif == NULL){
fprintf(stderr, "%s:%s: Error: File %s not found.\n", __FILE__, __FUNCTION__, inFilename);
return NULL;
}
int width = tif_Width(tif);
int height = tif_Height(tif);
int is3d = tif_Is3d(tif);
int layers = tif_Layers(tif);
int depth = tif_BytesPerPixel(tif); // bytes per pixel
int iplDepth = convertDepthTiffToVgl(depth); // depth \in {IPL_DEPTH_8U, ...}
int nChannels = tif_nChannels(tif); // number of channels
if (is3d)
{
img = vglCreate3dImage(cvSize(width,height), iplDepth, nChannels, layers, 0);
}
else
{
img = vglCreateImage(cvSize(width,height), iplDepth, nChannels);
}
char* imageData = img->getImageData();
int pixelsPerFrame = img->getWidth()*img->getHeight()*img->nChannels;
int bytesPerFrame = pixelsPerFrame*depth;
int j = 0;
do{
char* buffer = (char*)tif_ReadData(tif);
memcpy(imageData+j, buffer, bytesPerFrame);
j += bytesPerFrame;
}while(TIFFReadDirectory(tif));
TIFFClose(tif);
vglSetContext(img, VGL_RAM_CONTEXT);
return img;
}
int main(int argc, char* argv[])
{
if (argc != 4)
{
printf("\nUsage: MMDCPU_benchmark lena_1024.tiff 1000 /tmp\n\n");
printf("In this example, will run the program for lena_1024.tiff in a \nloop with 1000 iterations. Output images will be stored in /tmp.\n\n");
printf("Error: Bad number of arguments = %d. 3 arguments required.\n", argc - 1);
exit(1);
}
//vglInit(50, 50);
int nSteps = atoi(argv[2]);
char* inFilename = argv[1];
char* outPath = argv[3];
char* outFilename = (char*)malloc(strlen(outPath) + 400);
sprintf(outFilename, "%s%s", outPath, "/test_out.tif");
printf("VisionGL-OpenCL on %s, %d operations\n\n", inFilename, nSteps);
VglImage* img = vglLoadImage(inFilename, 0);
if (img == NULL)
img = vglDcmtkLoadDicom(inFilename);
VglImage* out = vglCreateImage(img);
float* mask;
int* mask_size;
if (img->ndim == 2)
{
mask = (float*)malloc(sizeof(float) * 9);
float actual_mask[9] = { 0, 1, 0, 1, 1, 1, 0, 1, 0 };
memcpy(mask, actual_mask, sizeof(float) * 9);
mask_size = (int*)malloc(sizeof(int) * 2);
int actual_mask_size[2] = { 3, 3 };
memcpy(mask_size, actual_mask_size, sizeof(int) * 2);
}
else
{
mask = (float*)malloc(sizeof(float) * 27);
float actual_mask[27] = { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, };
memcpy(mask, actual_mask, sizeof(float) * 27);
mask_size = (int*)malloc(sizeof(int) * 3);
int actual_mask_size[3] = { 3, 3, 3 };
memcpy(mask_size, actual_mask_size, sizeof(int) * 3);
}
printf("Mask = { %d, %d, %d }\n", mask_size[0], mask_size[1], mask_size[2]);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Standard Erode", outPath, &MMD_STANDARD);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Standard Dilate", outPath, &MMD_STANDARD);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Algebraic Erode", outPath, &MMD_ALGEBRAIC);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Algebraic Dilate", outPath, &MMD_ALGEBRAIC);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Arithmetic Erode", outPath, &MMD_ARITHMETIC);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Arithmetic Dilate", outPath, &MMD_ARITHMETIC);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Geometric Erode", outPath, &MMD_GEOMETRIC);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Geometric Dilate", outPath, &MMD_GEOMETRIC);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Bound Erode", outPath, &MMD_BOUND);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Bound Dilate", outPath, &MMD_BOUND);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Drastic Erode", outPath, &MMD_DRASTIC);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Drastic Dilate", outPath, &MMD_DRASTIC);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "DaP Erode", outPath, &MMD_DaP);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "DaP Dilate", outPath, &MMD_DaP);
benchmark(img, out, mask, mask_size, nSteps, ERODE, "Hamacher Erode", outPath, &MMD_HAMACHER);
benchmark(img, out, mask, mask_size, nSteps, DILATE, "Hamacher Dilate", outPath, &MMD_HAMACHER);
return 0;
}
