void dump_frame(BIFSVID b2v, char *conv_buf, char *out_path, u32 dump_type, avi_t *avi_out, u32 frameNum) { u32 k; M4VideoSurface fb; /*lock it*/ SR_GetScreenBuffer(b2v.sr, &fb); /*export frame*/ switch (dump_type) { case 0: /*reverse frame*/ for (k=0; k<fb.height; k++) { memcpy(conv_buf + k*fb.width*3, fb.video_buffer + (fb.height-k-1) * fb.pitch, sizeof(char) * fb.width * 3); } if (AVI_write_frame(avi_out, conv_buf, fb.height*fb.width*3, 1) <0) printf("Error writing frame\n"); break; case 2: write_raw(&fb, out_path, frameNum); break; case 1: write_bmp(&fb, out_path, frameNum); break; } /*unlock it*/ SR_ReleaseScreenBuffer(b2v.sr, &fb); }
void save_screen_shot(int automap_flag) { static int savenum=0; char savename[13+sizeof(SCRNS_DIR)]; unsigned char *buf; if (!GameArg.DbgGlReadPixelsOk){ if (!automap_flag) HUD_init_message_literal(HM_DEFAULT, "glReadPixels not supported on your configuration"); return; } stop_time(); if (!PHYSFSX_exists(SCRNS_DIR,0)) PHYSFS_mkdir(SCRNS_DIR); //try making directory do { sprintf(savename, "%sscrn%04d.tga",SCRNS_DIR, savenum++); } while (PHYSFSX_exists(savename,0)); if (!automap_flag) HUD_init_message(HM_DEFAULT, "%s 'scrn%04d.tga'", TXT_DUMPING_SCREEN, savenum-1 ); #ifndef OGLES glReadBuffer(GL_FRONT); #endif buf = d_malloc(grd_curscreen->sc_w*grd_curscreen->sc_h*3); write_bmp(savename,grd_curscreen->sc_w,grd_curscreen->sc_h,buf); d_free(buf); start_time(); }
void BackProjection::create_prob() { int i, j; input = (unsigned char *)malloc(r * c * sizeof(unsigned char)); for (i = 0; i < r; i++) { for (j = 0; j < c; j++) { input[ i * c + j ] = FALSE; } } create_image(r, c, input, r < c ? r : c, r < c ? (F_TYPE) r / (F_TYPE) 4.0: (F_TYPE) c / (F_TYPE) 4.0); std::string inName = "BackProjection_ref_in.dat"; std::string bmpName = "BackProjection_ref_in.bmp"; printimage(r, c, input, inName.c_str()); write_bmp(bmpName.c_str(), input, r, c); rproj = (int *)malloc(r * sizeof(int)); cproj = (int *)malloc(c * sizeof(int)); uproj = (int *)malloc((r + c - 1) * sizeof(int)); dproj = (int *)malloc((r + c - 1) * sizeof(int)); rband = (int *)malloc(r * c * sizeof(int)); cband = (int *)malloc(c * sizeof(int)); uband = (int *)malloc((r + c - 1) * sizeof(int)); dband = (int *)malloc((r + c - 1) * sizeof(int)); makeband(r, c, rband, cband, uband, dband); create_input(r, c, input, rproj, cproj, uproj, dproj, uband, dband); }
int ray_trace(char* filename) { ray3_t primary_ray; int frame_z = 300; int frame_x = 0; int frame_y = 0; color_t hicolor; for (frame_x = 0; frame_x < frame_width; ++frame_x) { for (frame_y = 0; frame_y < frame_height; ++frame_y) { /* Primary Ray (test ray) */ primary_ray.origin = eye_origin; primary_ray.vector.x = (frame_x - (frame_width/2) - primary_ray.origin.x); primary_ray.vector.y = (frame_y - (frame_height/2) - primary_ray.origin.y); primary_ray.vector.z = (frame_z - primary_ray.origin.z); normalize_vector(&primary_ray.vector); hicolor = trace_ray(&primary_ray, 0); frame_buffer[frame_y][frame_x].r = (uint8_t) (hicolor.r * 0xFF); frame_buffer[frame_y][frame_x].g = (uint8_t) (hicolor.g * 0xFF); frame_buffer[frame_y][frame_x].b = (uint8_t) (hicolor.b * 0xFF); frame_buffer[frame_y][frame_x].a = (uint8_t) (hicolor.a * 0xFF); } } write_bmp(filename, frame_width, frame_height, frame_buffer); return 0; }
__inline__ int write_bmp(char * filename, rgb_t * pixel, int width, int height) { bmp_t bmp; int sizeImage = height* (int) real_width(width*sizeof(rgb_t));; bmp.file_header.type = 19778; bmp.file_header.reserved1 = bmp.file_header.reserved2 = 0; bmp.file_header.offsetbytes = 54; bmp.file_header.fsize = 54 + sizeImage; bmp.info_header.hsize = sizeof(bitmapInfoHeader_t); bmp.info_header.width = width; bmp.info_header.height = height; bmp.info_header.planes = 1; bmp.info_header.bitcount = 8 * sizeof(rgb_t); bmp.info_header.compression = 0; bmp.info_header.sizeimage = sizeImage; bmp.info_header.xpelspermeter = 0; bmp.info_header.ypelspermeter = 0; bmp.info_header.colorsused = 0; bmp.info_header.colorsimportant = 0; return write_bmp(filename, &bmp, pixel); }
//----------------------------------------------------------------------------- /// /// This method is for generating an bitmap image with some points representing /// a line, a circle in the middle of the image and a background color. /// /// @param points represents the line which has to be drawn onto the image. /// @param width is the resolution for the x-axis given in pixel. /// @param height is the resolution for the y-axis given in pixel. /// @param filename has to be a valid .bmp filename. /// /// @return int for success or failure of the whole function // int generateImage(short *points, int width, int height, char *filename) { int count_i; int row; int col; int radius; // Color circle: dark green // Color background: green // Color line: white // R, G, B Color col_circle = { 39, 174, 96 }; Color col_backgr = { 46, 204, 113 }; Color col_line = { 255, 255, 255 }; Byte data[height * width * 3]; Circle circle = { width / 2 - 1, height / 2 - 1, MIDDLE_CIRCLE_RADIUS }; for(count_i = 0; count_i < height * width * 3; count_i += 3) { row = (count_i / 3) / width; col = (count_i / 3) % width; // Get radius with pythagoras radius = sqrt(pow(fabs(row - circle.y_), 2) + pow(fabs(col - circle.x_), 2)); if(radius < circle.r_) { data[count_i] = col_circle.red_; data[count_i + 1] = col_circle.green_; data[count_i + 2] = col_circle.blue_; } else if(radius < circle.r_ + 1) { data[count_i] = (col_circle.red_ + col_backgr.red_) / 2; data[count_i + 1] = (col_circle.green_ + col_backgr.green_) / 2; data[count_i + 2] = (col_circle.blue_ + col_backgr.blue_) / 2; } else if (points[ARRAY_ACCESS(col, row, width)]) { data[count_i] = col_line.red_; data[count_i + 1] = col_line.green_; data[count_i + 2] = col_line.blue_; } else { data[count_i] = col_backgr.red_; data[count_i + 1] = col_backgr.green_; data[count_i + 2] = col_backgr.blue_; } } return write_bmp(filename, width, height, data); }
int main(void) { bmp_meta_t meta; unsigned char* image = read_bmp("test.bmp", &meta); if (image) { write_bmp(image, meta.width, meta.height, "test-copy.bmp"); } return 0; }
void BackProjection::output(void *param) { outParam *Param = reinterpret_cast < outParam * >(param); std::string outName = Param->outputFilename; std::string datName = outName + ".dat"; std::string bmpName = outName + ".bmp"; printimage(r, c, guess, datName.c_str()); write_bmp(bmpName.c_str(), guess, r, c); }
bool EmdTimBitmap::writeBmpFile(QString path) { QFile file(path); if (!file.open(QFile::WriteOnly | QFile::Truncate)) { return false; } QDataStream out(&file); bool stat = write_bmp(out, this->width(), this->height(), this->raw()); return stat; }
int render(const Setting& setting, Camera& camera, Screen& screen, Scene& scene, ImageBuffer& buffer) { int time_count = 1; clock_t start_time, current_time; float now_time; start_time = clock(); char fname[255]; for (int y = 0; y < setting.reso_h; y++) { Imath::Rand48 rnd; std::cout << "Rendering (y = " << y << ") " << (100.0 * y / (setting.reso_h - 1)) << "%" << std::endl; for (int x = 0; x < setting.reso_w; x++) { int index = (setting.reso_h - y - 1) * setting.reso_w + x; buffer[index] = Imath::C3f(0,0,0); for (int sy = 0; sy < setting.supersamples; sy++) { for (int sx = 0; sx < setting.supersamples; sx++) { Imath::C3f acm_rad = Imath::C3f(0,0,0); for (int s = 0; s < setting.samples; s++) { Ray ray = Ray(camera,screen,setting,x,y,sx,sy); acm_rad += radiance(scene, ray, rnd, 0) / setting.samples / (setting.supersamples * setting.supersamples); buffer[index] += acm_rad; current_time = clock(); now_time = static_cast<float>((current_time - start_time) / CLOCKS_PER_SEC); if (now_time > time_count * 60.0f) { std::cout << "width:" << setting.reso_w << std::endl; std::cout << "height:" << setting.reso_h << std::endl; std::cout << "sample:" << setting.samples << std::endl; std::cout << "subpixel:" << setting.supersamples << std::endl; std::cout << time_count << "minute(s)" << std::endl; std::cout << "image output..." << std::endl; sprintf(fname, "out_%02d.bmp", time_count); write_bmp(fname, buffer, setting); time_count++; } } } } } } return 0; }
int main_replaced(int argc, char** argv){ //Initialization MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); //Reading image if(rank == 0){ image = read_bmp("Lenna_blur.bmp"); } //Creating cartesian communicator MPI_Dims_create(size, 2, dims); MPI_Cart_create( MPI_COMM_WORLD, 2, dims, periods, 0, &cart_comm ); MPI_Cart_coords( cart_comm, rank, 2, coords ); MPI_Cart_shift( cart_comm, 0, 1, &north, &south ); MPI_Cart_shift( cart_comm, 1, 1, &west, &east ); local_image_size[0] = image_size[0]/dims[0]; local_image_size[1] = image_size[1]/dims[1]; //Allocating buffers int lsize = local_image_size[0]*local_image_size[1]; int lsize_border = (local_image_size[0] + 2*BORDER)*(local_image_size[1] + 2*BORDER); local_image_orig = (unsigned char*)malloc(sizeof(unsigned char)*lsize); local_image[0] = (unsigned char*)calloc(lsize_border, sizeof(unsigned char)); local_image[1] = (unsigned char*)calloc(lsize_border, sizeof(unsigned char)); create_types(); distribute_image(); initialilze_guess(); //Main loop for(int i = 0; i < ITERATIONS; i++){ exchange_borders(i); perform_convolution(i); } gather_image(); MPI_Finalize(); //Write image if(rank==0){ write_bmp(image, image_size[0], image_size[1]); } exit(0); }
void save_screen_shot(int automap_flag) { // fix t1; char message[100]; static int savenum=0; char savename[13]; unsigned char *buf; if (!ogl_readpixels_ok) { if (!automap_flag) hud_message(MSGC_GAME_FEEDBACK,"glReadPixels not supported on your configuration"); return; } stop_time(); //added/changed on 10/31/98 by Victor Rachels to fix overwrite each new game if ( savenum == 9999 ) savenum = 0; sprintf(savename,"scrn%04d.tga",savenum++); while(!access(savename,0)) { if ( savenum == 9999 ) savenum = 0; sprintf(savename,"scrn%04d.tga",savenum++); } sprintf( message, "%s '%s'", TXT_DUMPING_SCREEN, savename ); //end this section addition/change - Victor Rachels if (automap_flag) { // save_font = grd_curcanv->cv_font; // gr_set_curfont(GAME_FONT); // gr_set_fontcolor(gr_find_closest_color_current(0,31,0),-1); // gr_get_string_size(message,&w,&h,&aw); // modex_print_message(32, 2, message); } else { hud_message(MSGC_GAME_FEEDBACK,message); } buf = malloc(grd_curscreen->sc_w*grd_curscreen->sc_h*3); glReadBuffer(GL_FRONT); glReadPixels(0,0,grd_curscreen->sc_w,grd_curscreen->sc_h,GL_RGB,GL_UNSIGNED_BYTE,buf); write_bmp(savename,grd_curscreen->sc_w,grd_curscreen->sc_h,buf); free(buf); key_flush(); start_time(); }
int main(int argc, char** argv){ if(argc != 3){ printf("Usage: %s image n_threads\n", argv[0]); exit(-1); } int n_threads = atoi(argv[2]); // read from the input bmp image file unsigned char* image = read_bmp(argv[1]); unsigned char* output_image = malloc(sizeof(unsigned char) * image_size); // create a histogram for the pixel values int* histogram = (int*)calloc(sizeof(int), color_depth); #pragma omp parallel for num_threads(n_threads) for(int i = 0; i < image_size; i++){ int image_val = image[i]; // histogram[] is a shared variable, hence to avoid race conditions, critical clause has been used #pragma omp critical histogram[image_val]++; } float* transfer_function = (float*)calloc(sizeof(float), color_depth); // finding the normalised values using cumulative mass function // different scheduling clauses can be used here for comparative analysis #pragma omp parallel for num_threads(n_threads) schedule(static,1) for(int i = 0; i < color_depth; i++){ float sum = 0.0; for(int j = 0; j < i+1; j++){ sum += (float)histogram[j]; } transfer_function[i] += color_depth*((float)sum)/(image_size); } #pragma omp parallel for num_threads(n_threads) for(int i = 0; i < image_size; i++){ output_image[i] = transfer_function[image[i]]; } // write data to output bmp image file write_bmp(output_image, image_width, image_height); }
int main(int argc, char** argv){ if(argc != 3){ printf("Useage: %s image n_threads\n", argv[0]); exit(-1); } int n_threads = atoi(argv[2]); unsigned char* image = read_bmp(argv[1]); unsigned char* output_image = malloc(sizeof(unsigned char) * image_size); int* histogram = (int*)calloc(sizeof(int), color_depth); #pragma omp parallel for num_threads(n_threads) for(int i = 0; i < image_size; i++){ int image_val = image[i]; #pragma omp critical histogram[image_val]++; } float* transfer_function = (float*)calloc(sizeof(float), color_depth); #pragma omp parallel for num_threads(n_threads) schedule(static,1) for(int i = 0; i < color_depth; i++){ for(int j = 0; j < i+1; j++){ transfer_function[i] += color_depth*((float)histogram[j])/(image_size); } } #pragma omp parallel for num_threads(n_threads) for(int i = 0; i < image_size; i++){ output_image[i] = transfer_function[image[i]]; } write_bmp(output_image, image_width, image_height); }
int main(int argc, char *argv[]) { struct timeval tv_start, tv_end; int picture[WIDTH * HEIGHT]; #if 0 float real_start = -0.1592 - 0.01; float real_end = -0.1592 + 0.01; float imaginary_start = -1.0317 - 0.01; float imaginary_end = -1.0317 + 0.01; #endif float real_start = 0.37 - 0.00; float real_end = 0.37 + 0.04; float imaginary_start = -0.2166 - 0.02; float imaginary_end = -0.2166 + 0.02; #if 0 float real_start = -2.00; float real_end = 1.00; float imaginary_start = -1.00; float imaginary_end = 1.00; #endif int do_simd = 1; if (argc != 2) { printf("Usage: %s <normal/sse/avx2/avx_512>\n", argv[0]); exit(0); } if (strcmp(argv[1], "normal") == 0) { do_simd = 0; } else if (strcmp(argv[1], "sse") == 0) { do_simd = 1; } else if (strcmp(argv[1], "avx2") == 0) { do_simd = 2; } else if (strcmp(argv[1], "avx_512") == 0) { do_simd = 3; } gettimeofday(&tv_start, NULL); if (do_simd == 1) { mandel_calc_sse(picture, WIDTH, HEIGHT, real_start, real_end, imaginary_start, imaginary_end); } else if (do_simd == 2) { mandel_calc_avx2(picture, WIDTH, HEIGHT, real_start, real_end, imaginary_start, imaginary_end); } else if (do_simd == 3) { mandel_calc_avx_512(picture, WIDTH, HEIGHT, real_start, real_end, imaginary_start, imaginary_end); } else { mandel_calc(picture, WIDTH, HEIGHT, real_start, real_end, imaginary_start, imaginary_end); } gettimeofday(&tv_end, NULL); #if 0 int picture2[WIDTH * HEIGHT]; mandel_calc(picture2, WIDTH, HEIGHT, real_start, real_end, imaginary_start, imaginary_end); int n; for (n = 0; n < WIDTH * HEIGHT; n++) { if (picture[n] != picture2[n]) { printf("error %d %8x %8x\n", n, picture[n], picture2[n]); } } #endif printf("%ld %ld\n", tv_end.tv_sec, tv_end.tv_usec); printf("%ld %ld\n", tv_start.tv_sec, tv_start.tv_usec); long time_diff = tv_end.tv_usec - tv_start.tv_usec; while(time_diff < 0) { tv_end.tv_sec--; time_diff += 1000000; } time_diff += (tv_end.tv_sec - tv_start.tv_sec) * 1000000; printf("time=%f\n", (float)time_diff / 1000000); write_bmp(picture, WIDTH, HEIGHT); return 0; }
int main(int argc, char *argv[]) { char* szOutputFilename = 0; char* szInputFilename = 0; uint32_t ulColorSelectorIndex = 0; FILE* pFile; struct stat sFileStatus; int nStatus; uint32_t ulBlockSize; uint8_t* pBlockBuffer; void* pImageBuffer; bmp_pixel32_t* pImageBufferIndex; int nImageBufferSize; int nImageWidth; int nImageHeight; uint32_t ulSectorCount = 0; uint32_t ulSectorIndex = 0; uint32_t ulPercentDemoninator; uint32_t ulPercentComplete = 0; uint32_t ulPercentTemporary = 0; int nReturnValue = 0; void (*pfColorSelect)(bmp_pixel32_t*, uint8_t*, uint32_t) = 0; memset(&sFileStatus, 0x0, sizeof(struct stat)); if (argc != 6) { fprintf(stderr, "Usage: %s [input filename] [ouput filename] [block size] [image width] [color selector]\n", argv[0]); nReturnValue = -1; } else { szInputFilename = argv[1]; szOutputFilename = argv[2]; sscanf(argv[3], "%lu", &ulBlockSize); sscanf(argv[4], "%lu", &nImageWidth); sscanf(argv[5], "%lu", &ulColorSelectorIndex); switch (ulColorSelectorIndex) { case AVERAGE: pfColorSelect = cs_average; break; case STDDEV: pfColorSelect = cs_stddev; break; case SOLID_FF: pfColorSelect = cs_solidffs; break; case CHKSUM24: pfColorSelect = cs_sum24; break; default: pfColorSelect = 0; break; } if (0 == pfColorSelect) { fprintf(stderr, "Invalid color selector index: %lu. Valid selections:\n" " 0. Average\n" " 1. Standard Deviation\n" " 2. Solid FFs\n" " 3. Checksum (24-bit)\n", ulColorSelectorIndex); nReturnValue = -1; } else if (0 == (pBlockBuffer = (uint8_t*) malloc(ulBlockSize))) { fprintf(stderr, "buffer allocation failed.\n"); nReturnValue = -1; } /* Status the file size. */ else if (0 != (nStatus = stat(szInputFilename, &sFileStatus))) { fprintf(stderr, "stat() failed on file: '%s. Error Code: %d\n", szInputFilename, nStatus); nReturnValue = -1; } /* Open the file. */ else if(0 == (pFile = fopen(szInputFilename, "rb"))) { fprintf(stderr, "fopen() failed on file: '%s.\n", szInputFilename); nReturnValue = -1; } /* Process the file. */ else { /* find the number of bits in image. */ ulSectorCount = ((uint32_t) sFileStatus.st_size / ulBlockSize); /* find the number of rows required to fit all bits. */ nImageHeight = ((ulSectorCount + (nImageWidth - 1)) / nImageWidth); /* nImageBufferSize = (sFileStatus.st_size / SECTOR_SIZE) * sizeof(bmp_pixel32_t); */ nImageBufferSize = (nImageWidth * nImageHeight) * sizeof(bmp_pixel32_t); /* Allocate Image Buffer. */ if (0 == (pImageBuffer = malloc(nImageBufferSize))) { fprintf(stderr, "buffer allocation failed.\n"); nReturnValue = -1; } /* Process the file data. */ else { memset (pImageBuffer, 0x00, nImageBufferSize); pImageBufferIndex = (bmp_pixel32_t*) pImageBuffer; /* Current Sector Index / Percent Denominator equals (percentage * 10) */ ulPercentDemoninator = (ulSectorCount / 1000); /* Read the buffer, 512 bytes at a time. */ while (1 == fread(pBlockBuffer,ulBlockSize,1,pFile)) { pfColorSelect(pImageBufferIndex, pBlockBuffer, ulBlockSize); ++pImageBufferIndex; ++ulSectorIndex; ulPercentTemporary = (ulSectorIndex / ulPercentDemoninator); if (ulPercentComplete != ulPercentTemporary) { ulPercentComplete = ulPercentTemporary; fprintf(stdout, "Processing %3lu.%lu%%...\r", (ulPercentComplete / 10), (ulPercentComplete % 10)); } } /* Write the image buffer to file. */ write_bmp(szOutputFilename, nImageWidth, nImageHeight, pImageBuffer); /* Free the buffer. */ free (pImageBuffer); pImageBuffer = 0; } /* Close the file. */ if((pFile != 0) && (0 != (nStatus = fclose(pFile)))) { fprintf(stderr, "fclose() failed on file: '%s.\n", szInputFilename); nReturnValue = -1; } /* Free the buffer. */ free (pBlockBuffer); pBlockBuffer = 0; } } return nReturnValue; }
// Serial ray casting unsigned char* raycast_serial(unsigned char* data, unsigned char* region){ unsigned char* image = (unsigned char*)malloc(sizeof(unsigned char)*IMAGE_DIM*IMAGE_DIM); // Camera/eye position, and direction of viewing. These can be changed to look // at the volume from different angles. float3 camera = {.x=1000,.y=1000,.z=1000}; float3 forward = {.x=-1, .y=-1, .z=-1}; float3 z_axis = {.x=0, .y=0, .z = 1}; // Finding vectors aligned with the axis of the image float3 right = cross(forward, z_axis); float3 up = cross(right, forward); // Creating unity lenght vectors forward = normalize(forward); right = normalize(right); up = normalize(up); float fov = 3.14/4; float pixel_width = tan(fov/2.0)/(IMAGE_DIM/2); float step_size = 0.5; // For each pixel for(int y = -(IMAGE_DIM/2); y < (IMAGE_DIM/2); y++){ for(int x = -(IMAGE_DIM/2); x < (IMAGE_DIM/2); x++){ // Find the ray for this pixel float3 screen_center = add(camera, forward); float3 ray = add(add(screen_center, scale(right, x*pixel_width)), scale(up, y*pixel_width)); ray = add(ray, scale(camera, -1)); ray = normalize(ray); float3 pos = camera; // Move along the ray, we stop if the color becomes completely white, // or we've done 5000 iterations (5000 is a bit arbitrary, it needs // to be big enough to let rays pass through the entire volume) int i = 0; float color = 0; while(color < 255 && i < 5000){ i++; pos = add(pos, scale(ray, step_size)); // Update position int r = value_at(pos, region); // Check if we're in the region color += value_at(pos, data)*(0.01 + r) ; // Update the color based on data value, and if we're in the region } // Write final color to image image[(y+(IMAGE_DIM/2)) * IMAGE_DIM + (x+(IMAGE_DIM/2))] = color > 255 ? 255 : color; } } return image; } // Check if two values are similar, threshold can be changed. int similar(unsigned char* data, int3 a, int3 b){ unsigned char va = data[a.z * DATA_DIM*DATA_DIM + a.y*DATA_DIM + a.x]; unsigned char vb = data[b.z * DATA_DIM*DATA_DIM + b.y*DATA_DIM + b.x]; int i = abs(va-vb) < 1; return i; } // Serial region growing, same algorithm as in assignment 2 unsigned char* grow_region_serial(unsigned char* data){ unsigned char* region = (unsigned char*)calloc(sizeof(unsigned char), DATA_DIM*DATA_DIM*DATA_DIM); stack_t* stack = new_stack(); int3 seed = {.x=50, .y=300, .z=300}; push(stack, seed); region[seed.z *DATA_DIM*DATA_DIM + seed.y*DATA_DIM + seed.x] = 1; int dx[6] = {-1,1,0,0,0,0}; int dy[6] = {0,0,-1,1,0,0}; int dz[6] = {0,0,0,0,-1,1}; while(stack->size > 0){ int3 pixel = pop(stack); for(int n = 0; n < 6; n++){ int3 candidate = pixel; candidate.x += dx[n]; candidate.y += dy[n]; candidate.z += dz[n]; if(!inside_int(candidate)){ continue; } if(region[candidate.z * DATA_DIM*DATA_DIM + candidate.y*DATA_DIM + candidate.x]){ continue; } if(similar(data, pixel, candidate)){ push(stack, candidate); region[candidate.z * DATA_DIM*DATA_DIM + candidate.y*DATA_DIM + candidate.x] = 1; } } } return region; } unsigned char* grow_region_gpu(unsigned char* data){ cl_platform_id platform; cl_device_id device; cl_context context; cl_command_queue queue; cl_kernel kernel; cl_int err; char *source; int i; clGetPlatformIDs(1, &platform, NULL); clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL); context = clCreateContext(NULL, 1, &device, NULL, NULL, &err); printPlatformInfo(platform); queue = clCreateCommandQueue(context, device, 0, &err); kernel = buildKernel("region.cl", "region", NULL, context, device); //Host variables unsigned char* host_region = (unsigned char*)calloc(sizeof(unsigned char), DATA_SIZE); int host_unfinished; cl_mem device_region = clCreateBuffer(context, CL_MEM_READ_WRITE, DATA_SIZE * sizeof(cl_uchar) ,NULL,&err); cl_mem device_data = clCreateBuffer(context, CL_MEM_READ_ONLY, DATA_SIZE * sizeof(cl_uchar), NULL,&err); cl_mem device_unfinished = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), NULL,&err); clError("Error allocating memory", err); //plant seed int3 seed = {.x=50, .y=300, .z=300}; host_region[index(seed.z, seed.y, seed.x)] = 2; //Copy data to the device clEnqueueWriteBuffer(queue, device_data , CL_FALSE, 0, DATA_SIZE * sizeof(cl_uchar), data , 0, NULL, NULL); clEnqueueWriteBuffer(queue, device_region, CL_FALSE, 0, DATA_SIZE * sizeof(cl_uchar), host_region, 0, NULL, NULL); //Calculate block and grid sizes size_t global[] = { 512, 512, 512 }; size_t local[] = { 8, 8, 8 }; //Run kernel untill completion do{ host_unfinished = 0; clEnqueueWriteBuffer(queue, device_unfinished, CL_FALSE, 0, sizeof(cl_int), &host_unfinished , 0, NULL, NULL); clFinish(queue); err = clSetKernelArg(kernel, 0, sizeof(device_data), (void*)&device_data); err = clSetKernelArg(kernel, 1, sizeof(device_region), (void*)&device_region); err = clSetKernelArg(kernel, 2, sizeof(device_unfinished), (void*)&device_unfinished); clError("Error setting arguments", err); //Run the kernel clEnqueueNDRangeKernel(queue, kernel, 3, NULL, &global, &local, 0, NULL, NULL); clFinish(queue); clError("Error running kernel", err); err = clEnqueueReadBuffer(queue, device_unfinished, CL_TRUE, 0, sizeof(cl_int), &host_unfinished, 0, NULL, NULL); clFinish(queue); clError("Error reading buffer 1", err); }while(host_unfinished); //Copy result to host err = clEnqueueReadBuffer(queue, device_region, CL_TRUE, 0, DATA_SIZE * sizeof(cl_uchar), host_region, 0, NULL, NULL); clFinish(queue); clError("Error reading buffer 2", err); return host_region; } unsigned char* raycast_gpu(unsigned char* data, unsigned char* region){ cl_platform_id platform; cl_device_id device; cl_context context; cl_command_queue queue; cl_kernel kernel; cl_int err; char *source; int i; clGetPlatformIDs(1, &platform, NULL); clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL); context = clCreateContext(NULL, 1, &device, NULL, NULL, &err); printPlatformInfo(platform); printDeviceInfo(device); queue = clCreateCommandQueue(context, device, 0, &err); kernel = buildKernel("raycast.cl", "raycast", NULL, context, device); cl_mem device_region = clCreateBuffer(context, CL_MEM_READ_ONLY, DATA_SIZE * sizeof(cl_uchar) ,NULL,&err); cl_mem device_data = clCreateBuffer(context, CL_MEM_READ_ONLY, DATA_SIZE * sizeof(cl_uchar), NULL,&err); cl_mem device_image = clCreateBuffer(context, CL_MEM_READ_WRITE, IMAGE_SIZE * sizeof(cl_uchar),NULL,&err); clError("Error allocating memory", err); //Copy data to the device clEnqueueWriteBuffer(queue, device_data , CL_FALSE, 0, DATA_SIZE * sizeof(cl_uchar), data , 0, NULL, NULL); clEnqueueWriteBuffer(queue, device_region, CL_FALSE, 0, DATA_SIZE * sizeof(cl_uchar), region, 0, NULL, NULL); int grid_size = IMAGE_DIM; int block_size = IMAGE_DIM; //Set up kernel arguments err = clSetKernelArg(kernel, 0, sizeof(device_data), (void*)&device_data); err = clSetKernelArg(kernel, 1, sizeof(device_region), (void*)&device_region); err = clSetKernelArg(kernel, 2, sizeof(device_image), (void*)&device_image); clError("Error setting arguments", err); //Run the kernel const size_t globalws[2] = {IMAGE_DIM, IMAGE_DIM}; const size_t localws[2] = {8, 8}; clEnqueueNDRangeKernel(queue, kernel, 2, NULL, &globalws, &localws, 0, NULL, NULL); clFinish(queue); //Allocate memory for the result unsigned char* host_image = (unsigned char*)malloc(IMAGE_SIZE_BYTES); //Copy result from device err = clEnqueueReadBuffer(queue, device_image, CL_TRUE, 0, IMAGE_SIZE * sizeof(cl_uchar), host_image, 0, NULL, NULL); clFinish(queue); //Free device memory return host_image; } int main(int argc, char** argv){ unsigned char* data = create_data(); unsigned char* region = grow_region_gpu(data); unsigned char* image = raycast_gpu(data, region); write_bmp(image, IMAGE_DIM, IMAGE_DIM); }
/*generates an intertwined bmp from a scene file with 5 different viewpoints*/ void bifs3d_viewpoints_merger(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time) { GF_User user; char out_path[GF_MAX_PATH]; char old_driv[1024]; BIFSVID b2v; Bool needs_raw; GF_Err e; GF_VideoSurface fb; unsigned char **rendered_frames; u32 nb_viewpoints = 5; u32 viewpoint_index; /* Configuration of the Rendering Capabilities */ { const char *test; char config_path[GF_MAX_PATH]; memset(&user, 0, sizeof(GF_User)); user.config = gf_cfg_init(szConfigFile, NULL); if (!user.config) { fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path); return; } test = gf_cfg_get_key(user.config, "General", "ModulesDirectory"); user.modules = gf_modules_new((const unsigned char *) test, user.config); strcpy(old_driv, "raw_out"); if (!gf_modules_get_count(user.modules)) { printf("Error: no modules found\n"); goto err_exit; } /*switch driver to raw_driver*/ test = gf_cfg_get_key(user.config, "Video", "DriverName"); if (test) strcpy(old_driv, test); needs_raw = 0; test = gf_cfg_get_key(user.config, "Compositor", "RendererName"); /*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/ if (test && strstr(test, "2D")) { gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output"); needs_raw = 1; } if (needs_raw) { test = gf_cfg_get_key(user.config, "Video", "DriverName"); if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) { printf("couldn't load raw output driver (%s used)\n", test); goto err_exit; } } } memset(&b2v, 0, sizeof(BIFSVID)); user.init_flags = GF_TERM_NO_AUDIO; /* Initialization of the compositor */ b2v.sr = gf_sc_new(&user, 0, NULL); gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0); /* Initialization of the scene graph */ b2v.sg = gf_sg_new(); gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v); gf_sg_set_init_callback(b2v.sg, node_init, &b2v); gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v); /*load config*/ gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1); { u32 di; u32 track_number; GF_ESD *esd; u16 es_id; b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0); for (track_number=0; track_number<gf_isom_get_track_count(file); track_number++) { esd = gf_isom_get_esd(file, track_number+1, 1); if (!esd) continue; if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break; gf_odf_desc_del((GF_Descriptor *) esd); esd = NULL; } if (!esd) { printf("no bifs track found\n"); goto err_exit; } es_id = (u16) gf_isom_get_track_id(file, track_number+1); e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication); if (e) { printf("BIFS init error %s\n", gf_error_to_string(e)); gf_odf_desc_del((GF_Descriptor *) esd); esd = NULL; goto err_exit; } { GF_ISOSample *samp = gf_isom_get_sample(file, track_number+1, 1, &di); b2v.cts = samp->DTS + samp->CTS_Offset; /*apply command*/ gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0); gf_isom_sample_del(&samp); } b2v.duration = gf_isom_get_media_duration(file, track_number+1); gf_odf_desc_del((GF_Descriptor *) esd); } gf_sc_set_scene(b2v.sr, b2v.sg); if (!width || !height) { gf_sg_get_scene_size_info(b2v.sg, &width, &height); } /*we work in RGB24, and we must make sure the pitch is %4*/ if ((width*3)%4) { printf("Adjusting width (%d) to have a stride multiple of 4\n", width); while ((width*3)%4) width--; } gf_sc_set_size(b2v.sr, width, height); gf_sc_get_screen_buffer(b2v.sr, &fb); width = fb.width; height = fb.height; gf_sc_release_screen_buffer(b2v.sr, &fb); GF_SAFEALLOC(rendered_frames, nb_viewpoints*sizeof(char *)); for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) { GF_SAFEALLOC(rendered_frames[viewpoint_index-1], fb.width*fb.height*3); gf_sc_set_viewpoint(b2v.sr, viewpoint_index, NULL); gf_sc_draw_frame(b2v.sr); /*needed for background2D !!*/ gf_sc_draw_frame(b2v.sr); strcpy(out_path, ""); if (out_dir) { strcat(out_path, out_dir); if (out_path[strlen(out_path)-1] != '\\') strcat(out_path, "\\"); } strcat(out_path, rad_name); strcat(out_path, "_view"); gf_sc_get_screen_buffer(b2v.sr, &fb); write_bmp(&fb, out_path, viewpoint_index); memcpy(rendered_frames[viewpoint_index-1], fb.video_buffer, fb.width*fb.height*3); gf_sc_release_screen_buffer(b2v.sr, &fb); } if (width != 800 || height != 480) { printf("Wrong scene dimension, cannot produce output\n"); goto err_exit; } else { u32 x, y; GF_VideoSurface out_fb; u32 bpp = 3; out_fb.width = 800; out_fb.height = 480; out_fb.pitch = 800*bpp; out_fb.pixel_format = GF_PIXEL_RGB_24; out_fb.is_hardware_memory = 0; GF_SAFEALLOC(out_fb.video_buffer, out_fb.pitch*out_fb.height) #if 1 for (y=0; y<out_fb.height; y++) { /*starting red pixel is R1, R5, R4, R3, R2, R1, R5, ... when increasing line num*/ u32 line_shift = (5-y) % 5; for (x=0; x<out_fb.width; x++) { u32 view_shift = (line_shift+bpp*x)%5; u32 offset = out_fb.pitch*y + x*bpp; /* red */ out_fb.video_buffer[offset] = rendered_frames[view_shift][offset]; /* green */ out_fb.video_buffer[offset+1] = rendered_frames[(view_shift+1)%5][offset+1]; /* blue */ out_fb.video_buffer[offset+2] = rendered_frames[(view_shift+2)%5][offset+2]; } } #else /*calibration*/ for (y=0; y<out_fb.height; y++) { u32 line_shift = (5- y%5) % 5; for (x=0; x<out_fb.width; x++) { u32 view_shift = (line_shift+bpp*x)%5; u32 offset = out_fb.pitch*y + x*bpp; out_fb.video_buffer[offset] = ((view_shift)%5 == 2) ? 0xFF : 0; out_fb.video_buffer[offset+1] = ((view_shift+1)%5 == 2) ? 0xFF : 0; out_fb.video_buffer[offset+2] = ((view_shift+2)%5 == 2) ? 0xFF : 0; } } #endif write_bmp(&out_fb, "output", 0); } /*destroy everything*/ gf_bifs_decoder_del(b2v.bifs); gf_sg_del(b2v.sg); gf_sc_set_scene(b2v.sr, NULL); gf_sc_del(b2v.sr); err_exit: /* if (rendered_frames) { for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) { if (rendered_frames[viewpoint_index-1]) gf_free(rendered_frames[viewpoint_index-1]); } gf_free(rendered_frames); } if (output_merged_frame) gf_free(output_merged_frame); */ if (user.modules) gf_modules_del(user.modules); if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv); gf_cfg_del(user.config); }
inline int image_proc(u8 ** index, u8 * image_buf, u8 * color_buf, int width, int height, BMP_HEADER * p_header) { char interact = 0; int char_test = 0; while (1) { printf("\n\nDIP has already held your image, what's next?\n" "type:\n" "[s] -> smooth\n" "[h] -> sharp\n" "[l] -> enlarge / shrink\n" "[r] -> rotate\n" "[e] -> exit\n\n"); while ((char_test = getchar()) != '\n' && char_test != EOF) { interact = char_test; /* * so significant here * we need just a char, if user inputs such as 'sel', * so the final char which installed in the var is * 'l', not 's' */ while ((char_test = getchar()) != '\n' && char_test != EOF) ; break; } switch (interact) { case 's': printf("which algorithm u wanna use?\n" "type:\n" "[k] -> k_near_average\n" "[a] -> average_filter \t[1, 1, 1, 1, 1, 1, 1, 1, 1]\n" "[m] -> median_filter\n"); __asm__ __volatile__("2:"); while ((char_test = getchar()) != '\n' && char_test != EOF) { interact = char_test; while ((char_test = getchar()) != '\n' && char_test != EOF) ; break; } switch (interact) { case 'k': smooth_avr_k(index, height, width); break; case 'a': smooth_avr_filter(index, height, width); break; case 'm': smooth_median_filter(index, height, width); break; default: printf("\nhey bro, type \"k\" or \"9\"\n"); __asm__ __volatile__("jmp 2b"); break; } if (write_bmp(p_header, color_buf, image_buf)) { printf("Sorry, Failure!\n"); } printf("Well Done!\n"); break; case 'h': printf("which algorithm u wanna use?\n" "type:\n" "[l] -> laplacian \t[0, 1, 0; 1, -4, 1; 0, 1, 0]\n" "[f] -> high pass filter [-1, -1, -1; -1, 9, -1; -1, -1, -1]\n" "[a] -> ladder \t\t[-1, 1; -1, 1]\n"); __asm__ __volatile__("3:"); while ((char_test = getchar()) != '\n' && char_test != EOF) { interact = char_test; while ((char_test = getchar()) != '\n' && char_test != EOF) ; break; } switch (interact) { case 'a': sharp_ladder(index, height, width); break; case 'l': sharp_laplacian(index, height, width); break; case 'f': sharp_hpass_filter(index, height, width); break; default: printf("\nhey bro, type \"l\" or \"f\"\n"); __asm__ __volatile__("jmp 3b"); break; } if (write_bmp(p_header, color_buf, image_buf)) { printf("Sorry, Failure!\n"); } printf("Well Done!\n"); break; case 'l': stretch(index, p_header, color_buf, width, height); break; case 'r': rotate(index, p_header, color_buf, width, height); break; case 'e': { int i = 0; for (; i < 10; i++) { printf("%x %c\n", *bp, *bp); bp++; } free(p_header); /* to avoid accessing freed memory */ p_header = NULL; } return 0; default: printf("\nHey bro, please follow the rule\n"); break; } } }
int write_image(const char *filename, int width, int height, unsigned char *rgb) { FILE *outfile; char *extension = strrchr(filename, '.'); char *lowercase; char *ptr; int success = 0; lowercase = malloc(strlen(extension) + 1); strcpy(lowercase, extension); ptr = lowercase; while (*ptr != '\0') *ptr++ = tolower(*extension++); outfile = fopen(filename, "wb"); if (outfile == NULL) return(0); if (strcmp(lowercase, ".bmp" ) == 0) { success = write_bmp(filename, width, height, rgb); } else if (strcmp(lowercase, ".gif" ) == 0) { #ifdef HAVE_LIBGIF success = write_gif(filename, width, height, rgb); #else fprintf(stderr, "Sorry, this program was not compiled with GIF support\n"); success = 0; #endif /* HAVE_LIBPNG */ } else if (( strcmp(lowercase, ".jpg" ) == 0) || (strcmp(lowercase, ".jpeg") == 0)) { #ifdef HAVE_LIBJPEG success = write_jpeg(outfile, width, height, rgb, Q); #else fprintf(stderr, "Sorry, this program was not compiled with JPEG support\n"); success = 0; #endif /* HAVE_LIBJPEG */ } else if (strcmp(lowercase, ".png" ) == 0) { #ifdef HAVE_LIBPNG success = write_png(outfile, width, height, rgb, alpha); #else fprintf(stderr, "Sorry, this program was not compiled with PNG support\n"); success = 0; #endif /* HAVE_LIBPNG */ } else if (( strcmp(lowercase, ".pbm") == 0) || (strcmp(lowercase, ".pgm") == 0) || (strcmp(lowercase, ".ppm") == 0)) { #ifdef HAVE_LIBPNM if (strcmp(lowercase, ".pbm") == 0) success = write_pnm(outfile, width, height, rgb, 1, PBM_TYPE, 0); else if (strcmp(lowercase, ".pgm") == 0) success = write_pnm(outfile, width, height, rgb, 255, PGM_TYPE, 0); else if (strcmp(lowercase, ".ppm") == 0) success = write_pnm(outfile, width, height, rgb, 255, PPM_TYPE, 0); #else fprintf(stderr, "Sorry, this program was not compiled with PNM support\n"); success = 0; #endif /* HAVE_LIBPNM */ } else if ((strcmp(lowercase, ".tif" ) == 0) || (strcmp(lowercase, ".tiff" ) == 0)) { #ifdef HAVE_LIBTIFF success = write_tiff(filename, width, height, rgb); #else fprintf(stderr, "Sorry, this program was not compiled with TIFF support\n"); success = 0; #endif /* HAVE_LIBTIFF */ } else { fprintf(stderr, "Unknown image format\n"); success = 0; } free(lowercase); fclose(outfile); return(success); }
int main(int argc, char** argv) { int x = 0, y = 0, sample = 0, subpixel = 0; int i = 1; while (true) { if (i >= argc) break; if (std::string(argv[i]).compare("-x") == 0) { i++; x = atoi(argv[i]); i++; continue; } if (std::string(argv[i]).compare("-y") == 0) { i++; y = atoi(argv[i]); i++; continue; } if (std::string(argv[i]).compare("-s") == 0) { i++; sample = atoi(argv[i]); i++; continue; } if (std::string(argv[i]).compare("-p") == 0) { i++; subpixel = atoi(argv[i]); i++; continue; } } if (x == 0 || y == 0 || sample == 0 || subpixel == 0) { std::cout << "argv error. using default setting." << std::endl; x = 640; y = 480; sample = 4; subpixel = 2; } std::cout << "width:" << x << std::endl; std::cout << "height:" << y << std::endl; std::cout << "sample:" << sample << std::endl; std::cout << "subpixel:" << subpixel << std::endl; Setting render_settings(x, y, sample, subpixel); Camera cam(Imath::V3d(50.0, 52.0, 220.0), Imath::V3d(0.0, -0.04, -30.0).normalized(), Imath::V3d(0.0, -1.0, 0.0)); Screen screen(cam, render_settings); ImageBuffer image(render_settings.reso_w * render_settings.reso_h); //Mesh mesh = Mesh(); //mesh.push_back(Triangle(Imath::V3d(12.8, 5.0, -10), Imath::V3d(5.0, 20.0, -10), Imath::V3d(20.0, 20.0, -10))); //Geometry geom(mesh, Imath::V3d(0, 0, 0), Imath::C3f(0.7, 0.5, 0.5)); //Geometry geom(mesh, Imath::V3d(0, 0, 0), Imath::C3f(0.7, 0.5, 0.5)); Scene scene; //scene.geometries.push_back(geom); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(1e5 + 1, 40.8, 81.6), 1e5), Imath::V3d(1e5 + 1, 40.8, 81.6), Imath::C3f(0.75, 0.25, 0.25), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(-1e5 + 99, 40.8, 81.6), 1e5), Imath::V3d(-1e5 + 99, 40.8, 81.6), Imath::C3f(0.25, 0.25, 0.75), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(50, 40.8, 1e5), 1e5), Imath::V3d(50, 40.8, 1e5), Imath::C3f(0.75, 0.75, 0.75), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(50, 40.8, -1e5 + 250), 1e5), Imath::V3d(50, 40.8, -1e5 + 250), Imath::C3f(0.0, 0.0, 0.0), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(50, 1e5, 81.6), 1e5), Imath::V3d(50, 1e5, 81.6), Imath::C3f(0.75, 0.75, 0.75), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(50, -1e5 + 81.6, 81.6), 1e5), Imath::V3d(50, -1e5 + 81.6, 81.6), Imath::C3f(0.75, 0.75, 0.75), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(65, 20, 20), 20), Imath::V3d(65, 20, 20), Imath::C3f(0.25, 0.75, 0.25), Imath::C3f(0, 0, 0), Reflection::Diffuse)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(27, 16.5, 47), 16.5), Imath::V3d(27, 16.5, 47), Imath::C3f(0.99, 0.99, 0.99), Imath::C3f(0, 0, 0), Reflection::Specular)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(77, 16.5, 78), 16.5), Imath::V3d(77, 16.5, 78), Imath::C3f(0.99, 0.99, 0.99), Imath::C3f(0, 0, 0), Reflection::Refraction)); scene.geometries.push_back(Geometry(Sphere(Imath::V3d(50, 90, 81.6), 15.0), Imath::V3d(50, 90, 81.6), Imath::C3f(0.0, 0.0, 0.0), Imath::C3f(36, 36, 36), Reflection::Diffuse)); //scene.geometries.push_back(Geometry(Triangle(Imath::V3d(12.8, 5.0, -10), Imath::V3d(5.0, 20.0, -10), Imath::V3d(20.0, 20.0, -10)), Imath::V3d(65, 20, 20), Imath::C3f(0.75, 0.75, 0.75), Imath::C3f(0, 0, 0), Reflection::Diffuse)); render(render_settings,cam,screen,scene,image); write_bmp("out_complete.bmp", image, render_settings); return 0; }
int main(int argc, char **argv) { // bmp_t *b1, *b2, *bout; img_t *i1, *i2, **m; FILE *f; double zweight; int diameter; img_pyr_t *a_imgpyr, *b_imgpyr; #if 1 double tmin = 0, tmax = 1.0; int i, steps = 32; #else double tmin = 0.5, tmax = 0.5; int i, steps = 1; #endif img_dist_pyr_t *apyr, *bpyr; if (argc != 8) { printf("Usage: morphimg2 <zweight> <diameter> <in1.bmp> <in2.bmp> <in1.pyr> <in2.pyr> <out.bmp>\n"); return 1; } zweight = atof(argv[1]); diameter = atoi(argv[2]); #if 0 /* Read the first bitmap */ f = fopen(argv[3], "r"); if (f == NULL) { printf("Could not open file %s for reading\n", argv[3]); return 1; } b1 = read_bmp(f); fclose(f); /* Read the second bitmap */ f = fopen(argv[4], "r"); if (f == NULL) { printf("Could not open file %s for reading\n", argv[4]); return 1; } b2 = read_bmp(f); fclose(f); /* Convert the bitmaps to images */ if (b1 == NULL || b2 == NULL) { printf("Error reading bitmaps\n"); return 1; } i1 = bmp2img(b1), i2 = bmp2img(b2); if (i1 == NULL || i2 == NULL) { printf("Error in bmp2img conversion\n"); return 1; } #endif i1 = img_read_bmp_file(argv[3]); i2 = img_read_bmp_file(argv[4]); /* Read the first map */ f = open_file(argv[5], "r"); apyr = img_read_distance_pyramid(f); fclose(f); /* Read the second map */ f = open_file(argv[6], "r"); bpyr = img_read_distance_pyramid(f); fclose(f); set_ann_z_weight(zweight); a_imgpyr = img_create_gaussian_pyramid(i1, 0); b_imgpyr = img_create_gaussian_pyramid(i2, 0); #if 1 m = img_morph3(i1, i2, diameter, &(apyr->dmaps[0]), &(bpyr->dmaps[0]), zweight, 1, tmin, tmax, steps); for (i = 0; i < steps; i++) { char outfile[64]; #if 0 bout = img2bmp(m[i]); if (bout == NULL) { printf("Error in img2bmp conversion\n"); return 1; } #endif sprintf(outfile, "%s%03d.bmp", argv[7], i); f = fopen(outfile, "w"); if (f == NULL) { printf("Error opening %s for writing\n", outfile); return 1; } // write_bmp(f, bout); // fclose(f); img_write_bmp_file(m[i], outfile); // free_bmp(bout); } #else iout = img_morph(i1, i2); bout = img2bmp(iout); if (bout == NULL) { printf("Error in img2bmp conversion\n"); return 1; } f = fopen(argv[7], "w"); if (f == NULL) { printf("Error opening %s for writing\n", argv[7]); return 1; } write_bmp(f, bout); fclose(f); free_bmp(bout); #endif // free_bmp(b1); // free_bmp(b2); img_free(i1); img_free(i2); return 0; }
int main(int argc, char **argv) { cl_int status; const char *platform_name = "NVIDIA"; if (!find_platform(platform_name, &platform)) { fprintf(stderr,"Error: Platform \"%s\" not found\n", platform_name); print_platforms(); teardown(-1); } status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 1, &device, NULL); checkError (status, "Error: could not query devices"); context = clCreateContext(NULL, 1, &device, NULL, NULL, &status); checkError(status, "could not create context"); const char name[] = KERNELDIR "/gauss.cl"; unsigned char *source; size_t size; if (!load_file(name, &source, &size)) { teardown(-1); } program = clCreateProgramWithSource(context, 1, (const char **) &source, &size, &status); checkError(status, "Error: failed to create program %s: ", name); status = clBuildProgram(program, 1, &device, "-I.", NULL, NULL); if (status != CL_SUCCESS) { print_build_log(program, device); checkError(status, "Error: failed to create build %s: ", name); } free(source); print_device_info(device, 0); queue = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, &status); checkError(status, "could not create command queue"); cl_ulong start, end; cl_event event; unsigned char *data; size_t datasize; if (!load_file("lena.dat", &data, &datasize)) { teardown(-1); } size_t width = 512; size_t height = 512; size_t buf_size = width*height*sizeof(cl_float); float *data_out = malloc(buf_size); if (!data_out) { fprintf(stderr,"\nError: malloc failed\n"); teardown(-1); } kernel = clCreateKernel(program, "gauss", &status); checkError(status, "could not create kernel"); cl_image_format format = { CL_R, CL_UNORM_INT8}; buffer_in = clCreateImage2D (context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, &format, width, height, 0, data, &status); checkError(status, "Error: could not create image"); buffer_out = clCreateBuffer(context, CL_MEM_READ_WRITE, buf_size, NULL, &status); checkError(status, "Error: could not create buffer_out"); // execute kernel int arg = 0; status = clSetKernelArg(kernel, arg++, sizeof(cl_mem), &buffer_in); status = clSetKernelArg(kernel, arg++, sizeof(cl_mem), &buffer_out); checkError(status, "Error: could not set args"); size_t work_size[] = {width, height}; size_t local_size[] = {1, 1}; status = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, work_size, local_size, 0, NULL, &event); checkError(status, "Error: could not enqueue kernel"); status = clWaitForEvents(1, &event); checkError(status, "Error: could not wait for event"); status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &start, NULL); checkError(status, "Error: could not get start profile information"); status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end, NULL); checkError(status, "Error: could not get end profile information"); status = clReleaseEvent(event); checkError(status, "Error: could not release event"); // read results back status = clEnqueueReadBuffer(queue, buffer_out, CL_FALSE, 0, buf_size, data_out, 0, NULL, NULL); checkError(status, "Error: could not copy data into device"); status = clFinish(queue); checkError(status, "Error: could not finish successfully"); double elapsed = (end - start) * 1e-9f; printf("time: %f\n", elapsed); write_bmp("gauss.bmp", data_out, width, height, NORMAL); free(data); free(data_out); teardown(0); }
std::ostream& operator<<(std::ostream& os, const BMP<DIB, I, D>& bmp) { write_bmp(bmp, os); return os; }
int main (int argc, char **argv) { // Reading command line arguments iterations = 100; imageSize = 512; if(argc == 3){ iterations = atoi(argv[1]); imageSize = atoi(argv[2]); } // MPI initialization, getting rank and size MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Creating cartesian communicator MPI_Dims_create(size, 2, dims); MPI_Cart_create( MPI_COMM_WORLD, 2, dims, periods, 0, &cart_comm ); MPI_Cart_coords( cart_comm, rank, 2, coords ); // Finding neighbours processes MPI_Cart_shift(cart_comm, 0, 1, &north, &south); MPI_Cart_shift(cart_comm, 1, 1, &west, &east); // Determining size of local subdomain local_height = imageSize/dims[0]; local_width = imageSize/dims[1]; // Creating and commiting MPI datatypes for message passing create_types(); // Allocating memory for local arrays local_pres = (float*)malloc(sizeof(float)*(local_width + 2*border)*(local_height+2*border)); local_pres0 = (float*)malloc(sizeof(float)*(local_width + 2*border)*(local_height+2*border)); local_diverg = (float*)malloc(sizeof(float)*local_width*local_height); // Initializing the CFD computation, only one process should do this. if(rank == 0){ initFluid( &config, imageSize, imageSize); pres = config.pres; diverg = config.div; imageBuffer = (unsigned char*)malloc(sizeof(unsigned char)*imageSize*imageSize); } // Solving the CFD equations, one iteration for each timestep. // These are not the same iterations used in the Jacobi solver. // The solveFluid function call the Jacobi solver, wich runs for // 100 iterations for each of these iterations. for(int i = 0; i < iterations; i++){ solveFluid(&config); } // Converting the density to an image and writing it to file. if(rank == 0){ densityToColor(imageBuffer, config.dens, config.N); write_bmp(imageBuffer, imageSize, imageSize); // Free fluid simulation memory freeFluid( &config ); } // Finalize MPI_Finalize(); }
int main(int argc, char** argv){ if(argc != 3){ printf("Useage: %s image n_threads\n", argv[0]); exit(-1); } int n_threads = atoi(argv[2]); pthread_t threads[n_threads]; unsigned char* image = read_bmp(argv[1]); unsigned char* output_image = malloc(sizeof(unsigned char) * image_size); int* histogram = (int*)calloc(sizeof(int), color_depth); int** histograms = (int**)malloc(sizeof(int*)*n_threads); // This for loop have very few iterations so I will not parallelize it (the overhead is greater than the gain) for(int i=0;i<n_threads;i++) { histograms[i] = (int*)calloc(sizeof(int), color_depth); } //For each pixel, increment the correct cell in the local histogram for(int thread = 0; thread<n_threads; thread++) { histogram_count_args* a = malloc(sizeof(histogram_count_args)); a->n_threads = n_threads; a->thread_n = thread; a->histograms = histograms; a->image = image; pthread_create(&threads[thread], NULL, threaded_histogram_count, (void *)a); } for(int i = 0; i < n_threads; i++) pthread_join(threads[i], NULL); // Wait for all threads to finish // For each cell in the local histogram, add it to the global histogram // For the color depths used in these example images, paralellizing this is not that usefull, // For images with larger color depth however, it's quite usefull. for(int thread = 0; thread<n_threads; thread++) { histogram_sum_args* a = malloc(sizeof(histogram_sum_args)); a->n_threads = n_threads; a->thread_n = thread; a->histogram = histogram; a->histograms = histograms; pthread_create(&threads[thread], NULL, threaded_histogram_sum, (void *)a); } for(int i = 0; i < n_threads; i++) pthread_join(threads[i], NULL); // Wait for all threads to finish for(int i=0;i<color_depth;i++) { } float* transfer_function = (float*)calloc(sizeof(float), color_depth); for(int thread = 0; thread<n_threads; thread++) { transfer_args* a = malloc(sizeof(transfer_args)); a->n_threads = n_threads; a->thread_n = thread; a->transfer_function = transfer_function; a->histogram = histogram; pthread_create(&threads[thread], NULL, threaded_transfer, (void *)a); } for(int i = 0; i < n_threads; i++) pthread_join(threads[i], NULL); // Wait for all threads to finish for(int i = 0; i < image_size; i++){ output_image[i] = transfer_function[image[i]]; } write_bmp(output_image, image_width, image_height); // A little code snippet to compare the result to a correct.bmp image. // This is here just for testing. unsigned char* fasit = read_bmp("correct.bmp"); int no_errors = 1; for(int i=0;i<image_size;i++) { if(!(output_image[i] == fasit[i] || output_image[i]+1 == fasit[i] || output_image[i]-1 == fasit[i])) { no_errors = 0; } } printf("Correct: %d\n", no_errors); }