int main(int argc, char** argv)
{
const char *input_file = argv[1];
const char *output_file = argv[2];
int num_generations = atoi(argv[3]);
int population_size = atoi(argv[4]);
// population size, must be multiple of 4 right now
assert(population_size % 4 == 0);
// Load the desired image
RGB *desired_image;
int width, height, max;
desired_image = readPPM(input_file, &width, &height, &max);
// Compute an image
RGB *found_image = (RGB*)malloc(width*height*sizeof(RGB));
compImage(desired_image, width, height, max,
num_generations, population_size, found_image, output_file);
// Write it back into an output file
writePPM(output_file, width, height, max, found_image);
free(found_image);
free(desired_image);
return(0);
}
/*
* Read an image
*/
int RImage::read(char file[100]) {
if (strstr(file, ".ppm") != NULL) {
type = PPM;
readPPM(file);
} else if (strstr(file, ".pgm") != NULL){
type = PGM;
readPGM(file);
} else if (strstr(file, ".jpeg") != NULL ||
strstr(file, ".jpg") != NULL) {
type = JPEG;
readJPEG(file);
} else if (strstr(file, ".png") != NULL) {
fprintf(stderr, "ERROR: Format not supported as yet.\n");
type = PNG;
readPNG(file);
} else {
fprintf(stderr, "ERROR: Cannot read image %s.\n", file);
exit(1);
}
return 0;
}
//!
//! @internal
//! @~English
//! @brief Read a netpbm file, either PAM, PGM or PPM
//!
//! The file type is determined from the magic number.
//! P5 is a PGM file. P6 is a PPM binary file, P7 is a PAM file.
//!
//! @param [in] src pointer to FILE stream to read
//! @param [out] width reference to variable in which to store the image width
//! @param [out] height reference to variable in which to store the image height
//! @param [out] components reference to variable in which to store the number of
//! components in an image pixel
//! @param [out] componentSize
//! reference to variable in which to store the size in bytes
//! of each component of a pixel.
//! @param [out] imageSize reference to variable in which to store the size in bytes
//! of the image.
//! @param [out] pixels reference to variable in which to store a pointer to the
//! image's pixels.
//!
//! @return an error indicator or SUCCESS
//!
//! @exception INVALID_FORMAT the file is not in .pam, .pgm or .ppm format
//!
//! @author Mark Callow
//!
FileResult
readNPBM(FILE* src, unsigned int& width, unsigned int& height,
unsigned int& components, unsigned int& componentSize,
unsigned int &imageSize, unsigned char** pixels)
{
char line[255];
int numvals;
skipNonData(src);
numvals = fscanf(src, "%3s", line);
if (numvals == 0) {
fprintf(stderr, "Error: PBM type string missing.\n");
return INVALID_FORMAT;
}
if (strcmp(line, "P6") == 0) {
return readPPM(src, width, height, components, componentSize, imageSize, pixels);
} else if (strcmp(line, "P5") == 0) {
components = 1;
return readPGM(src, width, height, components, componentSize, imageSize, pixels);
} else if (strcmp(line, "P7") == 0) {
return readPAM(src, width, height, components, componentSize, imageSize, pixels);
} else
return INVALID_FORMAT;
}
GLImageStructure readImage(const std::string& FileName, ImageType type_hint)
{
if (type_hint==itUnknown)
{
type_hint = getImageType(FileName);
}
switch (type_hint)
{
case itJPEG:
return readJPEG(FileName);
case itPNG:
return readPNG(FileName);
case itGIF:
return readGIF(FileName);
case itBitmap:
return readBMP(FileName);
case itPPM:
return readPPM(FileName);
}
//no supported image here
GLImageStructure temp_glis;
temp_glis.setWidth(0);
temp_glis.setHeight(0);
temp_glis.setFormat(0);
temp_glis.setBuffer(NULL);
return temp_glis;
}
/**************************************************************************
Reads in a ppm file (name given in s) and loads it as a texture.
File should have height and width of a power of 2. Returns 0
if error detected, otherwise returns 1
****************************************************************************/
int setTexture(char *s)
{
FILE *fin;
if ( !(fin = fopen(s, "rb")) ) { return 0; }
texpat = readPPM(fin, &w, &h); /* w and h must be a power of 2 */
if (texpat == NULL) return 0;
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
// Uncomment one of the glTexEnvi lines below
// (GL_MODULATE is the default)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D( GL_TEXTURE_2D, /* target */ 0, /* level */
3, /* components */
w, h, /* width, height */ 0, /* border */
GL_RGB, /* format */ GL_UNSIGNED_BYTE, /* type */
texpat);
free(texpat); /* free the texture memory */
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
return 1;
}
int main(int argc , char ** argv){
PPMImage *imageTinyCorrect;
imageTinyCorrect = readPPM("flower_tiny_correct.ppm");
PPMImage *imageSmallCorrect;
imageSmallCorrect = readPPM("flower_small_correct.ppm");
PPMImage *imageMediumCorrect;
imageMediumCorrect = readPPM("flower_medium_correct.ppm");
PPMImage *imageTiny;
imageTiny = readPPM("flower_tiny.ppm");
PPMImage *imageSmall;
imageSmall = readPPM("flower_small.ppm");
PPMImage *imageMedium;
imageMedium = readPPM("flower_medium.ppm");
printf("flower_tiny.ppm:\n");
int pass = testImage(imageTiny, imageTinyCorrect);
printf("flower_small.ppm:\n");
pass = testImage(imageSmall, imageSmallCorrect);
printf("flower_medium.ppm:\n");
pass = testImage(imageMedium, imageMediumCorrect);
exit(0);
}
int main(int argc, char *argv[]) {
if( argc != 2 ) {
printf("Too many or no one arguments supplied.\n");
}
double t_start, t_end;
int i;
char *filename = argv[1]; //Recebendo o arquivo!;
PPMImage *image = readPPM(filename);
PPMImage *image_output = readPPM(filename);
t_start = rtclock();
Smoothing_CPU_Serial(image_output, image);
t_end = rtclock();
// fprintf(stdout, "\n%0.6lfs\n", t_end - t_start);
writePPM(image_output);
free(image);
free(image_output);
}
int main(int argc, char** argv)
{
//Puck status text
strcpy(text[0],"Shoot the puck!");
strcpy(text[1],"What a goal!");
strcpy(text[2], "Everything, but net!");
strcpy(text[3], "The puck hits the left post!");
strcpy(text[4], "The puck hits the right post!");
strcpy(text[5], "The puck hits the crossbar!");
strcpy(text[6], "Shoot it a little harder, guy!");
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(1000,1000);
glutInitWindowPosition(50,50);
glutCreateWindow("Hockey Guy");
glEnable(GL_DEPTH_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
readPPM(BOARDS);
generateTextures(0);
readPPM(ICE);
generateTextures(1);
readPPM(NET);
generateTextures(2);
readPPM(STICK);
generateTextures(3);
readPPM(WALL);
generateTextures(4);
myinit();
glutDisplayFunc(display);
glutIdleFunc(idle);
glutKeyboardFunc(keys);
glutSpecialFunc(special);
glutMainLoop();
return 0;
}
void initialize ()
{
glMatrixMode(GL_PROJECTION);
glViewport(0, 0, 320, 320);
GLfloat aspect = (GLfloat) 320 / 320;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45, aspect, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
glShadeModel( GL_SMOOTH );
glClearColor( 0.0f, 0.0f, 0.0f, 0.5f );
glClearDepth( 1.0f );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
GLfloat amb_light[] = { 0.1, 0.1, 0.1, 1.0 };
GLfloat diffuse[] = { 0.6, 0.6, 0.6, 1 };
GLfloat specular[] = { 0.7, 0.7, 0.3, 1 };
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, amb_light );
glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, specular );
glEnable( GL_LIGHT0 );
glEnable( GL_COLOR_MATERIAL );
glShadeModel( GL_SMOOTH );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
glDepthFunc( GL_LEQUAL );
glEnable( GL_DEPTH_TEST );
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
//textureImage = readPPM("pebbles_texture.ppm");
textureImage = readPPM("yourOwnTexture.ppm");
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
printf("%d %d \n", textureImage->x, textureImage->y);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textureImage->x, textureImage->y, 0, GL_RGB, GL_UNSIGNED_BYTE, textureImage->data);
glBindTexture(GL_TEXTURE_2D, 0);
}
GLuint loadTexture( const char * filename, int wrap )
{
GLuint texture;
int width, height;
unsigned char * data = readPPM(filename, &width, &height);
// allocate a texture name
glGenTextures( 1, &texture );
// select our current texture
glBindTexture( GL_TEXTURE_2D, texture );
// select modulate to mix texture with color for shading
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// when texture area is small, bilinear filter the closest mipmap
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
// when texture area is large, bilinear filter the first mipmap
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// if wrap is true, the texture wraps over at the edges (repeat)
// ... false, the texture ends at the edges (clamp)
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap ? GL_REPEAT : GL_CLAMP );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap ? GL_REPEAT : GL_CLAMP );
// build our texture mipmaps
gluBuild2DMipmaps( GL_TEXTURE_2D, 3, width, height, GL_RGB, GL_UNSIGNED_BYTE, data );
glBindTexture( GL_TEXTURE_2D, 0);
// free buffer
free( data );
return texture;
}
/* reads a PPM image from the given filename. Initializes the alpha channel to 1.0 and the z channel to 1.0. Returns a NULL pointer if the operation fails. */
Image *image_read(char *filename) {
int rows = 0;
int cols = 0;
int colors = 0;
Pixel *image_array = readPPM(&rows, &cols, &colors, filename); // an array of pixels
if (rows < 0 || cols < 0 ) {
printf("rows: %d, cols: %d", rows, cols);
return(NULL);
}
Image *image = image_create(rows, cols);
for (int row=0;row<rows;row++) {
for (int col=0;col<cols;col++) {
image->data[row][col].rgb[0] = 256 - image_array[row*cols + col].r;
image->data[row][col].rgb[1] = 256 - image_array[row*cols + col].g;
image->data[row][col].rgb[2] = 256 - image_array[row*cols + col].b;
image->data[row][col].a = 1.0;
image->data[row][col].z = 1.0;
}
}
return(image);
}
int main(int argc, char** argv) {
PPMImage *image;
if(argc > 1) {
image = readPPM("flower.ppm");
} else {
image = readStreamPPM(stdin);
}
AccurateImage *imageUnchanged = convertImageToNewFormat(image); // save the unchanged image from input image
AccurateImage *imageBuffer = createEmptyImage(image);
AccurateImage *imageSmall = createEmptyImage(image);
AccurateImage *imageBig = createEmptyImage(image);
PPMImage *imageOut;
imageOut = (PPMImage *)malloc(sizeof(PPMImage));
imageOut->data = (PPMPixel*)malloc(image->x * image->y * sizeof(PPMPixel));
// Process the tiny case:
performNewIdeaIteration(imageSmall, imageUnchanged, 2);
performNewIdeaIteration(imageBuffer, imageSmall, 2);
performNewIdeaIteration(imageSmall, imageBuffer, 2);
performNewIdeaIteration(imageBuffer, imageSmall, 2);
performNewIdeaIteration(imageSmall, imageBuffer, 2);
// Process the small case:
performNewIdeaIteration(imageBig, imageUnchanged,3);
performNewIdeaIteration(imageBuffer, imageBig,3);
performNewIdeaIteration(imageBig, imageBuffer,3);
performNewIdeaIteration(imageBuffer, imageBig,3);
performNewIdeaIteration(imageBig, imageBuffer,3);
// save tiny case result
performNewIdeaFinalization(imageSmall, imageBig, imageOut);
if(argc > 1) {
writePPM("flower_tiny.ppm", imageOut);
} else {
writeStreamPPM(stdout, imageOut);
}
// Process the medium case:
performNewIdeaIteration(imageSmall, imageUnchanged, 5);
performNewIdeaIteration(imageBuffer, imageSmall, 5);
performNewIdeaIteration(imageSmall, imageBuffer, 5);
performNewIdeaIteration(imageBuffer, imageSmall, 5);
performNewIdeaIteration(imageSmall, imageBuffer, 5);
// save small case
performNewIdeaFinalization(imageBig, imageSmall,imageOut);
if(argc > 1) {
writePPM("flower_small.ppm", imageOut);
} else {
writeStreamPPM(stdout, imageOut);
}
// process the large case
performNewIdeaIteration(imageBig, imageUnchanged, 8);
performNewIdeaIteration(imageBuffer, imageBig, 8);
performNewIdeaIteration(imageBig, imageBuffer, 8);
performNewIdeaIteration(imageBuffer, imageBig, 8);
performNewIdeaIteration(imageBig, imageBuffer, 8);
// save the medium case
performNewIdeaFinalization(imageSmall, imageBig, imageOut);
if(argc > 1) {
writePPM("flower_medium.ppm", imageOut);
} else {
writeStreamPPM(stdout, imageOut);
}
// free all memory structures
freeImage(imageUnchanged);
freeImage(imageBuffer);
freeImage(imageSmall);
freeImage(imageBig);
free(imageOut->data);
free(imageOut);
free(image->data);
free(image);
return 0;
}
int main(int argc, char** argv) {
PPMImage *image;
int size;
if(argc > 1) {
image = readPPM("flower.ppm");
} else {
image = readStreamPPM(stdin);
}
AccurateImage *imageAccurate1_tiny = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_tiny = convertImageToNewFormat(image);
// Process the tiny case:
size = 2;
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, size);
performNewIdeaIteration(imageAccurate1_tiny, imageAccurate2_tiny, size);
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, size);
performNewIdeaIteration(imageAccurate1_tiny, imageAccurate2_tiny, size);
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, size);
AccurateImage *imageAccurate1_small = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_small = convertImageToNewFormat(image);
// Process the small case:
size = 3;
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, size);
performNewIdeaIteration(imageAccurate1_small, imageAccurate2_small, size);
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, size);
performNewIdeaIteration(imageAccurate1_small, imageAccurate2_small, size);
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, size);
AccurateImage *imageAccurate1_medium = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_medium = convertImageToNewFormat(image);
// Process the medium case:
size = 5;
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, size);
performNewIdeaIteration(imageAccurate1_medium, imageAccurate2_medium, size);
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, size);
performNewIdeaIteration(imageAccurate1_medium, imageAccurate2_medium, size);
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, size);
AccurateImage *imageAccurate1_large = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_large = convertImageToNewFormat(image);
size = 8;
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, size);
performNewIdeaIteration(imageAccurate1_large, imageAccurate2_large, size);
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, size);
performNewIdeaIteration(imageAccurate1_large, imageAccurate2_large, size);
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, size);
// Save the images.
PPMImage *final_tiny = performNewIdeaFinalization(imageAccurate2_tiny, imageAccurate2_small);
PPMImage *final_small = performNewIdeaFinalization(imageAccurate2_small, imageAccurate2_medium);
PPMImage *final_medium = performNewIdeaFinalization(imageAccurate2_medium, imageAccurate2_large);
if(argc > 1) {
writePPM("flower_tiny.ppm", final_tiny);
writePPM("flower_small.ppm", final_small);
writePPM("flower_medium.ppm", final_medium);
} else {
writeStreamPPM(stdout, final_tiny);
writeStreamPPM(stdout, final_small);
writeStreamPPM(stdout, final_medium);
}
return 0;
}
void handle_input(char *input, img_t **in, img_t **out, img_t **original) {
#ifndef MPI
/* Read input image, memory is automaticaly allocated. */
img_t *read = readPPM(input);
/* Allocate memory for output image. */
*out = createPPM(read->w, read->h);
/* For sequential code, the input is just what we read from file. */
*in = read;
*original = read;
#else
/* Size and rank for MPI. */
int size, rank;
/* Array to broadcast image width and height. */
int dim[2];
/* Local variables for image size and number of lines to compute. */
int w, h, extrarows, index;
/* Declare pointer to image to read. */
img_t *read = NULL;
/* Need to ask MPI who we are, and how many processes there are. */
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/* Only one (the first) process reads the input. */
if (rank == 0) {
/* Read input */
read = readPPM(input);
/* Get size for broadcasting to others */
dim[0] = read->w;
dim[1] = read->h;
}
/* Let others know the size of the image. */
MPI_Bcast(dim, 2, MPI_INT, 0, MPI_COMM_WORLD);
/* Width is the same for each process. */
w = dim[0];
/* We divide the rows of pixels (height) over the processes. */
h = dim[1] / size;
/*
* There might be some rows left (remainder of division),
* so some processes must do an additional row.
*/
extrarows = dim[1] % size;
if (rank < extrarows) {
h++;
}
/* As we know the size by now, we can create the local images */
*in = createPPM(w, h);
*out = createPPM(w, h);
/* The first one sends all the processes their data. */
if (rank == 0) {
/* First copy data for myself. */
memcpy((*in)->data, read->data, w * h * sizeof(pixel_t));
/* The next send should start at this index. */
index = w * h;
/* Loop over all workers. */
for (int i = 1; i < size; i++) {
/* Calculate how many rows this worker gets */
int height = dim[1] / size;
if (i < extrarows) {
height++;
}
/* Do the actual sending */
MPI_Send(read->data + index, w * height * sizeof(pixel_t),
MPI_UNSIGNED_CHAR, i, 0, MPI_COMM_WORLD);
/* Update the index for next send. */
index += w * height;
}
/* Store a pointer to the original image. */
*original = read;
} else {
/* All others just receive */
MPI_Recv((*in)->data, w * h * sizeof(pixel_t),
MPI_UNSIGNED_CHAR, 0, 0, MPI_COMM_WORLD, NULL);
}
#endif
}
int main(int argc, char *argv[]) {
Pixel *image1;
Pixel *image2;
Pixel *image3;
int rows, cols, colors;
long imagesize;
// //int intensity, avg_r, avg_g, avg_b;
if(argc < 5) {
printf("Usage: %s <input file_1><input file_2><input mask><output file>\n", argv[0]);
exit(-1);
}
/* read in the image */
image1 = readPPM(&rows, &cols, &colors, argv[1]);
if(!image1) {
fprintf(stderr, "Unable to read file_1 %s\n", argv[1]);
exit(-1);
}else{
printf("successfully opened image %s\n", argv[1]);
}
image2 = readPPM(&rows, &cols, &colors, argv[2]);
if(!image2) {
fprintf(stderr, "Unable to read file_2 %s\n", argv[2]);
exit(-1);
}else{
printf("successfully opened image %s\n", argv[2]);
}
image3 = readPPM(&rows, &cols, &colors, argv[3]);
if(!image3) {
fprintf(stderr, "Unable to read mask %s\n", argv[3]);
exit(-1);
}else{
printf("successfully opened image %s\n", argv[3]);
}
/* calculate the image size */
imagesize = (long)rows * (long)cols;
//image1 = makeMask(image1, imagesize); // use for creating the mask
//image1 = setBackground(image1, image2, image3, imagesize); // setting the back ground ***use either this method or "translate" method. NOT BOTH
image1 = translate(image1, image2, image3, imagesize, cols, rows,0,0); // sets the back ground as well as translates the front image.
//image1 = toGreyscale(image1, imagesize); // turns an image to greyscale
image1 = toNegative(image1, imagesize); // turns an image to negative
//image1 = horizontalBlur(image1, imagesize); // turns the image blury
// /* write out the resulting image */
writePPM(image1, rows, cols, colors /* s/b 255 */, argv[4]);
// /* free the image memory */
#if USECPP
delete[] image;
#else
free(image1);
free(image2);
free(image3);
#endif
return(0);
}
Texture::Texture(const char* _path) {
readPPM(_path);
}
int main( int argc, char* argv[]){
if (argc<4){
printf("Usage: %s image annotations output\n", argv[0] );
return 1;
}
// Number of labels [use only 4 to make our lives a bit easier]
const int M = 4;
// Load the color image and some crude annotations (which are used in a simple classifier)
int W, H, GW, GH;
unsigned char * im = readPPM( argv[1], W, H );
if (!im){
printf("Failed to load image!\n");
return 1;
}
unsigned char * anno = readPPM( argv[2], GW, GH );
if (!anno){
printf("Failed to load annotations!\n");
return 1;
}
if (W!=GW || H!=GH){
printf("Annotation size doesn't match image!\n");
return 1;
}
// Get the labeling
VectorXs labeling = getLabeling( anno, W*H, M );
const int N = W*H;
// Get the logistic features (unary term)
// Here we just use the color as a feature
Eigen::MatrixXf logistic_feature( 4, N ), logistic_transform( M, 4 );
logistic_feature.fill( 1.f );
for( int i=0; i<N; i++ )
for( int k=0; k<3; k++ )
logistic_feature(k,i) = im[3*i+k] / 255.;
for( int j=0; j<logistic_transform.cols(); j++ )
for( int i=0; i<logistic_transform.rows(); i++ )
logistic_transform(i,j) = 0.01*(1-2.*random()/RAND_MAX);
// Setup the CRF model
DenseCRF2D crf(W, H, M);
// Add a logistic unary term
crf.setUnaryEnergy( logistic_transform, logistic_feature );
// Add simple pairwise potts terms
crf.addPairwiseGaussian( 3, 3, new PottsCompatibility( 1 ) );
// Add a longer range label compatibility term
crf.addPairwiseBilateral( 80.0f, 80.0f, 13.0f, 13.0f, 13.0f, &*im, new MatrixCompatibility::MatrixCompatibility( Eigen::MatrixXf::Identity(M,M) ) );
// Choose your loss function
// LogLikelihood objective( labeling, 0.01 ); // Log likelihood loss
// Hamming objective( labeling, 0.0 ); // Global accuracy
// Hamming objective( labeling, 1.0 ); // Class average accuracy
// Hamming objective( labeling, 0.2 ); // Hamming loss close to intersection over union
IntersectionOverUnion objective( labeling ); // Intersection over union accuracy
int NIT = 5;
const bool verbose = true;
Eigen::MatrixXf learning_params( 3, 3 );
// Optimize the CRF in 3 phases:
// * First unary only
// * Unary and pairwise
// * Full CRF
learning_params<<1,0,0,
1,1,0,
1,1,1;
for( int i=0; i<learning_params.rows(); i++ ) {
// Setup the energy
CRFEnergy energy( crf, objective, NIT, learning_params(i,0), learning_params(i,1), learning_params(i,2) );
energy.setL2Norm( 1e-3 );
// Minimize the energy
Eigen::VectorXf p = minimizeLBFGS( energy, 2, true );
// Save the values
int id = 0;
if( learning_params(i,0) ) {
crf.setUnaryParameters( p.segment( id, crf.unaryParameters().rows() ) );
id += crf.unaryParameters().rows();
}
if( learning_params(i,1) ) {
crf.setLabelCompatibilityParameters( p.segment( id, crf.labelCompatibilityParameters().rows() ) );
id += crf.labelCompatibilityParameters().rows();
}
if( learning_params(i,2) )
crf.setKernelParameters( p.segment( id, crf.kernelParameters().rows() ) );
}
// Return the parameters
std::cout<<"Unary parameters: "<<crf.unaryParameters().transpose()<<std::endl;
std::cout<<"Pairwise parameters: "<<crf.labelCompatibilityParameters().transpose()<<std::endl;
std::cout<<"Kernel parameters: "<<crf.kernelParameters().transpose()<<std::endl;
// Do map inference
VectorXs map = crf.map(NIT);
// Store the result
unsigned char *res = colorize( map, W, H );
writePPM( argv[3], W, H, res );
delete[] im;
delete[] anno;
delete[] res;
}
int main() {
PPMImage *image;
image = readPPM("flower.ppm");
AccurateImage *imageAccurate1_tiny = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_tiny = convertImageToNewFormat(image);
// Process the tiny case:
for(int colour = 0; colour < 3; colour++) {
int size = 2;
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, colour, size);
performNewIdeaIteration(imageAccurate1_tiny, imageAccurate2_tiny, colour, size);
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, colour, size);
performNewIdeaIteration(imageAccurate1_tiny, imageAccurate2_tiny, colour, size);
performNewIdeaIteration(imageAccurate2_tiny, imageAccurate1_tiny, colour, size);
}
AccurateImage *imageAccurate1_small = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_small = convertImageToNewFormat(image);
// Process the small case:
for(int colour = 0; colour < 3; colour++) {
int size = 3;
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, colour, size);
performNewIdeaIteration(imageAccurate1_small, imageAccurate2_small, colour, size);
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, colour, size);
performNewIdeaIteration(imageAccurate1_small, imageAccurate2_small, colour, size);
performNewIdeaIteration(imageAccurate2_small, imageAccurate1_small, colour, size);
}
AccurateImage *imageAccurate1_medium = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_medium = convertImageToNewFormat(image);
// Process the medium case:
for(int colour = 0; colour < 3; colour++) {
int size = 5;
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, colour, size);
performNewIdeaIteration(imageAccurate1_medium, imageAccurate2_medium, colour, size);
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, colour, size);
performNewIdeaIteration(imageAccurate1_medium, imageAccurate2_medium, colour, size);
performNewIdeaIteration(imageAccurate2_medium, imageAccurate1_medium, colour, size);
}
AccurateImage *imageAccurate1_large = convertImageToNewFormat(image);
AccurateImage *imageAccurate2_large = convertImageToNewFormat(image);
// Do each color channel
for(int colour = 0; colour < 3; colour++) {
int size = 8;
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, colour, size);
performNewIdeaIteration(imageAccurate1_large, imageAccurate2_large, colour, size);
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, colour, size);
performNewIdeaIteration(imageAccurate1_large, imageAccurate2_large, colour, size);
performNewIdeaIteration(imageAccurate2_large, imageAccurate1_large, colour, size);
}
// Save the images.
PPMImage *final_tiny = performNewIdeaFinalization(imageAccurate2_tiny, imageAccurate2_small);
writePPM("flower_tiny_correct.ppm",final_tiny);
PPMImage *final_small = performNewIdeaFinalization(imageAccurate2_small, imageAccurate2_medium);
writePPM("flower_small_correct.ppm",final_small);
PPMImage *final_medium = performNewIdeaFinalization(imageAccurate2_medium, imageAccurate2_large);
writePPM("flower_medium_correct.ppm",final_medium);
}
int main(int argc, char *argv[]) {
if (argc < 5 )
{
printf("\n Usage: ./denoise input.ppm output.ppm N F \n input.ppm is the name of the input file\n output.ppm is the name of the output file \n N specifies the size of the window\n F is the type of filtering");
return 1;
}
const char *input = (argv[1]), *output = (argv[2]), *type = (argv[4]);
int size = atoi(argv[3]);
int *width, *height, *max;
printf("Reading file %c", *input);
clock_t start, end;
double cpu_time_used;
start = clock();
RGB *readfile = readPPM(input, width, height, max);
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("***\t %c read in %e seconds", *input, cpu_time_used);
filter rtype;
if ((*type) == 'A')
{
printf("Processing %d x %d image using %d x %d and mean filter...", *width, *height, size, size);
rtype = MEAN;
}
else
{
printf("Processing %d x %d image using %d x %d and median filter...", *width, *height, size, size);
}
start = clock();
RGB *writefile = denoiseImage (*width, *height, readfile, size, rtype);
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("***\t image processed in %e seconds", cpu_time_used);
printf("Writing file %c", *output);
start = clock();
writePPM(output, *width, *height, *max, writefile);
printf("\n");
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("***\t %c read in %e seconds", *output, cpu_time_used);
/*
deallocateBST(bst_root);
deallocateList(list_head);
free(A);
*/
return 0;
}
int main( int argc, char* argv[] )
{
//===================================================================
// Get the command-line options.
//===================================================================
Options opt;
if( !options( argc, argv , opt ) )
{
return 1;
}
// Output the options.
std::cerr << "Using demo sequence " << opt.sequenceNumber << "." << std::endl;
std::cerr << "Output path is: \"" << opt.outputPath << "\"." << std::endl;
std::cerr << "Number Of Images: " << opt.nImages << std::endl;
std::cerr << "Start frame: " << opt.startFrame << std::endl;
std::cerr << "Blur mode: " << ( opt.blurMode == Options::kGentle ? "Gentle" : "Aggressive") << std::endl;
std::cerr << "Blur strength: " << opt.blurStrength << std::endl;
std::cerr << "Contribution strength: " << opt.contributionStrength << std::endl;
std::cerr << "Kernel width: " << opt.kernelWidth << std::endl;
// Load the images.
std::vector< Image > images( opt.nImages );
int frame = opt.startFrame;
for( unsigned int i = 0; i < images.size(); ++i )
{
std::stringstream s;
s << "images/image" << opt.sequenceNumber << "." << frame << ".ppm";
if( !readPPM( s.str(), images[i] ) )
{
std::cerr << "Failed to open image " << s.str() << std::endl;
return 1;
}
if( ++frame >= 11 )
{
frame = 0;
}
}
//===================================================================
// The algorithm.
//===================================================================
SampleSet set( images );
const int width = set.width(), height = set.height();
Image result( width, height );
int kernelRadius = opt.kernelWidth > 1 ? ( opt.kernelWidth - 1 ) / 2 : 0;
std::vector< double > srcSamples;
for( int y = 0; y < height; ++y )
{
for( int x = 0; x < width; ++x )
{
fprintf(stderr,"\rFiltering %5.2f%% complete.", 100. * y / ( height-1 ) );
// Loop over each channel.
for( unsigned int c = 0; c < 3; ++c )
{
double destMean = set.mean( x, y, c );
double destDeviation = set.deviation( x, y, c );
double destVariation = set.variance( x, y, c );
double destRange = set.max( x, y, c ) - set.min( x, y, c );
// Loop over the neighbouring pixels.
double weightedSum = 0.;
double v = 0.;
for( int ky = -kernelRadius; ky <= kernelRadius; ++ky )
{
for( int kx = -kernelRadius; kx <= kernelRadius; ++kx )
{
// Don't include the pixel being sampled in our calculations as we are
// summing the deviations from it and doing so will bias our results.
if( ky == 0 && kx == 0 )
{
continue;
}
// Gather information on the source pixel's samples.
srcSamples = set.samples( x + kx, y + ky, c );
double srcMin = set.min( x + kx, y + ky, c );
double srcMax = set.max( x + kx, y + ky, c );
double srcMean = set.mean( x + kx, y + ky, c );
double srcDeviation = set.deviation( x + kx, y + ky, c );
double srcVariation = set.variance( x + kx, y + ky, c );
double srcRange = set.max( x + kx, y + ky, c ) - set.min( x + kx, y + ky, c );
if( srcVariation == 0 && srcSamples[0] == 0. ) continue;
// A gaussian falloff that weights contributing samples which are closer to the pixel being filtered higher.
/// \todo Intuitive falloff parameters need to be added to the distance weight or at least a suitable curve found.
double distanceWeight = gaussian( sqrt( kx*kx + ky*ky ) / sqrt( kernelRadius*kernelRadius + kernelRadius*kernelRadius ), 0., .7, false );
// Similarity weight.
// This weight defines a measure of how similar the set of contributing samples is to the pixel being filtered.
// By itself it will produce a smart blur of sorts which is then attenuated by the variance of the source samples in the process of weighted offsets.
// Changing this value will effect how aggressive the filtering is.
double similarity;
if( opt.blurMode == Options::kAggressive )
{
similarity = ( srcMean - destMean ) * ( srcRange - destRange );
}
else
{
similarity = ( srcMean - destMean );
}
similarity *= similarity;
// Temporal weight.
// Weight the contribution using a function in the range of 0-1 which weights the importance of the
// contributing sample according to how close it is in time to the current time.
double time = 1.; // \todo: implement this! Example functions are Median, Gaussian, etc.
// Loop over each of the neighbouring samples.
for( unsigned int i = 0; i < srcSamples.size(); ++i )
{
// The contribution weight extends the range of allowed samples that can influence the pixel being filtered.
// It is simply a scaler that increases the width of the bell curve that the samples are weighted against.
double contribution = gaussian( srcSamples[i], destMean, destDeviation * ( 1 + opt.contributionStrength ) ) * gaussian( srcSamples[i], srcMean, srcDeviation );
contribution = contribution * ( 1. - opt.blurStrength ) + opt.blurStrength;
// This weight is a step function with a strong falloff close to the limits. However, it will never reach 0 so that the sample is not excluded.
// By using this weight the dependency on the limiting samples is much less which reduces the effect of sparkling artefacts.
double limitWeight = srcSamples.size() <= 2 ? 1. : softStep( srcSamples[i], srcMin, srcMax );
// Combine the weights together and normalize to the range of 0-1.
double weight = pow( M_E, -( similarity / ( contribution * srcVariation * time * distanceWeight * limitWeight ) ) );
weight = ( isnan( weight ) || isinf( weight ) ) ? 0. : weight;
// Sum the offset.
v += ( srcSamples[i] - destMean ) * weight;
// Sum the weight.
weightedSum += weight;
}
}
}
if( weightedSum == 0. || destVariation <= 0. )
{
result.writeable( x, y )[c] = destMean;
}
else
{
result.writeable( x, y )[c] = destMean + ( v / weightedSum );
}
}
}
}
bool success = false;
if( opt.extension == "bmp" )
{
success = writeBMP( opt.outputPath.c_str(), result );
}
else
{
success = writePPM( opt.outputPath.c_str(), result );
}
if( !success )
{
std::cerr << "Failed to write image." << std::endl;
return 1;
}
return 0;
}
int main(int argc, char *argv[]) {
Pixel *image;
int rows, cols, colors;
long imagesize;
long i;
int gain;
unsigned char *mask = NULL;
unsigned char *grown = NULL;
unsigned char *shrunk = NULL;
unsigned char *median = NULL;
char *inputfile;
if (argc != 2) {
printf("Usage: %s <input file>\n", argv[0]);
exit(-1);
}
inputfile = argv[1];
gain = 2;
/* read in the image */
image = readPPM(&rows, &cols, &colors, inputfile);
if (!image) {
fprintf(stderr, "Unable to read %s\n", inputfile);
exit(-1);
}
/* calculate the image size */
imagesize = (long)rows * (long)cols;
mask = (unsigned char*) malloc(sizeof(unsigned char) * imagesize);
grown = (unsigned char*) malloc(sizeof(unsigned char) * imagesize);
shrunk = (unsigned char*) malloc(sizeof(unsigned char) * imagesize);
median = (unsigned char*) malloc(sizeof(unsigned char) * imagesize);
/* mask the image */
for (i=0; i<imagesize; i++) {
if (image[i].r > (gain * image[i].g)) {
mask[i] = BACKGROUND;
}
else {
mask[i] = FOREGROUND;
}
}
/* manipulate the images */
grow(mask, grown, rows, cols);
shrink(mask, shrunk, rows, cols);
medianify(mask, median, rows, cols);
/* write out the files */
writePGM(mask, rows, cols, INTENSITIES, "masked.pgm");
writePGM(grown, rows, cols, INTENSITIES, "grown.pgm");
writePGM(shrunk, rows, cols, INTENSITIES, "shrunk.pgm");
writePGM(median, rows, cols, INTENSITIES, "median.pgm");
/* free the image memory */
free(image);
free(mask);
free(grown);
free(shrunk);
free(median);
return(0);
}
/**
* Lee y genera las texturas utilizadas
*/
void genTexturas() {
paleta = loadPalInt("paletas/landcolor3.ppm", 256);
paletaf = intPal2Float(paleta, 256);
paleta_agua = loadPalInt("paletas/watercolor7.ppm", 256);
paleta_aguaf = intPal2Float(paleta_agua, 256);
paleta_grass = loadPalInt("paletas/grasscolor2.ppm", 256);
paleta_grassf = intPal2Float(paleta_grass, 256);
tree = readPPM("paletas/tree.ppm");
snowtree = readPPM("paletas/treesnow.ppm");
treealpha = readPGM("paletas/treealpha.pgm");
datatree = genTextIntAlpha(tree, treealpha, 256);
datasnowtree = genTextIntAlpha(snowtree, treealpha, 256);
paletanubes = loadPalInt("paletas/skyalpha.ppm", 256);
nubesalpha = skyalpha3D(paletanubes, FRAMES_NUBES, int((nubosidad)*128.0), 256);
nubes = new rgbint*[256]; // nubes blancas
for (int i=0; i<256; i++){
nubes[i] = new rgbint[256];
for (int j=0; j<256; j++){
nubes[i][j].r = 255;
nubes[i][j].g = 255;
nubes[i][j].b = 255;
}
}
datanubes = new int*[FRAMES_NUBES];
for (int i=0; i<FRAMES_NUBES; i++){
datanubes[i] = genTextIntAlpha(nubes,nubesalpha[i],256);
}
//writePGMint("../../nubes3D.pgm", nubesalpha[0], 256);
// Genera los nombres de textura
glGenTextures(15, texNames);
glBindTexture(GL_TEXTURE_2D, texNames[ARBOL]);
genText(datatree, false, 256);
glBindTexture(GL_TEXTURE_2D, texNames[ARBOLNIEVE]);
genText(datasnowtree,false, 256);
for (int i=0; i<FRAMES_NUBES; i++){
glBindTexture(GL_TEXTURE_2D, texNames[NUBES+i]);
genText(datanubes[i], true, 256);
}
brujula = new rgbint*[128]; // brujula negra
for (int i=0; i<128; i++){
brujula[i] = new rgbint[128];
for (int j=0; j<128; j++){
brujula[i][j].r = 0;
brujula[i][j].g = 0;
brujula[i][j].b = 0;
}
}
brujulaalpha = readPGM("paletas/brujulaalpha.pgm");
databrujula = genTextIntAlpha(brujula, brujulaalpha, 128);
aguja = readPPM("paletas/aguja.ppm");
agujaalpha = readPGM("paletas/agujaalpha.pgm");
dataaguja = genTextIntAlpha(aguja, agujaalpha, 128);
glBindTexture(GL_TEXTURE_2D, texNames[BRUJULA]);
genText(databrujula,false, 128);
glBindTexture(GL_TEXTURE_2D, texNames[AGUJA]);
genText(dataaguja,false, 128);
}
int main( int argc, char* argv[]){
if (argc<4){
printf("Usage: %s image annotations output\n", argv[0] );
return 1;
}
// Number of labels
const int M = 21;
// Load the color image and some crude annotations (which are used in a simple classifier)
int W, H, GW, GH;
unsigned char * im = readPPM( argv[1], W, H );
if (!im){
printf("Failed to load image!\n");
return 1;
}
unsigned char * anno = readPPM( argv[2], GW, GH );
if (!anno){
printf("Failed to load annotations!\n");
return 1;
}
if (W!=GW || H!=GH){
printf("Annotation size doesn't match image!\n");
return 1;
}
/////////// Put your own unary classifier here! ///////////
Eigen::MatrixXf unary = computeUnary( getLabeling( anno, W*H, M ), M );
///////////////////////////////////////////////////////////
// Setup the CRF model
DenseCRF2D crf(W, H, M);
// Specify the unary potential as an array of size W*H*(#classes)
// packing order: x0y0l0 x0y0l1 x0y0l2 .. x1y0l0 x1y0l1 ...
crf.setUnaryEnergy( unary );
// add a color independent term (feature = pixel location 0..W-1, 0..H-1)
// x_stddev = 3
// y_stddev = 3
// weight = 3
crf.addPairwiseGaussian( 3, 3, new PottsCompatibility( 3 ) );
// add a color dependent term (feature = xyrgb)
// x_stddev = 60
// y_stddev = 60
// r_stddev = g_stddev = b_stddev = 20
// weight = 10
crf.addPairwiseBilateral( 80, 80, 13, 13, 13, im, new PottsCompatibility( 10 ) );
// Do map inference
// Eigen::MatrixXf Q = crf.startInference(), t1, t2;
// printf("kl = %f\n", crf.klDivergence(Q) );
// for( int it=0; it<5; it++ ) {
// crf.stepInference( Q, t1, t2 );
// printf("kl = %f\n", crf.klDivergence(Q) );
// }
// VectorXs map = crf.currentMap(Q);
VectorXs map = crf.map(5);
// Store the result
unsigned char *res = colorize( map, W, H );
writePPM( argv[3], W, H, res );
delete[] im;
delete[] anno;
delete[] res;
}
// Host code
int main(int argc, char** argv)
{
ParseArguments(argc, argv);
float s_SobelMatrix[25];
s_SobelMatrix[0] = 1;
s_SobelMatrix[1] = 2;
s_SobelMatrix[2]= 0;
s_SobelMatrix[3] = -2;
s_SobelMatrix[4] = -1;
s_SobelMatrix[5] = 4;
s_SobelMatrix[6] = 8;
s_SobelMatrix[7] = 0;
s_SobelMatrix[8] = -8;
s_SobelMatrix[9] = -4;
s_SobelMatrix[10] = 6;
s_SobelMatrix[11] = 12;
s_SobelMatrix[12] = 0;
s_SobelMatrix[13] = -12;
s_SobelMatrix[14] = -6;
s_SobelMatrix[15] = 4;
s_SobelMatrix[16] = 8;
s_SobelMatrix[17] = 0;
s_SobelMatrix[18] = -8;
s_SobelMatrix[19] =-4;
s_SobelMatrix[20] =1;
s_SobelMatrix[21] =2;
s_SobelMatrix[22] =0;
s_SobelMatrix[23] =-2;
s_SobelMatrix[24] =-1;
unsigned char *palete = NULL;
unsigned char *data = NULL, *out = NULL;
PPMImage *input_image=NULL, *output_image=NULL;
output_image = (PPMImage *)malloc(sizeof(PPMImage));
input_image = readPPM(PPMInFileL);
printf("Running %s filter\n", Filter);
out = (unsigned char *)malloc();
printf("Computing the CPU output\n");
printf("Image details: %d by %d = %d , imagesize = %d\n", input_image->x, input_image->y, input_image->x * input_image->y, input_image->x * input_image->y);
cutilCheckError(cutStartTimer(time_CPU));
if(FilterMode == SOBEL_FILTER){
printf("Running Sobel\n");
CPU_Sobel(intput_image->data, output_image, input_image->x, input_image->y);
}
else if(FilterMode == HIGH_BOOST_FILTER){
printf("Running boost\n");
CPU_Boost(data, out, dib.width, dib.height);
}
cutilCheckError(cutStopTimer(time_CPU));
if(FilterMode == SOBEL_FILTER || FilterMode == SOBEL_FILTER5)
BitMapWrite("CPU_sobel.bmp", &bmp, &dib, out, palete);
else if(FilterMode == AVERAGE_FILTER)
BitMapWrite("CPU_average.bmp", &bmp, &dib, out, palete);
else if(FilterMode == HIGH_BOOST_FILTER)
BitMapWrite("CPU_boost.bmp", &bmp, &dib, out, palete);
printf("Done with CPU output\n");
printf("CPU execution time %f \n", cutGetTimerValue(time_CPU));
printf("Allocating %d bytes for image \n", dib.image_size);
cutilSafeCall( cudaMalloc( (void **)&d_In, dib.image_size*sizeof(unsigned char)) );
cutilSafeCall( cudaMalloc( (void **)&d_Out, dib.image_size*sizeof(unsigned char)) );
// creating space for filter matrix
cutilSafeCall( cudaMalloc( (void **)&sobel_matrix, 25*sizeof(float)) );
cutilCheckError(cutStartTimer(time_mem));
cudaMemcpy(d_In, data, dib.image_size*sizeof(unsigned char), cudaMemcpyHostToDevice);
cudaMemcpy(sobel_matrix, s_SobelMatrix, 25*sizeof(float), cudaMemcpyHostToDevice);
cutilCheckError(cutStopTimer(time_mem));
FilterWrapper(data, dib.width, dib.height);
// Copy image back to host
cutilCheckError(cutStartTimer(time_mem));
cudaMemcpy(out, d_Out, dib.image_size*sizeof(unsigned char), cudaMemcpyDeviceToHost);
cutilCheckError(cutStopTimer(time_mem));
printf("GPU execution time %f Memtime %f \n", cutGetTimerValue(time_GPU), cutGetTimerValue(time_mem));
printf("Total GPU = %f \n", (cutGetTimerValue(time_GPU) + cutGetTimerValue(time_mem)));
// Write output image
BitMapWrite(BMPOutFile, &bmp, &dib, out, palete);
Cleanup();
}
