/* * Save the rendered image to disk. */ static void renderio(scenedef * scene) { flt iotime; char msgtxt[256]; rt_timerhandle ioth; /* I/O timer handle */ ioth=rt_timer_create(); rt_timer_start(ioth); if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB96F) { if (scene->imgprocess & RT_IMAGE_NORMALIZE) { normalize_rgb96f(scene->hres, scene->vres, (float *) scene->img); rt_ui_message(MSG_0, "Post-processing: normalizing pixel values."); } if (scene->imgprocess & RT_IMAGE_GAMMA) { gamma_rgb96f(scene->hres, scene->vres, (float *) scene->img, scene->imggamma); rt_ui_message(MSG_0, "Post-processing: gamma correcting pixel values."); } } else if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB24) { if (scene->imgprocess & (RT_IMAGE_NORMALIZE | RT_IMAGE_GAMMA)) rt_ui_message(MSG_0, "Can't post-process 24-bit integer image data"); } /* support cropping of output images for SPECMPI benchmarks */ if (scene->imgcrop.cropmode == RT_CROP_DISABLED) { writeimage(scene->outfilename, scene->hres, scene->vres, scene->img, scene->imgbufformat, scene->imgfileformat); } else { /* crop image before writing if necessary */ if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB96F) { float *imgcrop; imgcrop = image_crop_rgb96f(scene->hres, scene->vres, scene->img, scene->imgcrop.xres, scene->imgcrop.yres, scene->imgcrop.xstart, scene->imgcrop.ystart); writeimage(scene->outfilename, scene->imgcrop.xres, scene->imgcrop.yres, imgcrop, scene->imgbufformat, scene->imgfileformat); free(imgcrop); } else if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB24) { unsigned char *imgcrop; imgcrop = image_crop_rgb24(scene->hres, scene->vres, scene->img, scene->imgcrop.xres, scene->imgcrop.yres, scene->imgcrop.xstart, scene->imgcrop.ystart); writeimage(scene->outfilename, scene->imgcrop.xres, scene->imgcrop.yres, imgcrop, scene->imgbufformat, scene->imgfileformat); free(imgcrop); } } rt_timer_stop(ioth); iotime = rt_timer_time(ioth); rt_timer_destroy(ioth); sprintf(msgtxt, " Image I/O Time: %10.4f seconds", iotime); rt_ui_message(MSG_0, msgtxt); }
int main(int argc, char *argv[]) { // parse command line arguments int c; while (EOF != (c = getopt(argc, argv, "d"))) switch (c) { case 'd': debuglevel = LOG_DEBUG; break; } // create a camera instance SimCamera camera; CcdPtr ccd = camera.getCcd(0); GuiderPortPtr guiderport = camera.getGuiderPort(); // we will always use 1 sec exposures Exposure exposure(ImageRectangle(ImagePoint(160,120), ImageSize(320, 240)), 1); // make 10 images 1 second appart (should give small drift) counter = 0; while (counter < 10) { ccd->startExposure(exposure); ImagePtr image = ccd->getImage(); writeimage(image); } // now move for 5 seconds guiderport->activate(5, 0, 0, 0); sleep(5); ccd->startExposure(exposure); writeimage(ccd->getImage()); guiderport->activate(0, 5, 0, 0); sleep(5); ccd->startExposure(exposure); writeimage(ccd->getImage()); guiderport->activate(0, 0, 5, 0); sleep(5); ccd->startExposure(exposure); writeimage(ccd->getImage()); guiderport->activate(0, 0, 0, 5); sleep(5); ccd->startExposure(exposure); writeimage(ccd->getImage()); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { char *src_path,*dst_path; int row=0,col=0,max_value=255; char* loc;//int i,j; // <a.out> <src_file> <destination_file> if (argc != 3) { printf("Usage <a.out> <src_file> <destination_file> \n"); return -1; } src_path=argv[1]; dst_path=argv[2]; unsigned int **new_image = readimage(src_path,&row,&col,&max_value,&loc); new_image=contrast_stretch(new_image,&row,&col,max_value); writeimage(new_image,row,col,dst_path,max_value); return 0; }
int p3b(void) { // initialize data of input const char *inputname = "boat.raw"; int SizeW = 512; int SizeH = 512; int BytesPerPixel = 1; unsigned char inputdata[SizeH][SizeW][BytesPerPixel]; // initialize data of output const char *outputname = "3b boat_ED_ans.raw"; int newSizeW = SizeW; int newSizeH = SizeH; int newBytesPerPixel = BytesPerPixel; unsigned char outputdata[newSizeH][newSizeW][newBytesPerPixel]; // read input readimage(inputname, &inputdata[0][0][0], SizeH, SizeW, BytesPerPixel); // Error Diffusion int color = 255; FSErrorDiff(color, SizeH, SizeW, &inputdata[0][0][0], &outputdata[0][0][0]); writeimage(outputname, &outputdata[0][0][0], newSizeH, newSizeW, newBytesPerPixel); return 0; }
char* writebitmap(void) { char basename[64]; char name[64+30]; static char result[200]; char *p, *q; int fd; if(im == nil) return "no image"; memset(basename, 0, sizeof basename); if(doc->docname) strncpy(basename, doc->docname, sizeof(basename)-1); else if((p = menugen(page)) && p[0] != '\0') strncpy(basename, p+1, sizeof(basename)-1); if(basename[0]) { if((q = strrchr(basename, '/')) != nil) q++; else q = basename; if((p = strchr(q, '.')) != nil) *p = 0; memset(name, 0, sizeof name); snprint(name, sizeof(name)-1, "%s.%d.bit", q, page+1); if(access(name, 0) >= 0) { strcat(name, "XXXX"); mktemp(name); } if(access(name, 0) >= 0) return "couldn't think of a name for bitmap"; } else { strcpy(name, "bitXXXX"); mktemp(name); if(access(name, 0) >= 0) return "couldn't think of a name for bitmap"; } if((fd = create(name, OWRITE, 0666)) < 0) { snprint(result, sizeof result, "cannot create %s: %r", name); return result; } if(writeimage(fd, im, 0) < 0) { snprint(result, sizeof result, "cannot writeimage: %r"); close(fd); return result; } close(fd); snprint(result, sizeof result, "wrote %s", name); return result; }
int p3a(void) { // initialize data of input const char *inputname = "boat.raw"; int SizeW = 512; int SizeH = 512; int BytesPerPixel = 1; unsigned char inputdata[SizeH][SizeW][BytesPerPixel]; // initialize data of output const char *outputname1 = "3a boat_FT_ans.raw"; const char *outputname2 = "3a boat_RT_ans.raw"; const char *outputname3a = "3a boat_DM2_ans.raw"; const char *outputname3b = "3a boat_DM4_ans.raw"; int newSizeW = SizeW; int newSizeH = SizeH; int newBytesPerPixel = BytesPerPixel; unsigned char outputdata1[newSizeH][newSizeW][newBytesPerPixel]; unsigned char outputdata2[newSizeH][newSizeW][newBytesPerPixel]; unsigned char outputdata3a[newSizeH][newSizeW][newBytesPerPixel]; unsigned char outputdata3b[newSizeH][newSizeW][newBytesPerPixel]; // read input readimage(inputname, &inputdata[0][0][0], SizeH, SizeW, BytesPerPixel); //*** Fixed thresholding *** float FixedT = 128.0; Fixedthre(FixedT, SizeH, SizeW, &inputdata[0][0][0], &outputdata1[0][0][0]); writeimage(outputname1, &outputdata1[0][0][0], newSizeH, newSizeW, newBytesPerPixel); //*** Random thresholding *** RandomThre(SizeH, SizeW, &inputdata[0][0][0], &outputdata2[0][0][0]); writeimage(outputname2, &outputdata2[0][0][0], newSizeH, newSizeW, newBytesPerPixel); //*** Dithering Matrix Dithering(2, SizeH, SizeW, &inputdata[0][0][0], &outputdata3a[0][0][0]); Dithering(4, SizeH, SizeW, &inputdata[0][0][0], &outputdata3b[0][0][0]); writeimage(outputname3a, &outputdata3a[0][0][0], newSizeH, newSizeW, newBytesPerPixel); writeimage(outputname3b, &outputdata3b[0][0][0], newSizeH, newSizeW, newBytesPerPixel); return 0; }
MvthReplyCode writeframe_cmd(Command *cmd) { char *iname; Arg *a; char filename[2048]; char *basename; image_t *img; if (cmd->narg==2 && strncmp(cmd->arglist->next->str,"-h",2)==0) { usage(); return S_HANDLED; } if (cmd->narg!=3) { return S_USAGE; } a=cmd->arglist->next; /* get the image number */ iname=a->str; if (strcmp(iname,"-1")==0) { framenum=0; return S_SUCCESS; } /* get the basename of the image */ a=a->next; basename=a->str; if (basename==NULL) { mvthprint(stderr,"writeframe_cmd(): Error setting basename.\n"); return S_ARGS; } if ((img=get_image_var(iname))==NULL) { return S_NOEXIST; } /* constructing file name */ snprintf(filename,sizeof(filename),"%s%04d.ppm",basename,framenum); writeimage(img->data, img->w,img->h,img->bands,filename); framenum++; mvthprint(stdout,"Wrote image \"%s\" to file `%s',\n",iname, filename); return S_SUCCESS; }
void test_fill() { int w = 1024, h = 1024; color_dt * img = malloc(sizeof(color_dt) * w * h); int i,j; for (i = 0; i < w; i++) { for (j = 0; j < h; j++) { img[i*h+j].r = (double)i / (double)w; //0.3; img[i*h+j].g = 0; img[i*h+j].b = 0; } } writeimage("test.pnm", img, 16, w, h); }
void domask(Icon *icon) { int rv; char file[64]; int fd; rv = -1; snprint(file, sizeof(file), "%dx%d.mask", icon->w, icon->h); fd = create(file, OWRITE, 0664); if(fd >= 0){ rv = writeimage(fd, icon->mask, 0); close(fd); } if(rv < 0) mesg("error writing %s: %r", file); else mesg("created %s", file); }
int p1a(void) { // initialize data of input const char *filename1 = "Tiffany.raw"; int SizeW1 = 512; int SizeH1 = 512; int BytesPerPixel1 = 3; unsigned char ImageData1[SizeH1][SizeW1][BytesPerPixel1]; const char *filename2 = "Components.raw"; int SizeW2 = 350; int SizeH2 = 350; int BytesPerPixel2 = 3; unsigned char ImageData2[SizeH2][SizeW2][BytesPerPixel2]; // read input readimage(filename1, &ImageData1[0][0][0], SizeH1, SizeW1, BytesPerPixel1); readimage(filename2, &ImageData2[0][0][0], SizeH2, SizeW2, BytesPerPixel2); // find the center coordinates and the dimension of holes FindHoleInfo(&ImageData1[0][0][0], SizeH1, SizeW1); // find the center coordinates, the orientation angle and the dimension of the components FindPiecesInfo(&ImageData2[0][0][0], SizeH2, SizeW2); float mholeH = (60+4), mholeW = (110+4); float mholeI = 338, mholeJ = 320; float mouthH = 65.069191, mouthW = 127.279221; float mouthI = 107.620117, mouthJ = 106.122902; float mangle = 0 - 0.785398; float eholeH = (35+4), eholeW = (80+4); float eholeI = 211.5, eholeJ = 258; float eyeH = 52, eyeW = 112.946892; float eyeI = 251.533356, eyeJ = 226.533356; float eangle = 0.352553 - 3.14159; // rotation unsigned char rmImage[SizeH2][SizeW2][BytesPerPixel2]; memset(rmImage, 255, SizeH2*SizeW2*3*(sizeof(unsigned char))); rotation(&ImageData2[0][0][0], &rmImage[0][0][0], SizeH2, SizeW2, mouthH, mouthW, mouthI, mouthJ, mangle); writeimage("1a rotatedmouth.raw", &rmImage[0][0][0], SizeH2, SizeW2, 3); unsigned char reImage[SizeH2][SizeW2][BytesPerPixel2]; memset(reImage, 255, SizeH2*SizeW2*3*(sizeof(unsigned char))); rotation(&ImageData2[0][0][0], &reImage[0][0][0], SizeH2, SizeW2, eyeH, eyeW, eyeI, eyeJ, eangle); writeimage("1a rotatedeye.raw", &reImage[0][0][0], SizeH2, SizeW2, 3); // scaling unsigned char smImage[SizeH2][SizeW2][BytesPerPixel2]; memset(smImage, 255, SizeH2*SizeW2*3*(sizeof(unsigned char))); scaling(&rmImage[0][0][0], &smImage[0][0][0], SizeH2, SizeW2, mouthH, mouthW, mholeH, mholeW, mouthI, mouthJ); writeimage("1a scaledmouth.raw", &smImage[0][0][0], SizeH2, SizeW2, 3); unsigned char seImage[SizeH2][SizeW2][BytesPerPixel2]; memset(seImage, 255, SizeH2*SizeW2*3*(sizeof(unsigned char))); scaling(&reImage[0][0][0], &seImage[0][0][0], SizeH2, SizeW2, eyeH, eyeW, eholeH, eholeW, eyeI, eyeJ); writeimage("1a scaledeye.raw", &seImage[0][0][0], SizeH2, SizeW2, 3); // shift unsigned char shiftm[SizeH1][SizeW1][BytesPerPixel1]; memset(shiftm, 255, SizeH1*SizeW1*3*(sizeof(unsigned char))); shift(&smImage[0][0][0], &shiftm[0][0][0], SizeW2, SizeW1, mholeH, mholeW, mouthI, mouthJ, mholeI, mholeJ); writeimage("1a shiftedmouth.raw", &shiftm[0][0][0], SizeH1, SizeW1, 3); unsigned char shifte[SizeH1][SizeW1][BytesPerPixel1]; memset(shifte, 255, SizeH1*SizeW1*3*(sizeof(unsigned char))); shift(&seImage[0][0][0], &shifte[0][0][0], SizeW2, SizeW1, eholeH, eholeW, eyeI, eyeJ, eholeI, eholeJ); writeimage("1a shiftedeye.raw", &shifte[0][0][0], SizeH1, SizeW1, 3); // combine mouth & eye unsigned char MandE[SizeH1][SizeW1][BytesPerPixel1]; memset(MandE, 255, SizeH1*SizeW1*3*(sizeof(unsigned char))); combination(&shifte[0][0][0], &shiftm[0][0][0], &MandE[0][0][0], SizeH1, SizeW1); writeimage("1a mouth and eye.raw", &MandE[0][0][0], SizeH1, SizeW1, 3); // final combination unsigned char fullT[SizeH1][SizeW1][BytesPerPixel1]; memset(fullT, 255, SizeH1*SizeW1*3*(sizeof(unsigned char))); combination(&MandE[0][0][0], &ImageData1[0][0][0], &fullT[0][0][0], SizeH1, SizeW1); writeimage("1a fullTiffany.raw", &fullT[0][0][0], SizeH1, SizeW1, 3); return 0; }
int p1c(void) { // initialize data of input const char *filename = "fruits.raw"; int SizeW = 512; int SizeH = 512; int BytesPerPixel = 3; unsigned char ImageData[SizeH][SizeW][BytesPerPixel]; // read input readimage(filename, &ImageData[0][0][0], SizeH, SizeW, BytesPerPixel); unsigned char output[SizeH][SizeW][BytesPerPixel]; memset(output, 0, SizeH*SizeW*3*(sizeof(unsigned char))); float oldx, oldy, midi, midj; float diffi, diffj; int midi0, midj0, midi1, midj1, midi2, midj2, midi3, midj3; int R0, G0, B0, R1, G1, B1, R2, G2, B2, R3, G3, B3; for(int i=0; i<256; i++) { for(int j=256; (j <= 511-i) && (j <= 255 + i/0.4142); j++) { float x = j - 255; float y = 256 -i; oldx = 1.4142*x; oldy = 0.4142*x + y; midj = oldx + 255; midi = 256 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int j=256; j<512; j++) { for(int i=255; (i >= 2.4142*j - 977.6593) && (i >= 511-j); i--) { float x = j - 255; float y = 256 -i; // printf("i = %d , j = %d, x = %f, y = %f\n", i, j, x, y); oldx = x + 0.4142*y; oldy = 1.4142*y; midj = oldx + 255; midi = 256 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int j=256; j<512; j++) { for(int i=255; (i <= j) && (i <= 1488.6593 - 2.4142*j); i++) { float x = j - 255; float y = 255 -i; oldx = x - 0.4142*y; oldy = 1.4142*y; midj = oldx + 255; midi = 255 - oldy; // printf("i = %d , j = %d, x = %f, y = %f, midi = %f, midj = %f\n", i, j, x, y, midi, midj); diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int i=256; i<512; i++) { for(int j=256; (j <= i) && (j <= 255 + (511-i)/0.4142); j++) { float x = j - 255; float y = 255 -i; oldx = 1.4142*x; oldy = y - 0.4142*x; midj = oldx + 255; midi = 255 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int i=256; i<512; i++) { for(int j=255; (j >= 511-i) && (j >= 256 - (511-i)/0.4142); j--) { float x = j - 256; float y = 255 -i; oldx = 1.4142*x; oldy = 0.4142*x + y; midj = oldx + 256; midi = 255 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int j=0; j<256; j++) { for(int i=256; (i <= 511-j) && (i <= 2.4142*j+255.0031); i++) { float x = j - 256; float y = 255 -i; // printf("i = %d , j = %d, x = %f, y = %f\n", i, j, x, y); oldx = x + 0.4142*y; oldy = 1.4142*y; midj = oldx + 256; midi = 255 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int j=0; j<256; j++) { for(int i=255; (i >= j) && (i >= 255.9969 - 2.4142*j); i--) { float x = j - 256; float y = 256 -i; oldx = x - 0.4142*y; oldy = 1.4142*y; midj = oldx + 256; midi = 256 - oldy; // printf("i = %d , j = %d, x = %f, y = %f, midi = %f, midj = %f\n", i, j, x, y, midi, midj); diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } for(int i=0; i<256; i++) { for(int j=255; (j >= i) && (j >= 256 - i/0.4142); j--) { float x = j - 256; float y = 256 -i; oldx = 1.4142*x; oldy = y - 0.4142*x; midj = oldx + 256; midi = 256 - oldy; diffi = midi - ((int)midi); diffj = midj - ((int)midj); midi0 = midi; midj0 = midj; midi1 = midi0 + 1; midj1 = midj0; midi2 = midi0; midj2 = midj0 + 1; midi3 = midi0 + 1; midj3 = midj0 + 1; R0 = ImageData[midi0][midj0][0]; G0 = ImageData[midi0][midj0][1]; B0 = ImageData[midi0][midj0][2]; R1 = ImageData[midi1][midj1][0]; G1 = ImageData[midi1][midj1][1]; B1 = ImageData[midi1][midj1][2]; R2 = ImageData[midi2][midj2][0]; G2 = ImageData[midi2][midj2][1]; B2 = ImageData[midi2][midj2][2]; R3 = ImageData[midi3][midj3][0]; G3 = ImageData[midi3][midj3][1]; B3 = ImageData[midi3][midj3][2]; output[i][j][0] = (int)((1.0-diffj)*(1-diffi)*R0 + diffj*(1-diffi)*R1 + diffi*(1-diffj)*R2 + diffj*diffi*R3); output[i][j][1] = (int)((1.0-diffj)*(1-diffi)*G0 + diffj*(1-diffi)*G1 + diffi*(1-diffj)*G2 + diffj*diffi*G3); output[i][j][2] = (int)((1.0-diffj)*(1-diffi)*B0 + diffj*(1-diffi)*B1 + diffi*(1-diffj)*B2 + diffj*diffi*B3); } } writeimage("1c warped fruits.raw", &output[0][0][0], SizeH, SizeW, 3); return 0; }
int p1b(void) { // initialize data of input const char *filename = "Scarlett.raw"; int SizeW = 400; int SizeH = 300; int BytesPerPixel = 3; unsigned char ImageData[SizeH][SizeW][BytesPerPixel]; unsigned char R[SizeH][SizeW]; unsigned char G[SizeH][SizeW]; unsigned char B[SizeH][SizeW]; double dImageData[SizeH][SizeW][BytesPerPixel]; // initialize data of output const char *BGfilename = "1b Scarlett_lab_bf.raw"; const char *BGfilename1 = "1b Scarlett_rgb_bf.raw"; const char *Exfilename = "1b Scarlett_ex.raw"; const char *newfilename = "1b Scarlett_ans.raw"; int newSizeW = SizeW; int newSizeH = SizeH; int newBytesPerPixel = BytesPerPixel; double MBGImageData[newSizeH][newSizeW][newBytesPerPixel]; double MCImageData[newSizeH][newSizeW][newBytesPerPixel]; unsigned char BGImageData[newSizeH][newSizeW][newBytesPerPixel]; unsigned char BGImageData1[newSizeH][newSizeW][newBytesPerPixel]; unsigned char CBGImageData[newSizeH][newSizeW][newBytesPerPixel]; unsigned char newImageData[newSizeH][newSizeW][newBytesPerPixel]; // input readimage(filename, &ImageData[0][0][0], SizeH, SizeW, BytesPerPixel); double L[SizeH][SizeW]; double a[SizeH][SizeW]; double b[SizeH][SizeW]; for(int i = 0; i<SizeH; i++) { for(int j = 0; j < SizeW; j++) { R[i][j] = ImageData[i][j][0]; G[i][j] = ImageData[i][j][1]; B[i][j] = ImageData[i][j][2]; dImageData[i][j][0] = ((double) ImageData[i][j][0]/255.0); dImageData[i][j][1] = ((double) ImageData[i][j][1]/255.0); dImageData[i][j][2] = ((double) ImageData[i][j][2]/255.0); Rgb2Lab(&L[i][j], &a[i][j], &b[i][j], dImageData[i][j][0], dImageData[i][j][1], dImageData[i][j][2]); // printf("%d, %f = %u, %f = %u, %f = %u\n", i,dImageData[i][j][0], ImageData[i][j][0], dImageData[i][j][1],ImageData[i][j][1], dImageData[i][j][2], ImageData[i][j][2]); // printf("%d, %f, %f, %f\n", i,L[i][j], a[i][j],b[i][j]); } } // Bilateral Filter double newL[SizeH][SizeW]; double newa[SizeH][SizeW]; double newb[SizeH][SizeW]; double newnewL[SizeH][SizeW]; double newnewa[SizeH][SizeW]; double newnewb[SizeH][SizeW]; unsigned char newR[SizeH][SizeW]; unsigned char newG[SizeH][SizeW]; unsigned char newB[SizeH][SizeW]; unsigned char newnewR[SizeH][SizeW]; unsigned char newnewG[SizeH][SizeW]; unsigned char newnewB[SizeH][SizeW]; int FilterSize = 5; int sigmaC = 3; int sigmaC1 = 10; double sigmaS = 4.25; double sigmaS1 = 10.0; BilateralFilter(FilterSize, sigmaC1, sigmaS1, &R[0][0], SizeH, SizeW, &newR[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &G[0][0], SizeH, SizeW, &newG[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &B[0][0], SizeH, SizeW, &newB[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &L[0][0], SizeH, SizeW, &newL[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &a[0][0], SizeH, SizeW, &newa[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &b[0][0], SizeH, SizeW, &newb[0][0]); for(int i = 0; i<SizeH; i++) { for(int j = 0; j < SizeW; j++) { Lab2Rgb(&MCImageData[i][j][0], &MCImageData[i][j][1], &MCImageData[i][j][2], newL[i][j], newa[i][j], newb[i][j]); CBGImageData[i][j][0] = (int) (MCImageData[i][j][0]*255); CBGImageData[i][j][1] = (int) (MCImageData[i][j][1]*255); CBGImageData[i][j][2] = (int) (MCImageData[i][j][2]*255); } } BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newR[0][0], SizeH, SizeW, &newnewR[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newG[0][0], SizeH, SizeW, &newnewG[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newB[0][0], SizeH, SizeW, &newnewB[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newL[0][0], SizeH, SizeW, &newnewL[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newa[0][0], SizeH, SizeW, &newnewa[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newb[0][0], SizeH, SizeW, &newnewb[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newnewR[0][0], SizeH, SizeW, &newR[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newnewG[0][0], SizeH, SizeW, &newG[0][0]); BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newnewB[0][0], SizeH, SizeW, &newB[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newnewL[0][0], SizeH, SizeW, &newL[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newnewa[0][0], SizeH, SizeW, &newa[0][0]); BFiforLab(FilterSize, sigmaC, sigmaS, &newnewb[0][0], SizeH, SizeW, &newb[0][0]); // BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newR[0][0], SizeH, SizeW, &newnewR[0][0]); // BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newG[0][0], SizeH, SizeW, &newnewG[0][0]); // BilateralFilter(FilterSize, sigmaC1, sigmaS1, &newB[0][0], SizeH, SizeW, &newnewB[0][0]); for(int i = 0; i<SizeH; i++) { for(int j = 0; j < SizeW; j++) { Lab2Rgb(&MBGImageData[i][j][0], &MBGImageData[i][j][1], &MBGImageData[i][j][2], newL[i][j], newa[i][j], newb[i][j]); BGImageData[i][j][0] = (int) (MBGImageData[i][j][0]*255); BGImageData[i][j][1] = (int) (MBGImageData[i][j][1]*255); BGImageData[i][j][2] = (int) (MBGImageData[i][j][2]*255); BGImageData1[i][j][0] = newR[i][j]; BGImageData1[i][j][1] = newG[i][j]; BGImageData1[i][j][2] = newB[i][j]; // printf("%d, %f, %f, %f\n", i,newL[i][j], newa[i][j],newb[i][j]); // printf("%d, %u = %f, %u = %f, %u = %f\n", i,newImageData[i][j][0], MImageData[i][j][0],newImageData[i][j][1], MImageData[i][j][1], newImageData[i][j][2], MImageData[i][j][2]); } } writeimage(BGfilename, &BGImageData[0][0][0], newSizeH, newSizeW, newBytesPerPixel); writeimage(BGfilename1, &BGImageData1[0][0][0], newSizeH, newSizeW, newBytesPerPixel); // XDoG // convert to gray-scale image unsigned char GrayImageData[newSizeH][newSizeW]; for(int i = 0; i<SizeH; i++) { for(int j = 0; j < SizeW; j++) { float Y = 0.21*CBGImageData[i][j][0] + 0.72*CBGImageData[i][j][1] +0.07*CBGImageData[i][j][2]; GrayImageData[i][j] = (int) Y; // printf("%d %u = %f\n", i, GrayImageData[i][j], Y); } } unsigned char GrayImageData0[newSizeH][newSizeW]; for(int i = 0; i<SizeH; i++) { for(int j = 0; j < SizeW; j++) { float Y = 0.21*ImageData[i][j][0] + 0.72*ImageData[i][j][1] +0.07*ImageData[i][j][2]; GrayImageData0[i][j] = (int) Y; } } //compute Ex int windowsize = 11; float sigma = 1.5; float k = sqrt(1.6); float t = 0.98, e = 0.5, f = 4; unsigned char ExImageData[newSizeH][newSizeW]; XDoG(windowsize, sigma, k, t, e, f, &GrayImageData[0][0], &ExImageData[0][0], SizeH, SizeW); writeimage(Exfilename, &ExImageData[0][0], newSizeH, newSizeW, 1); // Integration of Portrait Background and Contour for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { newImageData[i][j][0] = (ExImageData[i][j]/255) * BGImageData[i][j][0]; newImageData[i][j][1] = (ExImageData[i][j]/255) * BGImageData[i][j][1]; newImageData[i][j][2] = (ExImageData[i][j]/255) * BGImageData[i][j][2]; } } writeimage(newfilename, &newImageData[0][0][0], newSizeH, newSizeW, newBytesPerPixel); // DoG unsigned char DoGExImageData[newSizeH][newSizeW]; unsigned char DoGImageData[newSizeH][newSizeW][newBytesPerPixel]; DoG(windowsize, sigma, k, e, f, &GrayImageData[0][0], &DoGExImageData[0][0], SizeH, SizeW); writeimage("1b Scarlett_DoG_ex.raw", &DoGExImageData[0][0], newSizeH, newSizeW, 1); for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { DoGImageData[i][j][0] = (DoGExImageData[i][j]/255) * BGImageData[i][j][0]; DoGImageData[i][j][1] = (DoGExImageData[i][j]/255) * BGImageData[i][j][1]; DoGImageData[i][j][2] = (DoGExImageData[i][j]/255) * BGImageData[i][j][2]; } } writeimage("1b Scarlett_DoG_ans.raw", &DoGImageData[0][0][0], newSizeH, newSizeW, newBytesPerPixel); return 0; }
// ****************** Problem 1: Edge Detection *********************** int p1a(void) { // initialize data of input const char *filename1 = "elaine.raw"; const char *filename2 = "noisy_elaine.raw"; int SizeW = 256; int SizeH = 256; int BytesPerPixel = 1; unsigned char ImageData1[SizeH][SizeW][BytesPerPixel]; unsigned char ImageData2[SizeH][SizeW][BytesPerPixel]; // initialize data of output const char *newfilename1a = "1a elaine_soble_ans.raw"; const char *newfilename1b = "1a elaine_LoG_ans.raw"; const char *newfilename2a = "1a noisyelaine_soble_ans.raw"; const char *newfilename2b = "1a noisyelaine_LoG_ans.raw"; int newSizeW = SizeW; int newSizeH = SizeH; int newBytesPerPixel = BytesPerPixel; unsigned char newImageData1a[newSizeH][newSizeW][newBytesPerPixel]; unsigned char newImageData1b[newSizeH][newSizeW][newBytesPerPixel]; unsigned char newImageData2a[newSizeH][newSizeW][newBytesPerPixel]; unsigned char newImageData2b[newSizeH][newSizeW][newBytesPerPixel]; // read input readimage(filename1, &ImageData1[0][0][0], SizeH, SizeW, BytesPerPixel); readimage(filename2, &ImageData2[0][0][0], SizeH, SizeW, BytesPerPixel); // --------------------Sobel Detector------------------------ int extend = 2; int thr1a = 24; int thr2a = 37; unsigned char Gradient1aR[SizeH][SizeW]; unsigned char Gradient1aC[SizeH][SizeW]; unsigned char Gradient1a[SizeH][SizeW]; const char *gradient1aR = "1a elaine_s_R_grad.raw"; const char *gradient1aC = "1a elaine_s_C_grad.raw"; const char *gradient1a = "1a elaine_soble_grad.raw"; unsigned char Gradient2aR[SizeH][SizeW]; unsigned char Gradient2aC[SizeH][SizeW]; unsigned char Gradient2a[SizeH][SizeW]; const char *gradient2aR = "1a noisingelaine_s_R_grad.raw"; const char *gradient2aC = "1a noisingelaine_s_C_grad.raw"; const char *gradient2a = "1a noisingelaine_soble_grad.raw"; GetSobleGradient(thr1a, &ImageData1[0][0][0], SizeH, SizeW, extend, &Gradient1aR[0][0], &Gradient1aC[0][0], &Gradient1a[0][0], &newImageData1a[0][0][0]); GetSobleGradient(thr2a, &ImageData2[0][0][0], SizeH, SizeW, extend, &Gradient2aR[0][0], &Gradient2aC[0][0], &Gradient2a[0][0], &newImageData2a[0][0][0]); // output writeimage(gradient1aR, &Gradient1aR[0][0], SizeH, SizeW, BytesPerPixel); writeimage(gradient1aC, &Gradient1aC[0][0], SizeH, SizeW, BytesPerPixel); writeimage(gradient1a, &Gradient1a[0][0], SizeH, SizeW, BytesPerPixel); writeimage(newfilename1a, &newImageData1a[0][0][0], newSizeH, newSizeW, newBytesPerPixel); writeimage(gradient2aR, &Gradient2aR[0][0], SizeH, SizeW, BytesPerPixel); writeimage(gradient2aC, &Gradient2aC[0][0], SizeH, SizeW, BytesPerPixel); writeimage(gradient2a, &Gradient2a[0][0], SizeH, SizeW, BytesPerPixel); writeimage(newfilename2a, &newImageData2a[0][0][0], newSizeH, newSizeW, newBytesPerPixel); // ----------------------LoG Detector------------------------------ int Dfiltersize = 9; float sigma = 1.0; float thr1b = 0.9; float thr2b = 1.5; unsigned char Gradient1b[SizeH][SizeW]; unsigned char ternarymap1[SizeH][SizeW]; unsigned char Gradient2b[SizeH][SizeW]; unsigned char ternarymap2[SizeH][SizeW]; const char *gradient1b = "1a elaine_LoG_grad.raw"; const char *ternary1 = "1a elaine_LoG_ter.raw"; const char *gradient2b = "1a noisingelaine_LoG_grad.raw"; const char *ternary2 = "1a noisingelaine_LoG_ter.raw"; LoG(Dfiltersize, sigma, thr1b, &ImageData1[0][0][0], SizeH, SizeW, &Gradient1b[0][0], &ternarymap1[0][0], &newImageData1b[0][0][0]); LoG(Dfiltersize, sigma, thr2b, &ImageData2[0][0][0], SizeH, SizeW, &Gradient2b[0][0], &ternarymap2[0][0], &newImageData2b[0][0][0]); writeimage(gradient1b, &Gradient1b[0][0], SizeH, SizeW, BytesPerPixel); writeimage(ternary1, &ternarymap1[0][0], SizeH, SizeW, BytesPerPixel); writeimage(newfilename1b, &newImageData1b[0][0][0], newSizeH, newSizeW, newBytesPerPixel); writeimage(gradient2b, &Gradient2b[0][0], SizeH, SizeW, BytesPerPixel); writeimage(ternary2, &ternarymap2[0][0], SizeH, SizeW, BytesPerPixel); writeimage(newfilename2b, &newImageData2b[0][0][0], newSizeH, newSizeW, newBytesPerPixel); return 0; }
/* ==================================== */ int32_t ldynamique_ldynamique(struct xvimage *image, struct xvimage *order, int32_t connex) /* ==================================== */ /*! \fn int32_t ldynamique_ldynamique(struct xvimage *image, struct xvimage *order, int32_t connex) \param image (entrée/sortie) : une image \param order (entrée) : labels définissant un ordre sur les maxima (de 1 à nbmaxima) \param connex (entrée) : 4 ou 8 (2D), 6, 18 ou 26 (3D) \return code erreur : 0 si échec, 1 sinon \brief calcule la dynamique ordonnée des maxima */ #undef F_NAME #define F_NAME "ldynamique_ldynamique" { register int32_t i, j, k, x; /* index muet */ int32_t rs = rowsize(image); /* taille ligne */ int32_t cs = colsize(image); /* taille colonne */ int32_t ds = depth(image); /* nb plans */ int32_t ps = rs * cs; /* taille plan */ int32_t N = ps * ds; /* taille image */ uint8_t *F = UCHARDATA(image); /* l'image de depart */ int32_t *O = SLONGDATA(order); /* l'image de labels */ Fahs * FAHS; /* la file d'attente hierarchique */ int32_t *CM; /* etat d'un pixel */ ctree * CT; /* resultat : l'arbre des composantes */ int32_t *mu; /* pour représenter l'ordre */ int32_t *alpha; /* pour certains calculs intermédiaires */ int32_t *dyn; /* pour représenter la dynamique */ if ((rowsize(order) != rs) || (colsize(order) != cs) || (depth(order) != ds)) { fprintf(stderr, "%s: incompatible image sizes\n", F_NAME); exit(0); } FAHS = CreeFahsVide(N); if (FAHS == NULL) { fprintf(stderr, "%s() : CreeFahsVide failed\n", F_NAME); return 0; } if ((connex == 4) || (connex == 8)) { if (!ComponentTree(F, rs, N, connex, &CT, &CM)) { fprintf(stderr, "%s() : ComponentTree failed\n", F_NAME); return 0; } } else if ((connex == 6) || (connex == 18) || (connex == 26)) { if (!ComponentTree3d(F, rs, ps, N, connex, &CT, &CM)) { fprintf(stderr, "%s() : ComponentTree failed\n", F_NAME); return 0; } } else { fprintf(stderr, "%s() : bad value for connex : %d\n", F_NAME, connex); return 0; } #ifdef DEBUG ComponentTreePrint(CT); writeimage(order, "_o"); #endif mu = (int32_t *)calloc(CT->nbleafs+1, sizeof(int32_t)); // 0 non utilise dyn = (int32_t *)calloc(CT->nbleafs+1, sizeof(int32_t)); // 0 non utilise alpha = (int32_t *)calloc(CT->nbnodes, sizeof(int32_t)); if ((mu == NULL) || (dyn == NULL) || (alpha == NULL)) { fprintf(stderr, "%s : malloc failed\n", F_NAME); return 0; } for (x = 0; x < N; x++) { k = CM[x]; i = O[x]; // label donnant l'ordre if (CT->tabnodes[k].nbsons == 0) // feuille mu[i] = k; } // for (x = 0; x < N; x++) for (i = CT->nbleafs; i >= 1; i--) { j = k = mu[i]; #ifdef DEBUG printf("node %d : %d ", i, k); #endif while ((k != -1) && (alpha[k] == 0)) { alpha[k] = i; k = CT->tabnodes[k].father; } if (k == -1) dyn[i] = 255; else dyn[i] = CT->tabnodes[j].data - CT->tabnodes[k].data; #ifdef DEBUG printf(" ancestor %d, level %d\n", k, dyn[i]); #endif } // for (i = CT->nbleafs; i >= 1; i--) for (x = 0; x < N; x++) if (O[x]) F[x] = dyn[O[x]]; else F[x] = 0; /* ================================================ */ /* UN PEU DE MENAGE */ /* ================================================ */ FahsTermine(FAHS); ComponentTreeFree(CT); free(CM); free(mu); free(dyn); free(alpha); return(1); } /* ldynamique_ldynamique() */
/*---------------------------------------------------------------- * prism2_fwapply * * Apply the firmware loaded into memory * * Arguments: * rfptr firmware image in kernel memory * wlandev device * * Returns: * 0 - success * ~0 - failure *---------------------------------------------------------------- */ static int prism2_fwapply(const struct ihex_binrec *rfptr, struct wlandevice *wlandev) { signed int result = 0; struct p80211msg_dot11req_mibget getmsg; struct p80211itemd *item; u32 *data; /* Initialize the data structures */ ns3data = 0; s3data = kcalloc(S3DATA_MAX, sizeof(*s3data), GFP_KERNEL); if (!s3data) { result = -ENOMEM; goto out; } ns3plug = 0; memset(s3plug, 0, sizeof(s3plug)); ns3crc = 0; memset(s3crc, 0, sizeof(s3crc)); ns3info = 0; memset(s3info, 0, sizeof(s3info)); startaddr = 0; nfchunks = 0; memset(fchunk, 0, sizeof(fchunk)); memset(&nicid, 0, sizeof(nicid)); memset(&rfid, 0, sizeof(rfid)); memset(&macid, 0, sizeof(macid)); memset(&priid, 0, sizeof(priid)); /* clear the pda and add an initial END record */ memset(&pda, 0, sizeof(pda)); pda.rec[0] = (struct hfa384x_pdrec *)pda.buf; pda.rec[0]->len = cpu_to_le16(2); /* len in words */ pda.rec[0]->code = cpu_to_le16(HFA384x_PDR_END_OF_PDA); pda.nrec = 1; /*-----------------------------------------------------*/ /* Put card into fwload state */ prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload); /* Build the PDA we're going to use. */ if (read_cardpda(&pda, wlandev)) { netdev_err(wlandev->netdev, "load_cardpda failed, exiting.\n"); result = 1; goto out; } /* read the card's PRI-SUP */ memset(&getmsg, 0, sizeof(getmsg)); getmsg.msgcode = DIDmsg_dot11req_mibget; getmsg.msglen = sizeof(getmsg); strcpy(getmsg.devname, wlandev->name); getmsg.mibattribute.did = DIDmsg_dot11req_mibget_mibattribute; getmsg.mibattribute.status = P80211ENUM_msgitem_status_data_ok; getmsg.resultcode.did = DIDmsg_dot11req_mibget_resultcode; getmsg.resultcode.status = P80211ENUM_msgitem_status_no_value; item = (struct p80211itemd *)getmsg.mibattribute.data; item->did = DIDmib_p2_p2NIC_p2PRISupRange; item->status = P80211ENUM_msgitem_status_no_value; data = (u32 *)item->data; /* DIDmsg_dot11req_mibget */ prism2mgmt_mibset_mibget(wlandev, &getmsg); if (getmsg.resultcode.data != P80211ENUM_resultcode_success) netdev_err(wlandev->netdev, "Couldn't fetch PRI-SUP info\n"); /* Already in host order */ priid.role = *data++; priid.id = *data++; priid.variant = *data++; priid.bottom = *data++; priid.top = *data++; /* Read the S3 file */ result = read_fwfile(rfptr); if (result) { netdev_err(wlandev->netdev, "Failed to read the data exiting.\n"); goto out; } result = validate_identity(); if (result) { netdev_err(wlandev->netdev, "Incompatible firmware image.\n"); goto out; } if (startaddr == 0x00000000) { netdev_err(wlandev->netdev, "Can't RAM download a Flash image!\n"); result = 1; goto out; } /* Make the image chunks */ result = mkimage(fchunk, &nfchunks); if (result) { netdev_err(wlandev->netdev, "Failed to make image chunk.\n"); goto free_chunks; } /* Do any plugging */ result = plugimage(fchunk, nfchunks, s3plug, ns3plug, &pda); if (result) { netdev_err(wlandev->netdev, "Failed to plug data.\n"); goto free_chunks; } /* Insert any CRCs */ result = crcimage(fchunk, nfchunks, s3crc, ns3crc); if (result) { netdev_err(wlandev->netdev, "Failed to insert all CRCs\n"); goto free_chunks; } /* Write the image */ result = writeimage(wlandev, fchunk, nfchunks); if (result) { netdev_err(wlandev->netdev, "Failed to ramwrite image data.\n"); goto free_chunks; } netdev_info(wlandev->netdev, "prism2_usb: firmware loading finished.\n"); free_chunks: /* clear any allocated memory */ free_chunks(fchunk, &nfchunks); free_srecs(); out: return result; }
int prism2_fwapply(const struct ihex_binrec *rfptr, wlandevice_t *wlandev) { signed int result = 0; struct p80211msg_dot11req_mibget getmsg; p80211itemd_t *item; u32 *data; ns3data = 0; memset(s3data, 0, sizeof(s3data)); ns3plug = 0; memset(s3plug, 0, sizeof(s3plug)); ns3crc = 0; memset(s3crc, 0, sizeof(s3crc)); ns3info = 0; memset(s3info, 0, sizeof(s3info)); startaddr = 0; nfchunks = 0; memset(fchunk, 0, sizeof(fchunk)); memset(&nicid, 0, sizeof(nicid)); memset(&rfid, 0, sizeof(rfid)); memset(&macid, 0, sizeof(macid)); memset(&priid, 0, sizeof(priid)); memset(&pda, 0, sizeof(pda)); pda.rec[0] = (hfa384x_pdrec_t *) pda.buf; pda.rec[0]->len = cpu_to_le16(2); pda.rec[0]->code = cpu_to_le16(HFA384x_PDR_END_OF_PDA); pda.nrec = 1; prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload); if (read_cardpda(&pda, wlandev)) { printk(KERN_ERR "load_cardpda failed, exiting.\n"); return 1; } memset(&getmsg, 0, sizeof(getmsg)); getmsg.msgcode = DIDmsg_dot11req_mibget; getmsg.msglen = sizeof(getmsg); strcpy(getmsg.devname, wlandev->name); getmsg.mibattribute.did = DIDmsg_dot11req_mibget_mibattribute; getmsg.mibattribute.status = P80211ENUM_msgitem_status_data_ok; getmsg.resultcode.did = DIDmsg_dot11req_mibget_resultcode; getmsg.resultcode.status = P80211ENUM_msgitem_status_no_value; item = (p80211itemd_t *) getmsg.mibattribute.data; item->did = DIDmib_p2_p2NIC_p2PRISupRange; item->status = P80211ENUM_msgitem_status_no_value; data = (u32 *) item->data; prism2mgmt_mibset_mibget(wlandev, &getmsg); if (getmsg.resultcode.data != P80211ENUM_resultcode_success) printk(KERN_ERR "Couldn't fetch PRI-SUP info\n"); priid.role = *data++; priid.id = *data++; priid.variant = *data++; priid.bottom = *data++; priid.top = *data++; result = read_fwfile(rfptr); if (result) { printk(KERN_ERR "Failed to read the data exiting.\n"); return 1; } result = validate_identity(); if (result) { printk(KERN_ERR "Incompatible firmware image.\n"); return 1; } if (startaddr == 0x00000000) { printk(KERN_ERR "Can't RAM download a Flash image!\n"); return 1; } result = mkimage(fchunk, &nfchunks); result = plugimage(fchunk, nfchunks, s3plug, ns3plug, &pda); if (result) { printk(KERN_ERR "Failed to plug data.\n"); return 1; } if (crcimage(fchunk, nfchunks, s3crc, ns3crc)) { printk(KERN_ERR "Failed to insert all CRCs\n"); return 1; } result = writeimage(wlandev, fchunk, nfchunks); if (result) { printk(KERN_ERR "Failed to ramwrite image data.\n"); return 1; } free_chunks(fchunk, &nfchunks); free_srecs(); printk(KERN_INFO "prism2_usb: firmware loading finished.\n"); return result; }
/*---------------------------------------------------------------- * prism2_fwapply * * Apply the firmware loaded into memory * * Arguments: * rfptr firmware image in kernel memory * wlandev device * * Returns: * 0 - success * ~0 - failure ----------------------------------------------------------------*/ int prism2_fwapply(const struct ihex_binrec *rfptr, wlandevice_t *wlandev) { signed int result = 0; struct p80211msg_dot11req_mibget getmsg; p80211itemd_t *item; u32 *data; /* Initialize the data structures */ ns3data = 0; memset(s3data, 0, sizeof(s3data)); ns3plug = 0; memset(s3plug, 0, sizeof(s3plug)); ns3crc = 0; memset(s3crc, 0, sizeof(s3crc)); ns3info = 0; memset(s3info, 0, sizeof(s3info)); startaddr = 0; nfchunks = 0; memset(fchunk, 0, sizeof(fchunk)); memset(&nicid, 0, sizeof(nicid)); memset(&rfid, 0, sizeof(rfid)); memset(&macid, 0, sizeof(macid)); memset(&priid, 0, sizeof(priid)); /* clear the pda and add an initial END record */ memset(&pda, 0, sizeof(pda)); pda.rec[0] = (hfa384x_pdrec_t *) pda.buf; pda.rec[0]->len = cpu_to_le16(2); /* len in words */ pda.rec[0]->code = cpu_to_le16(HFA384x_PDR_END_OF_PDA); pda.nrec = 1; /*-----------------------------------------------------*/ /* Put card into fwload state */ prism2sta_ifstate(wlandev, P80211ENUM_ifstate_fwload); /* Build the PDA we're going to use. */ if (read_cardpda(&pda, wlandev)) { ; return 1; } /* read the card's PRI-SUP */ memset(&getmsg, 0, sizeof(getmsg)); getmsg.msgcode = DIDmsg_dot11req_mibget; getmsg.msglen = sizeof(getmsg); strcpy(getmsg.devname, wlandev->name); getmsg.mibattribute.did = DIDmsg_dot11req_mibget_mibattribute; getmsg.mibattribute.status = P80211ENUM_msgitem_status_data_ok; getmsg.resultcode.did = DIDmsg_dot11req_mibget_resultcode; getmsg.resultcode.status = P80211ENUM_msgitem_status_no_value; item = (p80211itemd_t *) getmsg.mibattribute.data; item->did = DIDmib_p2_p2NIC_p2PRISupRange; item->status = P80211ENUM_msgitem_status_no_value; data = (u32 *) item->data; /* DIDmsg_dot11req_mibget */ prism2mgmt_mibset_mibget(wlandev, &getmsg); if (getmsg.resultcode.data != P80211ENUM_resultcode_success) ; /* Already in host order */ priid.role = *data++; priid.id = *data++; priid.variant = *data++; priid.bottom = *data++; priid.top = *data++; /* Read the S3 file */ result = read_fwfile(rfptr); if (result) { ; return 1; } result = validate_identity(); if (result) { ; return 1; } if (startaddr == 0x00000000) { ; return 1; } /* Make the image chunks */ result = mkimage(fchunk, &nfchunks); /* Do any plugging */ result = plugimage(fchunk, nfchunks, s3plug, ns3plug, &pda); if (result) { ; return 1; } /* Insert any CRCs */ if (crcimage(fchunk, nfchunks, s3crc, ns3crc)) { ; return 1; } /* Write the image */ result = writeimage(wlandev, fchunk, nfchunks); if (result) { ; return 1; } /* clear any allocated memory */ free_chunks(fchunk, &nfchunks); free_srecs(); ; return result; }
/* ==================================== */ int32_t lsquelval(struct xvimage *image, // entree/sortie: image originale / squelette struct xvimage *dx, // entree/sortie: distance / distance topologique int32_t connex, int32_t val_inhibit) /* ==================================== */ #undef F_NAME #define F_NAME "lsquelval" { int32_t k; int32_t x; /* index muet de pixel */ int32_t y; /* index muet (generalement un voisin de x) */ int32_t rs = rowsize(image); /* taille ligne */ int32_t cs = colsize(image); /* taille colonne */ int32_t N = rs * cs; /* taille image */ struct xvimage *dt; /* pour le calcul de la "distance topologique" */ uint8_t *IM = UCHARDATA(image); /* l'image de depart */ uint32_t *DX; /* fonction distance au complementaire de IM */ uint32_t *DT; /* fonction "distance topologique" */ uint32_t d; Rbt * RBT; int32_t taillemaxrbt; IndicsInit(N); if ((rowsize(dx) != rs) || (colsize(dx) != cs) || (depth(dx) != 1)) { fprintf(stderr, "%s() : bad size for dx\n", F_NAME); return(0); } if (datatype(dx) != VFF_TYP_4_BYTE) { fprintf(stderr, "%s() : datatype(dx) must be uint32_t\n", F_NAME); return(0); } DX = ULONGDATA(dx); dt = copyimage(dx); DT = ULONGDATA(dt); taillemaxrbt = 2 * rs + 2 * cs ; /* cette taille est indicative, le RBT est realloue en cas de depassement */ RBT = mcrbt_CreeRbtVide(taillemaxrbt); if (RBT == NULL) { fprintf(stderr, "%s() : mcrbt_CreeRbtVide failed\n", F_NAME); return(0); } /* ================================================ */ /* PREMIERE PHASE */ /* ================================================ */ #ifdef VERBOSE printf("1ere etape\n"); #endif // INITIALISATION DT for (x = 0; x < N; x++) if (IM[x]) DT[x] = INFINI; else DT[x] = 0; // INITIALISATION DU RBT for (x = 0; x < N; x++) if (IM[x] && (DX[x] != val_inhibit) && bordext8(IM, x, rs, N)) { mcrbt_RbtInsert(&RBT, DX[x], x); Set(x, EN_RBT); } // if, for d = 1; if (connex == 4) { while (!mcrbt_RbtVide(RBT)) { x = RbtPopMin(RBT); UnSet(x, EN_RBT); #ifdef DEBUG printf("pop x = %d,%d, im = %d, dx = %ld\n", x%rs, x/rs, IM[x], DX[x]); #endif if (simple4(IM, x, rs, N)) { DT[x] = d; IM[x] = 0; d++; for (k = 0; k < 8; k += 1) /* parcourt les voisins en 8-connexite */ { /* pour empiler les voisins */ y = voisin(x, k, rs, N); /* non deja empiles */ if ((y != -1) && (IM[y]) && (DX[y] != val_inhibit) && (! IsSet(y, EN_RBT))) { mcrbt_RbtInsert(&RBT, DX[y], y); Set(y, EN_RBT); } /* if y */ } /* for k */ } // if (simple4(IM, x, rs, N)) } /* while (!mcrbt_RbtVide(RBT)) */ } /* if (connex == 4) */ else if (connex == 8) { while (!mcrbt_RbtVide(RBT)) { x = RbtPopMin(RBT); UnSet(x, EN_RBT); #ifdef DEBUG printf("pop x = %d,%d, im = %d, dx = %ld\n", x%rs, x/rs, IM[x], DX[x]); #endif if (simple8(IM, x, rs, N)) { DT[x] = d; IM[x] = 0; d++; for (k = 0; k < 8; k += 1) /* parcourt les voisins en 8-connexite */ { /* pour empiler les voisins */ y = voisin(x, k, rs, N); /* non deja empiles */ if ((y != -1) && (IM[y]) && (DX[y] != val_inhibit) && (! IsSet(y, EN_RBT))) { mcrbt_RbtInsert(&RBT, DX[y], y); Set(y, EN_RBT); } /* if y */ } /* for k */ } // if (simple8(IM, x, rs, N)) } /* while (!mcrbt_RbtVide(RBT)) */ } /* if (connex == 8) */ #ifdef DEBUG writeimage(dt, "_dt"); #endif /* ================================================ */ /* SECONDE PHASE */ /* ================================================ */ #ifdef SECONDE_PHASE stabilite = 0; while (!stabilite) { #ifdef VERBOSE printf("2eme etape\n"); #endif stabilite = 1; // INITIALISATION DU RBT for (j = 1; j < cs-1; j++) for (i = 1; i < rs-1; i++) { x = j * rs + i; if (DT[x] && (DT[x] != INFINI)) mcrbt_RbtInsert(&RBT, DT[x], x); } if (connex == 4) { while (!mcrbt_RbtVide(RBT)) { x = RbtPopMin(RBT); #ifdef DEBUG printf("pop x = %d,%d, dt = %ld\n", x%rs, x/rs, DT[x]); #endif if (abaisse4(x, DT, rs, N)) { stabilite = 0; #ifdef DEBUG printf("abaisse a %ld\n", DT[x]); #endif } // if (abaisse4(x, DT, rs, N)) } // while (!mcrbt_RbtVide(RBT)) } // if (connex == 4) else if (connex == 8) { int32_t abaisse; while (!mcrbt_RbtVide(RBT)) { x = RbtPopMin(RBT); #ifdef DEBUG printf("pop x = %d,%d, dt = %d\n", x%rs, x/rs, DT[x]); #endif if (abaisse8(x, DT, rs, N)) { stabilite = 0; #ifdef DEBUG printf("abaisse a %ld\n", DT[x]); #endif } // if (abaisse8(x, DT, rs, N)) } // while (!mcrbt_RbtVide(RBT)) } // if (connex == 8) } // while (!stabilite) #endif // RECUPERATION DU RESULTAT d = 0; // valeur pour l'infini: plus grande valeur finie + 1 for (x = 0; x < N; x++) if ((DT[x] > d) && (DT[x] < INFINI)) d = DT[x]; d += 1; for (x = 0; x < N; x++) if (DT[x] == INFINI) DX[x] = d; else DX[x] = DT[x]; /* ================================================ */ /* UN PEU DE MENAGE */ /* ================================================ */ IndicsTermine(); mcrbt_RbtTermine(RBT); freeimage(dt); return(1); } /* lsquelval() */
int FindPiecesInfo(unsigned char *ImageData, int SizeH, int SizeW) { unsigned char piecemap[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if((ImageData[i*SizeW*3+j*3+0] <= 220) || (ImageData[i*SizeW*3+j*3+1] <= 220) || (ImageData[i*SizeW*3+j*3+2] <= 220)) { piecemap[i][j] = 255; } else piecemap[i][j] = 0; } } writeimage("1a piecemap.raw", &piecemap[0][0], SizeH, SizeW, 1); int labeledmap[SizeH][SizeW]; // float hist[256]; memset(labeledmap, 0, SizeH*SizeW*(sizeof(int))); TwoPassLable(SizeH, SizeW, &piecemap[0][0], &labeledmap[0][0]); // GetHG(&labeledmap[0][0], &hist[0], SizeH, SizeW, 256); // OutputHG("1a piecelabeledmap_hist.txt", &hist[0], 256); unsigned char fortest[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { fortest[i][j] = labeledmap[i][j]*50; } } writeimage("1a piecelabeledmap.raw", &fortest[0][0], SizeH, SizeW, 1); int x1, y1, x2, y2, x3, y3, x4, y4; int a1, b1, a2, b2, a3, b3, a4, b4; float x, y, a, b, mW, mH, eW, eH, mAngle, eAngle; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if(labeledmap[i][j] == 1) { x2 = j; y2 = SizeH - (i+1); // y2 = y2 - 1; break; } } } for(int j=0; j<SizeW; j++) { for(int i=0; i<SizeH; i++) { if(labeledmap[i][j] == 1) { x3 = j; // x3 = x3 + 1; y3 = SizeH - (i+1); break; } } } for(int i=(SizeH-1); i>=0; i--) { for(int j=(SizeW-1); j>=0; j--) { if(labeledmap[i][j] == 1) { x1 = j; y1 = SizeH - (i+1); // y1 = y1 + 1; break; } } } for(int j=(SizeW-1); j>=0; j--) { for(int i=(SizeH-1); i>=0; i--) { if(labeledmap[i][j] == 1) { x4 = j; // x4 = x4 - 1; y4 = SizeH - (i+1); break; } } } for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if(labeledmap[i][j] != 0 && labeledmap[i][j] != 1) { a2 = j; b2 = SizeH - (i+1); // b2 = b2 - 1; break; } } } for(int j=0; j<SizeW; j++) { for(int i=0; i<SizeH; i++) { if(labeledmap[i][j] != 0 && labeledmap[i][j] != 1) { a3 = j; // a3 = a3 + 1; b3 = SizeH - (i+1); break; } } } for(int i=(SizeH-1); i>=0; i--) { for(int j=(SizeW-1); j>=0; j--) { if(labeledmap[i][j] != 0 && labeledmap[i][j] != 1) { a1 = j; b1 = SizeH - (i+1); // b1 = b1 + 1; break; } } } for(int j=(SizeW-1); j>=0; j--) { for(int i=(SizeH-1); i>=0; i--) { if(labeledmap[i][j] != 0 && labeledmap[i][j] != 1) { a4 = j; // a4 = a4 - 1; b4 = SizeH - (i+1); break; } } } // printf("%d, %d, %d, %d, %d, %d, %d, %d\n", a1, b1, a2, b2, a3, b3, a4, b4); float mtemp1, mtemp2, etemp1, etemp2; mtemp1 = 1.0*(y2 - y1)/(x2 - x1); mtemp2 = 1.0*(y4 - y3)/(x4 - x3); etemp1 = 1.0*(b2 - b1)/(a2 - a1); etemp2 = 1.0*(b4 - b3)/(a4 - a3); x = (y3 - mtemp2*x3 + mtemp1*x1 - y1)/(mtemp1 - mtemp2); y = mtemp1*(x - x1) + y1; a = (b3 - etemp2*a3 + etemp1*a1 - b1)/(etemp1 - etemp2); b = etemp1*(a - a1) + b1; mW = sqrt((x2 - x3)*(x2 - x3) + (y2 - y3)*(y2 - y3)); mH = sqrt((x4 - x2)*(x4 - x2) + (y2 - y4)*(y2 - y4)); eH = sqrt((a2 - a3)*(a2 - a3) + (b2 - b3)*(b2 - b3)); eW = sqrt((a4 - a2)*(a4 - a2) + (b2 - b4)*(b2 - b4)); mAngle = atan(1.0*(y4-y1)/(x4-x1)); eAngle = atan(1.0*(b4-b2)/(a4-a2)); printf(" mouth height = %f,\n mouth width = %f,\n center coordinate of mouth (i, j) = (%f, %f),\n the orientation angle = %f;\n", mH, mW, (SizeH-y-1), x, mAngle); printf(" eye height = %f,\n eye width = %f,\n center coordinate of eye (i, j) = (%f, %f),\n the orientation angle = %f.\n", eH, eW, (SizeH-b-1), a, eAngle); return 0; }
int FindHoleInfo(unsigned char *ImageData, int SizeH, int SizeW) { unsigned char holemap[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if(ImageData[i*SizeW*3+j*3+0] > 235 && ImageData[i*SizeW*3+j*3+1] > 225 && ImageData[i*SizeW*3+j*3+2] > 218) { holemap[i][j] = 255; } else holemap[i][j] = 0; } } writeimage("1a holemap.raw", &holemap[0][0], SizeH, SizeW, 1); int labeledmap[SizeH][SizeW]; memset(labeledmap, 0, SizeH*SizeW*(sizeof(int))); TwoPassLable(SizeH, SizeW, &holemap[0][0], &labeledmap[0][0]); unsigned char fortest[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { fortest[i][j] = labeledmap[i][j]*50; } } writeimage("1a labeledmap.raw", &fortest[0][0], SizeH, SizeW, 1); unsigned char finalmap[SizeH][SizeW]; memset(finalmap, 0, SizeH*SizeW*(sizeof(unsigned char))); // for(int i=1; i<(SizeH-3); i++) // { // for(int j=1; j<(SizeW-3); j++) // { // if(labeledmap[i][j] != 0) // { // if(labeledmap[i-1][j-1]==0 && labeledmap[i-1][j]==0 && labeledmap[i-1][j+1]==0 && // labeledmap[i-1][j+2]==0 && labeledmap[i-1][j+3]==0 && labeledmap[i][j-1]==0 && // labeledmap[i+1][j-1]==0 && labeledmap[i+2][j-1]==0 && labeledmap[i+3][j-1]==0 && // labeledmap[i][j+1]!=0 && labeledmap[i][j+2]!=0 && labeledmap[i][j+3]!=0 && // labeledmap[i+1][j]!=0 && labeledmap[i+2][j]!=0 && labeledmap[i+3][j]!=0) // { // for(int u=0; u<SizeH; u++) // { // for(int v=0; v<SizeW; v++) // { // if(labeledmap[u][v] == labeledmap[i][j]) // finalmap[u][v] = labeledmap[i][j]; // } // } // } // } // } // } int mark = 1; for(int i=(SizeH-2); i>=3; i--) { for(int j=(SizeW-2); j>=3; j--) { if(labeledmap[i][j] != 0) { if(labeledmap[i-3][j+1]==0 && labeledmap[i-2][j+1]==0 && labeledmap[i-1][j+1]==0 && labeledmap[i][j+1]==0 && labeledmap[i+1][j+1]==0 && labeledmap[i+1][j]==0 && labeledmap[i+1][j-3]==0 && labeledmap[i+1][j-2]==0 && labeledmap[i+1][j-1]==0 && labeledmap[i][j-1]!=0 && labeledmap[i][j-2]!=0 && labeledmap[i][j-3]!=0 && labeledmap[i-1][j]!=0 && labeledmap[i-2][j]!=0 && labeledmap[i-3][j]!=0) { for(int u=0; u<SizeH; u++) { for(int v=0; v<SizeW; v++) { if(labeledmap[u][v] == labeledmap[i][j]) finalmap[u][v] = mark*100; } } // printf("%d\n", mark); mark++; } } } } writeimage("1a finalmap.raw", &finalmap[0][0], SizeH, SizeW, 1); int mouthH=0, mouthW=0, eyeH=0, eyeW=0; float mouthI, mouthJ, eyeI, eyeJ; for(int i=0; i<SizeH; i++) { int check = 0; for(int j=0; j<SizeW; j++) { if(finalmap[i][j] == 1*100) { for(int u=0; u<SizeW; u++) { if(finalmap[i][u] == 1*100) { mouthW++; } } for(int u=0; u<SizeH; u++) { if(finalmap[u][j] == 1*100) { mouthH++; } } mouthI = (i-1)+(mouthH/2.0); mouthJ = (j-1)+(mouthW/2.0); check = 1; break; } } if(check == 1) break; } for(int i=(SizeH-1); i>=0; i--) { int check = 0; for(int j=(SizeW-1); j>=0; j--) { if(finalmap[i][j] == 2*100) { for(int u=0; u<SizeW; u++) { if(finalmap[i][u] == 2*100) { eyeW++; } } for(int u=0; u<SizeH; u++) { if(finalmap[u][j] == 2*100) { eyeH++; } } eyeI = i-(eyeH/2.0); eyeJ = j-(eyeW/2.0); check = 1; break; } } if(check == 1) break; } printf(" height of hole of mouth = %d,\n width of hole of mouth = %d,\n center coordinate of hole of mouth (i, j)= (%f, %f);\n", mouthH, mouthW, mouthI, mouthJ); printf(" height of hole of eye = %d,\n width of hole of eye = %d,\n center coordinate of hole of eye (i, j)= (%f, %f).\n\n", eyeH, eyeW, eyeI, eyeJ); return 0; }
int p1b(void) { // initialize data of input const char *filename = "jennifer.raw"; int SizeW = 512; int SizeH = 512; int BytesPerPixel = 3; unsigned char ImageData[SizeH][SizeW][BytesPerPixel]; // read input readimage(filename, &ImageData[0][0][0], SizeH, SizeW, BytesPerPixel); // int scaleW1 = 512 - (128*(576-512)/512); // int scaleH1 = 512; // unsigned char scaledImage1[scaleH1][scaleW1][3]; // resizeimage(&ImageData[0][0][0], &scaledImage1[0][0][0], SizeH, SizeW, scaleH1, scaleW1); // int scaleH2 = 512 - (128*(576-512)/512); // int scaleW2 = 512; // unsigned char scaledImage2[scaleH2][scaleW2][3]; // resizeimage(&ImageData[0][0][0], &scaledImage2[0][0][0], SizeH, SizeW, scaleH2, scaleW2); // writeimage("1b horzscaledJ.raw", &scaledImage1[0][0][0], scaleH1, scaleW1, 3); int horzH = 512, horzW = 576; unsigned char horzoutput[horzH][horzW][BytesPerPixel]; memset(horzoutput, 0, horzH*horzW*3*(sizeof(unsigned char))); int vertH = 576, vertW = 512; unsigned char vertoutput[vertH][vertW][BytesPerPixel]; memset(vertoutput, 0, vertH*vertW*3*(sizeof(unsigned char))); for(int i=0; i<128; i++) { for(int j=0; j<SizeW; j++) { int s = (576-512)*(i+1)/128.0; horzoutput[i][j+s][0] = ImageData[i][j][0]; horzoutput[i][j+s][1] = ImageData[i][j][1]; horzoutput[i][j+s][2] = ImageData[i][j][2]; } } for(int i=128; i<256; i++) { for(int j=0; j<SizeW; j++) { int s = (576-512)*((255-i)+1)/128.0; horzoutput[i][j+s][0] = ImageData[i][j][0]; horzoutput[i][j+s][1] = ImageData[i][j][1]; horzoutput[i][j+s][2] = ImageData[i][j][2]; } } for(int i=256; i<384; i++) { for(int j=0; j<SizeW; j++) { int s = (576-512)*((i-256)+1)/128.0; horzoutput[i][j+s][0] = ImageData[i][j][0]; horzoutput[i][j+s][1] = ImageData[i][j][1]; horzoutput[i][j+s][2] = ImageData[i][j][2]; } } for(int i=384; i<512; i++) { for(int j=0; j<SizeW; j++) { int s = (576-512)*((511-i)+1)/128.0; horzoutput[i][j+s][0] = ImageData[i][j][0]; horzoutput[i][j+s][1] = ImageData[i][j][1]; horzoutput[i][j+s][2] = ImageData[i][j][2]; } } writeimage("1b horizontal shear J.raw", &horzoutput[0][0][0], horzH, horzW, 3); for(int j=0; j<128; j++) { for(int i=0; i<SizeW; i++) { int s = (576-512)*(j+1)/128.0; vertoutput[i+s][j][0] = ImageData[i][j][0]; vertoutput[i+s][j][1] = ImageData[i][j][1]; vertoutput[i+s][j][2] = ImageData[i][j][2]; } } for(int j=128; j<256; j++) { for(int i=0; i<SizeW; i++) { int s = (576-512)*((255-j)+1)/128.0; vertoutput[i+s][j][0] = ImageData[i][j][0]; vertoutput[i+s][j][1] = ImageData[i][j][1]; vertoutput[i+s][j][2] = ImageData[i][j][2]; } } for(int j=256; j<384; j++) { for(int i=0; i<SizeW; i++) { int s = (576-512)*((j-256)+1)/128.0; vertoutput[i+s][j][0] = ImageData[i][j][0]; vertoutput[i+s][j][1] = ImageData[i][j][1]; vertoutput[i+s][j][2] = ImageData[i][j][2]; } } for(int j=384; j<512; j++) { for(int i=0; i<SizeW; i++) { int s = (576-512)*((511-j)+1)/128.0; vertoutput[i+s][j][0] = ImageData[i][j][0]; vertoutput[i+s][j][1] = ImageData[i][j][1]; vertoutput[i+s][j][2] = ImageData[i][j][2]; } } writeimage("1b vertical shear J.raw", &vertoutput[0][0][0], vertH, vertW, 3); return 0; }
int main(void) { //time meassuring struct timeval tvs; //variables int Nx=1024; int Ny=1024; int plotnum=0; int Tmax=2; int plottime=0; int plotgap=1; double Lx=1.0; double Ly=1.0; double dt=0.0; double A=0.0; double B=0.0; double Du=0.0; double Dv=0.0; //splitting coefficients double a=0.5; double b=0.5; double c=1.0; //loop counters int i=0; int j=0; int n=0; double*umax=NULL; double*vmax=NULL; parainit(&Nx,&Ny,&Tmax,&plotgap,&Lx,&Ly,&dt,&Du,&Dv,&A,&B); plottime=plotgap; vmax=(double*)malloc((Tmax/plotgap+1)*sizeof(double)); umax=(double*)malloc((Tmax/plotgap+1)*sizeof(double)); //openCL variables cl_platform_id *platform_id = NULL; cl_kernel frequencies = NULL, initialdata = NULL, linearpart=NULL; cl_kernel nonlinearpart_a=NULL, nonlinearpart_b=NULL; cl_int ret; cl_uint num_platforms; // Detect how many platforms there are. ret = clGetPlatformIDs(0, NULL, &num_platforms); // Allocate enough space for the number of platforms. platform_id = (cl_platform_id*) malloc(num_platforms*sizeof(cl_platform_id)); // Store the platforms ret = clGetPlatformIDs(num_platforms, platform_id, NULL); printf("Found %d platform(s)!\n",num_platforms); cl_uint *num_devices; num_devices=(cl_uint*) malloc(num_platforms*sizeof(cl_uint)); cl_device_id **device_id = NULL; device_id =(cl_device_id**) malloc(num_platforms*sizeof(cl_device_id*)); // Detect number of devices in the platforms for(i=0;i<num_platforms;i++){ char buf[65536]; size_t size; ret = clGetPlatformInfo(platform_id[i],CL_PLATFORM_VERSION,sizeof(buf),buf,&size); printf("%s\n",buf); ret = clGetDeviceIDs(platform_id[i],CL_DEVICE_TYPE_ALL,0,NULL,num_devices); printf("Found %d device(s) on platform %d!\n", num_devices[i],i); ret = clGetPlatformInfo(platform_id[i],CL_PLATFORM_NAME,sizeof(buf),buf,&size); printf("%s ",buf); // Store numDevices from platform device_id[i]=(cl_device_id*) malloc(num_devices[i]*sizeof(device_id)); ret = clGetDeviceIDs(platform_id[i],CL_DEVICE_TYPE_ALL,num_devices[i],device_id[i],NULL); for(j=0;j<num_devices[i];j++){ ret = clGetDeviceInfo(device_id[i][j],CL_DEVICE_NAME,sizeof(buf),buf,&size); printf("%s (%d,%d)\n",buf,i,j); } } //create context and command_queue cl_context context = NULL; cl_command_queue command_queue = NULL; //Which platform and device do i choose? int chooseplatform=0; int choosedevice=0; printf("Choose platform %d and device %d!\n",chooseplatform,choosedevice); context = clCreateContext( NULL, num_devices[chooseplatform], device_id[chooseplatform], NULL, NULL, &ret); if(ret!=CL_SUCCESS){printf("createContext ret:%d\n",ret); exit(1); } command_queue = clCreateCommandQueue(context, device_id[chooseplatform][choosedevice], 0, &ret); if(ret!=CL_SUCCESS){printf("createCommandQueue ret:%d\n",ret); exit(1); } //OpenCL arrays cl_mem cl_u = NULL,cl_v = NULL; cl_mem cl_uhat = NULL, cl_vhat = NULL; cl_mem cl_kx = NULL, cl_ky = NULL; //FFT clfftPlanHandle planHandle; cl_mem tmpBuffer = NULL; fftinit(&planHandle,&context, &command_queue, &tmpBuffer, Nx, Ny); //allocate gpu memory/ cl_u=clCreateBuffer(context, CL_MEM_READ_WRITE, 2*Nx* Ny* sizeof(double), NULL, &ret); cl_v=clCreateBuffer(context, CL_MEM_READ_WRITE, 2*Nx* Ny* sizeof(double), NULL, &ret); cl_uhat=clCreateBuffer(context, CL_MEM_READ_WRITE, 2*Nx * Ny* sizeof(double), NULL, &ret); cl_vhat=clCreateBuffer(context, CL_MEM_READ_WRITE, 2*Nx * Ny* sizeof(double), NULL, &ret); cl_kx = clCreateBuffer(context, CL_MEM_READ_WRITE, Nx * sizeof(double), NULL, &ret); cl_ky = clCreateBuffer(context, CL_MEM_READ_WRITE, Ny * sizeof(double), NULL, &ret); printf("allocated space\n"); //load the kernels loadKernel(&frequencies,&context,&device_id[chooseplatform][choosedevice],"frequencies"); loadKernel(&initialdata,&context,&device_id[chooseplatform][choosedevice],"initialdata"); loadKernel(&linearpart,&context,&device_id[chooseplatform][choosedevice],"linearpart"); loadKernel(&nonlinearpart_a,&context,&device_id[chooseplatform][choosedevice],"nonlinearpart_a"); loadKernel(&nonlinearpart_b,&context,&device_id[chooseplatform][choosedevice],"nonlinearpart_b"); size_t global_work_size[1] = {Nx*Ny}; size_t global_work_size_X[1] = {Nx}; size_t global_work_size_Y[1] = {Ny}; //frequencies ret = clSetKernelArg(frequencies, 0, sizeof(cl_mem),(void *)&cl_kx); ret = clSetKernelArg(frequencies, 1, sizeof(double),(void* )&Lx); ret = clSetKernelArg(frequencies, 2, sizeof(int),(void* )&Nx); ret = clEnqueueNDRangeKernel(command_queue, frequencies, 1, NULL, global_work_size_X, NULL, 0, NULL, NULL); ret = clFinish(command_queue); ret = clSetKernelArg(frequencies, 0, sizeof(cl_mem),(void *)&cl_ky); ret = clSetKernelArg(frequencies, 1, sizeof(double),(void* )&Ly); ret = clSetKernelArg(frequencies, 2, sizeof(int),(void* )&Ny); ret = clEnqueueNDRangeKernel(command_queue, frequencies, 1, NULL, global_work_size_Y, NULL, 0, NULL, NULL); ret = clFinish(command_queue); //printCL(&cl_kx,&command_queue,Nx,1); //printCL(&cl_ky,&command_queue,1,Ny); //inintial data ret = clSetKernelArg(initialdata, 0, sizeof(cl_mem),(void *)&cl_u); ret = clSetKernelArg(initialdata, 1, sizeof(cl_mem),(void* )&cl_v); ret = clSetKernelArg(initialdata, 2, sizeof(int),(void* )&Nx); ret = clSetKernelArg(initialdata, 3, sizeof(int),(void* )&Ny); ret = clSetKernelArg(initialdata, 4, sizeof(double),(void* )&Lx); ret = clSetKernelArg(initialdata, 5, sizeof(double),(void* )&Ly); ret = clEnqueueNDRangeKernel(command_queue, initialdata, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); //make output writedata_C(&cl_u, &command_queue,Nx,Ny,plotnum,"u"); writedata_C(&cl_v, &command_queue,Nx,Ny,plotnum,"v"); umax[plotnum]=writeimage(&cl_u, &command_queue,Nx,Ny,plotnum,"u"); vmax[plotnum]=writeimage(&cl_v, &command_queue,Nx,Ny,plotnum,"v"); printf("Got initial data, starting timestepping\n"); mtime_s(&tvs); for(n=0;n<=Tmax;n++){ //nonlinearpart_a ret = clSetKernelArg(nonlinearpart_a, 0, sizeof(cl_mem),(void *)&cl_u); ret = clSetKernelArg(nonlinearpart_a, 1, sizeof(cl_mem),(void* )&cl_v); ret = clSetKernelArg(nonlinearpart_a, 2, sizeof(double),(void* )&A); ret = clSetKernelArg(nonlinearpart_a, 3, sizeof(double),(void* )&dt); ret = clSetKernelArg(nonlinearpart_a, 4, sizeof(double),(void* )&a); ret = clEnqueueNDRangeKernel(command_queue, nonlinearpart_a, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); //nonlinearpart_b ret = clSetKernelArg(nonlinearpart_b, 0, sizeof(cl_mem),(void *)&cl_u); ret = clSetKernelArg(nonlinearpart_b, 1, sizeof(cl_mem),(void* )&cl_v); ret = clSetKernelArg(nonlinearpart_b, 2, sizeof(double),(void* )&A); ret = clSetKernelArg(nonlinearpart_b, 3, sizeof(double),(void* )&dt); ret = clSetKernelArg(nonlinearpart_b, 4, sizeof(double),(void* )&b); ret = clEnqueueNDRangeKernel(command_queue, nonlinearpart_b, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); //linear fft2dfor(&cl_u, &cl_uhat,&planHandle,&command_queue,&tmpBuffer); fft2dfor(&cl_v, &cl_vhat,&planHandle,&command_queue,&tmpBuffer); //printf("A%f,B%f\n",A,B); ret = clSetKernelArg(linearpart, 0, sizeof(cl_mem),(void *)&cl_uhat); ret = clSetKernelArg(linearpart, 1, sizeof(cl_mem),(void *)&cl_vhat); ret = clSetKernelArg(linearpart, 2, sizeof(cl_mem),(void* )&cl_kx); ret = clSetKernelArg(linearpart, 3, sizeof(cl_mem),(void* )&cl_ky); ret = clSetKernelArg(linearpart, 4, sizeof(double),(void* )&Du); ret = clSetKernelArg(linearpart, 5, sizeof(double),(void* )&Dv); ret = clSetKernelArg(linearpart, 6, sizeof(double),(void* )&A); ret = clSetKernelArg(linearpart, 7, sizeof(double),(void* )&B); ret = clSetKernelArg(linearpart, 8, sizeof(double),(void* )&dt); ret = clSetKernelArg(linearpart, 9, sizeof(double),(void* )&c); ret = clSetKernelArg(linearpart, 10, sizeof(int),(void* )&Nx); ret = clSetKernelArg(linearpart, 11, sizeof(int),(void* )&Ny); ret = clEnqueueNDRangeKernel(command_queue, linearpart, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); fft2dback(&cl_u, &cl_uhat,&planHandle,&command_queue,&tmpBuffer); fft2dback(&cl_v, &cl_vhat,&planHandle,&command_queue,&tmpBuffer); //nonlinearpart_b ret = clSetKernelArg(nonlinearpart_b, 0, sizeof(cl_mem),(void *)&cl_u); ret = clSetKernelArg(nonlinearpart_b, 1, sizeof(cl_mem),(void* )&cl_v); ret = clSetKernelArg(nonlinearpart_b, 2, sizeof(double),(void* )&A); ret = clSetKernelArg(nonlinearpart_b, 3, sizeof(double),(void* )&dt); ret = clSetKernelArg(nonlinearpart_b, 4, sizeof(double),(void* )&b); ret = clEnqueueNDRangeKernel(command_queue, nonlinearpart_b, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); //nonlinearpart_a ret = clSetKernelArg(nonlinearpart_a, 0, sizeof(cl_mem),(void *)&cl_u); ret = clSetKernelArg(nonlinearpart_a, 1, sizeof(cl_mem),(void* )&cl_v); ret = clSetKernelArg(nonlinearpart_a, 2, sizeof(double),(void* )&A); ret = clSetKernelArg(nonlinearpart_a, 3, sizeof(double),(void* )&dt); ret = clSetKernelArg(nonlinearpart_a, 4, sizeof(double),(void* )&a); ret = clEnqueueNDRangeKernel(command_queue, nonlinearpart_a, 1, NULL, global_work_size, NULL, 0, NULL, NULL); ret = clFinish(command_queue); // done if(n==plottime){ printf("time:%f, step:%d,%d,umax:%f,vmax:%f\n",n*dt,n,plotnum,umax[plotnum],vmax[plotnum]); plottime=plottime+plotgap; plotnum=plotnum+1; writedata_C(&cl_u, &command_queue,Nx,Ny,plotnum,"u"); writedata_C(&cl_v, &command_queue,Nx,Ny,plotnum,"v"); umax[plotnum]=writeimage(&cl_u, &command_queue,Nx,Ny,plotnum,"u"); vmax[plotnum]=writeimage(&cl_v, &command_queue,Nx,Ny,plotnum,"v"); } }//end timestepping printf("Finished time stepping\n"); mtime_e(&tvs,"Programm took:"); writearray(umax,(Tmax/plotgap)+1,"u"); writearray(vmax,(Tmax/plotgap)+1,"v"); free(umax); free(vmax); clReleaseMemObject(cl_u); clReleaseMemObject(cl_v); clReleaseMemObject(cl_uhat); clReleaseMemObject(cl_vhat); clReleaseMemObject(cl_kx); clReleaseMemObject(cl_ky); ret = clReleaseKernel(initialdata); ret = clReleaseKernel(frequencies); ret = clReleaseKernel(linearpart); ret = clReleaseKernel(nonlinearpart_a); ret = clReleaseKernel(nonlinearpart_b); fftdestroy(&planHandle, &tmpBuffer); ret = clReleaseCommandQueue(command_queue); ret = clReleaseContext(context); for(i=0;i<num_platforms;i++){free(device_id[i]);} free(device_id); free(platform_id); free(num_devices); printf("Program execution complete\n"); return 0; }
int Segment(int SizeH, int SizeW, unsigned char *inputdata) { int labeleddata[SizeH][SizeW]; int count; memset(labeleddata, 0, SizeH*SizeW*(sizeof(int))); count = TwoPassLable(SizeH, SizeW, inputdata, &labeleddata[0][0]); unsigned char fortest[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { fortest[i][j] = labeleddata[i][j]*50; } } writeimage("2a labeledmap.raw", &fortest[0][0], SizeH, SizeW, 1); int label = 1; int check = 0; int top, botton, left, right; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if(labeleddata[i][j] == label) { // printf("top = %d ", i); top = i; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int j=0; j<SizeW; j++) { for(int i=0; i<SizeH; i++) { if(labeleddata[i][j] == label) { // printf("left = %d ", j); left = j; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int i=SizeH-1; i>=0; i--) { for(int j=SizeW-1; j>=0; j--) { if(labeleddata[i][j] == label) { // printf("botton = %d ", i); botton = i; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int j=SizeW-1; j>=0; j--) { for(int i=0; i<SizeH; i++) { if(labeleddata[i][j] == label) { // printf("right = %d \n", j); right = j; check = 1; break; } } if(check == 1) { check = 0; break; } } int testH, testW; testH = botton - top + 1; testW = right - left + 1; int mayH, mayW; while(label < SizeH) { for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { if(labeleddata[i][j] == label) { // printf("top = %d ", i); top = i; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int j=0; j<SizeW; j++) { for(int i=0; i<SizeH; i++) { if(labeleddata[i][j] == label) { // printf("left = %d ", j); left = j; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int i=SizeH-1; i>=0; i--) { for(int j=SizeW-1; j>=0; j--) { if(labeleddata[i][j] == label) { // printf("botton = %d ", i); botton = i; check = 1; break; } } if(check == 1) { check = 0; break; } } for(int j=SizeW-1; j>=0; j--) { for(int i=0; i<SizeH; i++) { if(labeleddata[i][j] == label) { // printf("right = %d \n", j); right = j; check = 1; break; } } if(check == 1) { check = 0; break; } } mayH = botton - top + 1; mayW = right - left + 1; if(abs(mayH - testH)<=2 && abs(mayW - testW)<= 2) { printf("") } label++; } return 0; }
int32_t main(int argc, char *argv[]) { struct xvimage *image, *edges; FILE *output, *amira_script; char output_format; double r, v, b; iv_scene* scene; list *ss_result, *ss_result2; complexe *temp, *intersect_edges, *point; uint32_t i, rs, ps, d, N, lim, erode, j, keep, k, max, num_pt, *tab_pt, kept; char name[BASE_ALLOC]; //******************************************* //Checking input values //******************************************* if (argc!=4) { fprintf(stderr, "usage: %s %s\n", argv[0], USAGE); return(-1); } //We read input image image=readimage(argv[1]); if (image==NULL) { fprintf(stderr, "Error: Could not read %s.\n", argv[1]); return(-1); } else if(datatype(image)!=VFF_TYP_1_BYTE) { fprintf(stderr, "Error: only CC image supported\n"); return(-1); } //We extract some info rs=rowsize(image1); cs=colsize(image1); d=depth(image1); N=rs*cs*d; //We produce the edges image edges=copyimage(image); if(edges==NULL) { fprintf(stderr, "Memory allocation error : not enough memory.\n"); return(-1); } //And keep only intersection edges in this image pix=0; for(k=0; k<d; k++) for(j=0; j<cs; j++) for(i=0; i<rs; i++) { if( (UCHARDATA(image1)[pix] & CC_AX) != 0) { t=cca_cardinal_containers(image1, pix, i, j, k, CC_AX, rs, rs*cs); if(t<3) UCHARDATA(image1)[pix]&=(255-CC_AX); } if( (UCHARDATA(image1)[pix] & CC_AY) != 0) { t=cca_cardinal_containers(image1, pix, i, j, k, CC_AY, rs, rs*cs); if(t<3) UCHARDATA(image1)[pix]&=(255-CC_AY); } if( (UCHARDATA(image1)[pix] & CC_AZ) != 0) { t=cca_cardinal_containers(image1, pix, i, j, k, CC_AZ, rs, rs*cs); if(t<3) UCHARDATA(image1)[pix]&=(255-CC_AZ); } pix++; } for(i=0; i<N; i++) UCHARDATA(image1)[i]&=255-(CC_VOL | CC_FXY | CC_FYZ | CC_FXZ | CC_PT); cca_makecomplex(image1); if(strcmp(argv[6], "keep")==0) { strategy=KEEP; } else if(strcmp(argv[6], "reject")==0) { strategy=REJECT; } else { fprintf(stderr, "usage: %s %s\n", argv[0], USAGE); return(-1); } mode_amira=0; if(argc==9) { if(strcmp(argv[8], "-amira")!=0) { fprintf(stderr, "usage: %s %s\n", argv[0], USAGE); freeimage(image); freeimage(edges); return(-1); } else { mode_amira=1; } } if(strcmp(argv[4], "fusion")==0) { mode=FUSION; } else if(strcmp(argv[4], "split")==0) { mode=SPLIT; } else { fprintf(stderr, "usage: %s %s\n", argv[0], USAGE); freeimage(image); freeimage(edges); return(-1); } rs=rowsize(image); ps=colsize(image)*rs; if(mode==SPLIT) { //Each surface will be written in different Inventor File //Create an AVIZO script which will allow to open all of them sprintf(name, "%s_avizo_load_script.hx", argv[3]); amira_script=fopen(name, "wb"); if(amira_script==NULL) { fprintf(stderr, "Error: could not create file %s. Check directory permission.\n", name); freeimage(image); freeimage(edges); return(-1); } amira_script_init(amira_script); } else { sprintf(name, "%s.iv", argv[3]); output = fopen(name, "wb"); if(output==NULL) { fprintf(stderr, "Error: could not create output file %s (directory exists?).\n", name); freeimage(image); freeimage(edges); return(-1); } } if(strcmp(argv[7], "NULL")!=0) { cca_image=allocimage(NULL, rs, ps/rs, depth(image), VFF_TYP_1_BYTE); if(cca_image==NULL) { fprintf(stderr, "Error: could not allocate memory\n"); freeimage(image); freeimage(edges); return(-1); } } else { cca_image=NULL; } //******************************************************* //Preparation of the image and the scene //******************************************************* //In case we don't have a complex, uncomment following //cca_makecomplex(image); scene=inventor_new_scene(10, NULL); //Initialize the scene... if(scene==NULL) { fprintf(stderr, "Error when creating new scene.\n"); return(-1); } //We add to our object the main materials (keep the surfaces for later) inventor_add_material_to_scene(scene, "MatPoint", POS_PT, 0.0, 0.0, 0.0, 0.1, 0.4, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatAX", POS_AX, 0.0, 0.0, 0.0, 0.1, 0.1, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatAY", POS_AY, 0.0, 0.0, 0.0, 0.1, 0.1, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatAZ", POS_AZ, 0.0, 0.0, 0.0, 0.1, 0.1, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatVXY", POS_VXY, 0.0, 0.0, 0.0, 0.65, 0.65, 0.65, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatVXZ", POS_VXZ, 0.0, 0.0, 0.0, 0.50, 0.50, 0.50, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_add_material_to_scene(scene, "MatVYZ", POS_VYZ, 0.0, 0.0, 0.0, 0.80, 0.80, 0.80, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); if(mode==FUSION) { scene->output=output; inventor_init_file(scene); } //******************************************************** //Make surface segmentation //******************************************************** //Get the intersection edges intersect_edges=cca_to_complexe(edges); freeimage(edges); if(intersect_edges==NULL) { fprintf(stderr, "Error in function cca_to_complexe()\n"); inventor_delete_scene(scene); freeimage(image); return (-1); } //Make separation of the complex into surface components ss_result=cca_simple_surface_segmentation_with_intersection_edges_and_exclusion_inclusion_image(image, intersect_edges, filter, strategy); if(ss_result==NULL) { fprintf(stderr, "Error: cca_simple_surface_segmentation_with_intersection_edges_and_exclusion_inclusion_image() failed.\n"); inventor_delete_scene(scene); freeimage(image); return(-1); } //We don't need the image anymore freeimage(image); fprintf(stdout, "Found %d surfaces\n", ss_result->cpt -2); //The first item is the set of all vertices... temp=(complexe*)list_pop(ss_result); if(mode==SPLIT) { //We don't care. complexe_free_complexe(temp); point=NULL; tab_pt=NULL; num_pt=0; } else if(mode==FUSION) { for(i=0; i<ss_result->cpt; i++) { //Choose a random color for surfaces r=((double)rand())/((double)RAND_MAX); v=((double)rand())/((double)RAND_MAX); b=((double)rand())/((double)RAND_MAX); sprintf(name, "SurfXY_%d", i); inventor_add_material_to_scene(scene, name, POS_FXY, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); r+=0.05; v+=0.05; b+=0.05; if(r>1.0) r=1.0; if(b>1.0) b=1.0; if(v>1.0) v=1.0; sprintf(name, "SurfXZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FXZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); r+=0.05; v+=0.05; b+=0.05; if(r>1.0) r=1.0; if(b>1.0) b=1.0; if(v>1.0) v=1.0; sprintf(name, "SurfYZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FYZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); inventor_write_material_to_file(scene, POS_FXY); inventor_write_material_to_file(scene, POS_FXZ); inventor_write_material_to_file(scene, POS_FYZ); } //All the surfaces will go in the same file. //The array of points therefore interest us, we keep it and write it in the inventor file point=temp; tab_pt=point->tab_pt_obj; num_pt=point->num_pt_obj; inventor_new_object(scene); //inventor_set_drawstyle(scene, INVISIBLE, 1, 1); inventor_declare_points(scene, "Points", tab_pt, num_pt, rs, ps, mode_amira); } //The second item is the set of all intersect edges... We don't care. temp=(complexe*)list_pop(ss_result); complexe_free_complexe(temp); //******************************************************* //Send the surfaces to output file //******************************************************* i=0; //Will be used for the filename kept=0; while(!list_isempty(ss_result)) { //Get the object to write temp=(complexe*)list_pop(ss_result); keep=1; if(keep==1) { if(cca_image!=NULL) complexe_add_to_cca(cca_image, temp); /* if(temp->num_fxy>0) {k=temp->tab_fxy[0]; f=CC_FXY;} else if(temp->num_fxz>0) {k=temp->tab_fxz[0]; f=CC_FXZ;} else if(temp->num_fyz>0) {k=temp->tab_fyz[0]; f=CC_FYZ;} else assert(0); l=cca_list_container(cca_image, k, getxfrompixnum(k, rs, ps), getyfrompixnum(k, rs, ps), getzfrompixnum(k, rs, ps), f, rs, ps); assert(l->cpt==2); while(!list_isempty(l)) { g=(face_desc*)list_pop(l); surf[kept][l->cpt -1]=LONGDATA(labels)[g->pixnumber]; free(g); } assert(surf[kept][0] != surf[kept][1]); if(surf[kept][0] > surf[kept][1]) { k=surf[kept][1]; surf[kept][1]=surf[kept][0]; surf[kept][0]=k; } */ kept++; if(mode==SPLIT) complexe_compute_vertex_array(temp, rs, ps); if(mode==SPLIT) { //Choose a random color for surfaces r=((double)rand())/((double)RAND_MAX); v=((double)rand())/((double)RAND_MAX); b=((double)rand())/((double)RAND_MAX); sprintf(name, "SurfXY_%d", i); inventor_add_material_to_scene(scene, name, POS_FXY, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); r+=0.05; v+=0.05; b+=0.05; if(r>1.0) r=1.0; if(b>1.0) b=1.0; if(v>1.0) v=1.0; sprintf(name, "SurfXZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FXZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); r+=0.05; v+=0.05; b+=0.05; if(r>1.0) r=1.0; if(b>1.0) b=1.0; if(v>1.0) v=1.0; sprintf(name, "SurfYZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FYZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); //Create an output file for the surface sprintf(name, "%s.surf%d.%d.iv", argv[3], temp->num_fxy+temp->num_fyz+temp->num_fxz, i); output = fopen(name, "wb"); if(output==NULL) { fprintf(stderr, "Error: could not create output file %s (directory exists?).\n", name); while(!list_isempty(ss_result)) { temp=(complexe*)list_pop(ss_result); complexe_free_complexe(temp); } list_delete(ss_result, NO_FREE_DATA); inventor_delete_scene(scene); return(-1); } //Link the output with the scene scene->output=output; //And initialise the scene and the points inventor_init_file(scene); inventor_new_object(scene); //inventor_set_drawstyle(scene, INVISIBLE, 1, 1); inventor_declare_points(scene, "Points", temp->tab_pt_obj, temp->num_pt_obj, rs, ps, mode_amira); tab_pt=temp->tab_pt_obj; num_pt=temp->num_pt_obj; temp->num_pt_obj=0; temp->tab_pt_obj=NULL; } inventor_new_object(scene); if(mode==FUSION) { sprintf(name, "SurfXY_%d", i); inventor_add_material_to_scene(scene, name, POS_FXY, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); sprintf(name, "SurfXZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FXZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); sprintf(name, "SurfYZ_%d", i); inventor_add_material_to_scene(scene, name, POS_FYZ, r, v, b, r, v, b, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); } //inventor_call_defined(scene, "Points"); complexe_to_inventor(scene, temp, num_pt, tab_pt, rs, ps, mode_amira); inventor_close_object(scene); fflush(scene->output); if(mode==SPLIT) { inventor_close_object(scene); fclose(scene->output); //For the amira script k=0; max=0; while(name[k]!='\0') { if(name[k]=='/') max=k+1; k++; } amira_script_add_iv_file(amira_script, &name[max], 1, 30*(i+1)); free(tab_pt); } } i++; complexe_free_complexe(temp); } if(mode==FUSION) { inventor_close_object(scene); fclose(scene->output); } fprintf(stdout, "Kept %d surfaces\n", kept); /*for(i=0; i<kept-1; i++) for(k=i+1; k<kept; k++) { if( */ if(cca_image!=NULL) { writeimage(cca_image, argv[7]); freeimage(cca_image); } //**************************************************** //Program ends //**************************************************** inventor_delete_scene(scene); list_delete(ss_result, NO_FREE_DATA); if(filter!=NULL) freeimage(filter); if(mode==SPLIT) fclose(amira_script); return(0); }
int p3c(void) { // initialize data of input const char *inputname = "trees.raw"; int SizeW = 350; int SizeH = 258; int BytesPerPixel = 3; unsigned char inputdata[SizeH][SizeW][BytesPerPixel]; // initialize data of output const char *outputname1 = "3c tree_SED_ans.raw"; const char *outputname2 = "3c tree_MBVQ_ans.raw"; int newSizeW = SizeW; int newSizeH = SizeH; int newBytesPerPixel = BytesPerPixel; unsigned char outputdata1[newSizeH][newSizeW][newBytesPerPixel]; // read input readimage(inputname, &inputdata[0][0][0], SizeH, SizeW, BytesPerPixel); double inputC[SizeH][SizeW]; double inputM[SizeH][SizeW]; double inputY[SizeH][SizeW]; for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { inputC[i][j] = 1 - (inputdata[i][j][0] / 255.0); inputM[i][j] = 1 - (inputdata[i][j][1] / 255.0); inputY[i][j] = 1 - (inputdata[i][j][2] / 255.0); // printf("%d %f %f %f\n", i, inputC[i][j], inputM[i][j], inputY[i][j]); } } // Separable Error Diffusion double sedC[SizeH][SizeW]; double sedM[SizeH][SizeW]; double sedY[SizeH][SizeW]; FSErrorDiffFord(SizeH, SizeW, &inputC[0][0], &sedC[0][0]); FSErrorDiffFord(SizeH, SizeW, &inputM[0][0], &sedM[0][0]); FSErrorDiffFord(SizeH, SizeW, &inputY[0][0], &sedY[0][0]); for(int i=0; i<SizeH; i++) { for(int j=0; j<SizeW; j++) { outputdata1[i][j][0] = 255*(1 - sedC[i][j]); outputdata1[i][j][1] = 255*(1 - sedM[i][j]); outputdata1[i][j][2] = 255*(1 - sedY[i][j]); // printf("%d %f %f %f\n", i, sedC[i][j], sedM[i][j], sedY[i][j]); } } writeimage(outputname1, &outputdata1[0][0][0], newSizeH, newSizeW, newBytesPerPixel); // MBVQ-based Error diffusion MBVQErrorDiff(inputname, outputname2, SizeH, SizeW, BytesPerPixel); return 0; }
int main( int argc, char *argv[] ) { int ret = 1; int win_main, win_zoom, zoom_factor = 2; double p_x = -1, p_y = -1; unsigned char *zoom_buf = NULL; unsigned char *img_buf = NULL; int img_width, img_height, img_msk; int crosshairs = 1; if ( argc < 2 ) { fprintf(stderr,"[USAGE]\n"); fprintf(stderr,"%s filename.png\n",argv[0]); return 1; } /* zoom ウィンドゥ用の画像バッファ */ zoom_buf = (unsigned char *)malloc(ZOOMWN_WIDTH * ZOOMWN_HEIGHT * 4); if ( zoom_buf == NULL ) goto quit; //img_buf = readimage(NULL,argv[1],&img_width,&img_height,&img_msk); //img_buf = readimage("xbmtopbm",argv[1],&img_width,&img_height,&img_msk); #ifdef USE_IMAGEMAGICK img_buf = readimage("convert",argv[1],&img_width,&img_height,&img_msk); #else img_buf = readimage("pngtopnm",argv[1],&img_width,&img_height,&img_msk); #endif if ( img_buf == NULL ) { fprintf(stderr,"ERROR: cannot read file\n"); goto quit; } printf("mask value = %d\n",img_msk); /* 属性設定(左上を原点にする) */ gsetinitialattributes(DISABLE, BOTTOM_LEFT_ORIGIN); /* ウィンドゥのオープン */ win_zoom = gopen(ZOOMWN_WIDTH*2, ZOOMWN_HEIGHT); win_main = gopen(img_width, img_height); layer(win_zoom,0,1); /* メインウィンドゥへの画像の転送 */ gclr(win_main); gputimage(win_main, 0,0, img_buf, img_width, img_height, img_msk); /* カーソル描画のために,XOR での描画functionに設定 */ newgcfunction(win_main, GXxor); newcolor(win_main, "red"); #if 0 /* 保存のテスト */ //writeimage(img_buf,img_width,img_height,img_msk,"pnmtopng",256,"hoge.png"); //writeimage(img_buf,img_width,img_height,img_msk,NULL,256,"hoge.pam"); gsaveimage( win_main,0,0,0,1999,1999,"pnmtopng",256,"capt0.png"); { int im_w, im_h; unsigned char *im = ggetimage(win_main,0,0,0,1999,1999,&im_w,&im_h); writeimage(im_w,im_h,im,0,"pnmtopng",256,"capt.png"); if ( im != NULL ) free(im); } #endif /* メインループ */ while ( 1 ) { int win_ev, type, b; int needs_redraw = 0; double x, y; win_ev = ggetevent(&type,&b,&x,&y) ; if ( type == EnterNotify ) { fprintf(stderr,"event type = EnterNotify wid=%d\n",win_ev); } else if ( type == LeaveNotify ) { fprintf(stderr,"event type = LeaveNotify wid=%d\n",win_ev); } else { fprintf(stderr,"event type = %d wid=%d\n",type,win_ev); } if ( win_ev == win_main ) { if ( type == MotionNotify || type == EnterNotify || type == LeaveNotify ) { if ( type == LeaveNotify ) { x = -32000; y = -32000; } if ( crosshairs ) { /* crosshairs カーソルを消す */ drawline(win_main, 0,p_y, img_width,p_y); drawline(win_main, p_x,0, p_x,img_height); /* crosshairs カーソルを表示する */ drawline(win_main, 0,y, img_width,y); drawline(win_main, x,0, x,img_height); } needs_redraw = 1; p_x = x; p_y = y; } else if ( type == ButtonPress ) { if ( b == 1 ) zoom_factor++; else if ( b == 3 ) zoom_factor--; needs_redraw = 1; } } if ( type == KeyPress ) { if ( b == 'q' ) goto quit; else if ( b == '>' || b == '+' ) zoom_factor++; else if ( b == '<' || b == '-' ) zoom_factor--; else if ( b == ' ' ) { if ( crosshairs ) { /* crosshairs カーソルを消す */ drawline(win_main, 0,p_y, img_width,p_y); drawline(win_main, p_x,0, p_x,img_height); crosshairs = 0; } else { /* crosshairs カーソルを表示する */ drawline(win_main, 0,p_y, img_width,p_y); drawline(win_main, p_x,0, p_x,img_height); crosshairs = 1; } } needs_redraw = 1; } if ( needs_redraw ) { if ( zoom_factor < 2 ) zoom_factor = 2; else if ( 32 < zoom_factor ) zoom_factor = 32; get_zoom_image(img_width, img_height, img_buf, p_x, p_y, zoom_factor, ZOOMWN_WIDTH, ZOOMWN_HEIGHT, zoom_buf); gclr(win_zoom); /* 普通のコピー */ newgcfunction(win_zoom, GXcopy); gputimage(win_zoom, 0, 0, zoom_buf, ZOOMWN_WIDTH, ZOOMWN_HEIGHT, img_msk); /* 反転コピー */ newgcfunction(win_zoom, GXcopyInverted); gputarea(win_zoom, ZOOMWN_WIDTH, 0, win_zoom,1, 0,0,ZOOMWN_WIDTH-1, ZOOMWN_HEIGHT-1); /* ズームウィンドゥで,文字列を反転描画する */ newgcfunction(win_zoom, GXinvert); drawstr(win_zoom,2,14,14,0, "%dx zoom pos=(%g,%g)\n",zoom_factor,p_x,p_y); copylayer(win_zoom,1,0); } } ret = 0; quit: gcloseall(); if ( img_buf != NULL ) free(img_buf); if ( zoom_buf != NULL ) free(zoom_buf); return ret; }
/** * \brief main function */ int main(int argc, char *argv[]) { int ierr; int num_procs; int tag = 1; double h = 1; int steps = 1; char *basedir = NULL; udata_t udata; udata.nx = 1; udata.ny = 1; udata.dimension = 16; udata.algorithm = 0; udata.picturesteps = 1; // initialize MPI ierr = MPI_Init(&argc, &argv); if (ierr) { fprintf(stderr, "cannot initialize MPI: %d\n", ierr); return EXIT_FAILURE; } // get MPI dimension parameters ierr = MPI_Comm_rank(MPI_COMM_WORLD, &udata.rank); ierr = MPI_Comm_size(MPI_COMM_WORLD, &num_procs); char rankprefix[10]; snprintf(rankprefix, sizeof(rankprefix), "%d", udata.rank); if (debug) { fprintf(stderr, "%s:%d[%d]: process id %d\n", __FILE__, __LINE__, udata.rank, getpid()); } // parse the command line int c; while (EOF != (c = getopt(argc, argv, "b:dh:r:s:t:x:y:n:a:?"))) switch (c) { case 'd': debug++; break; case 's': udata.picturesteps = atoi(optarg); break; case 't': udata.maxsteps = atof(optarg); break; case 'x': udata.nx = atoi(optarg); break; case 'y': udata.ny = atoi(optarg); break; case 'b': basedir = optarg; break; case 'n': udata.dimension = atoi(optarg); break; case 'a': udata.algorithm = atoi(optarg); break; case '?': usage(argv[0]); return EXIT_SUCCESS; } udata.maxsteps = udata.dimension + udata.dimension; udata.h = 1 / udata.dimension; // make sure the arguments are consistent if (num_procs != udata.nx * udata.ny) { fprintf(stderr, "number of processes does not match " "dimensions: %d != %d x %d\n", num_procs, udata.nx, udata.ny); usage(argv[0]); return EXIT_FAILURE; } // compute horizontal and vertical index of this rank udata.rh = udata.rank % udata.nx; udata.rv = udata.rank / udata.nx; if (debug) { fprintf(stderr, "%s:%d[%d]: rh = %d, rv = %d\n", __FILE__, __LINE__, udata.rank, udata.rh, udata.rv); } // next argument is image file name if (argc <= optind) { fprintf(stderr, "image file name argument missing\n"); usage(argv[0]); return EXIT_FAILURE; } char *imagefilename = argv[optind++]; // next argument is output file name char *netcdffilename = NULL; if (argc > optind) { netcdffilename = argv[optind++]; if (debug) { fprintf(stderr, "%s:%d: netcdffilename: %s\n", __FILE__, __LINE__, netcdffilename); } } // image file and output file heatfile_t *hf = NULL; image_t *image = NULL; // process zero initializes and writes data if (udata.rank == 0) { // read the image file image = readimage(imagefilename); if (NULL == image) { fprintf(stderr, "cannot read image\n"); return EXIT_FAILURE; } if (debug) { fprintf(stderr, "%s:%d[%d]: %d x %d image read\n", __FILE__, __LINE__, udata.rank, image->width, image->height); } // create the output file if (netcdffilename) { if (debug) { fprintf(stderr, "%s:%d: creating NetCDF %s\n", __FILE__, __LINE__, netcdffilename); } hf = output2_create(netcdffilename, h, steps * udata.ht, image->width, image->height); if (NULL == hf) { fprintf(stderr, "cannot create output file\n"); return EXIT_FAILURE; } } } // write the first image if ((basedir) && (udata.rank == 0)) { char outfilename[1024]; snprintf(outfilename, sizeof(outfilename), "%s/00000.fits", basedir); writeimage(image, outfilename); } // index ranges for each rank udata.ranges = (int *)malloc(4 * num_procs * sizeof(int)); if (udata.rank == 0) { partitiondomain(&udata, image); } // exchange range size information with all other ranks. The ranks // then pick the dimensions they need from the array, this is // the purpose of the range pointer MPI_Bcast(udata.ranges, 4 * num_procs, MPI_INT, 0, MPI_COMM_WORLD); int *range = &udata.ranges[4 * udata.rank]; if (debug) { fprintf(stderr, "%s:%d:[%d]: [%d,%d) x [%d,%d)\n", __FILE__, __LINE__, udata.rank, range[0], range[1], range[2], range[3]); } // allocate memory for the area we are responsible for udata.width = range[1] - range[0]; udata.height = range[3] - range[2]; allocate_u(&udata); double *unew = (double *)malloc(udata.length * sizeof(double)); if (debug) { fprintf(stderr, "%s:%d[%d]: arrays allocated, %d x %d\n", __FILE__, __LINE__, udata.rank, udata.width, udata.height); } // write initial data to the output file if ((hf) && (udata.rank == 0)) { output2_add(hf, 0, image->data); } // measure start time (after all allocations are done) double start = gettime(); // process 0 has to send the data to all the other processes if (udata.rank == 0) { for (int r = 1; r < num_procs; r++) { sendimagerange(&udata, image, r, tag); } copyfromimage(&udata, image); } else { // receive my part of the matrix receiverange(&udata, tag); } tag++; // make sure dimension is correct if (udata.dimension != udata.height + udata.width) { fprintf(stderr, "dimension does not match\n"); return EXIT_FAILURE; } // start the solver algorithm int stepcounter = 0; // counter for time steps while (stepcounter < udata.maxsteps) { stepcounter++; // copy everything to unew as the initial approximation for (int i = 0; i < udata.length; i++) { unew[i] = udata.u[i]; } // now perform <picturesteps> iterations for (int k = 0; k < udata.picturesteps; k++) { // synchronize current values of boundary with neighbors tag++; exchange_boundaries(&udata, tag); // perform iteration step iterate_u(unew, &udata); // copy the new u to the old u / only used for Jacobi if (udata.algorithm == 0) { for (int i = 0; i < udata.length; i++) { udata.u[i] = unew[i]; } } } // decide whether we have to output something if (0) { // time value for this data output int stepvalue = stepcounter / udata.picturesteps; // output needed, so we synchronize image data tag++; synchronize_image(&udata, image, tag); // write an image if ((basedir) && (udata.rank == 0)) { char outfilename[1024]; snprintf(outfilename, sizeof(outfilename), "%s/%05d.fits", basedir, stepvalue); writeimage(image, outfilename); } // write solution data if ((hf) && (udata.rank == 0)) { output2_add(hf, stepvalue, image->data); } } } // measure end time double end = gettime(); // we are now done, rank 0 displays the result if (udata.rank == 0) { printf("%.6f",end - start); } // close the netcdf file if ((udata.rank == 0) && (hf)) { output_close(hf); } // cleanup MPI MPI_Finalize(); // cleanup the memory we have allocated free(udata.ranges); udata.ranges = NULL; free_u(&udata); return EXIT_SUCCESS; }
int32_t MSF3d(struct xvimage *ga, struct xvimage *marqueurs) #undef F_NAME #define F_NAME "MSF3d" { int32_t i; int32_t u,v; /* une arete */ int32_t x,y,z, x_1,y_1; /* des sommets */ int32_t rs = rowsize(ga); /* taille ligne */ int32_t cs = colsize(ga); /* taille colonne */ int32_t ps = rs*cs; int32_t ds = depth(ga); /* taille plan */ int32_t N = ds * ps; /* taille image */ uint8_t *F = UCHARDATA(ga); /* valuation des aretes de depart */ int32_t *G = SLONGDATA(marqueurs); /* labels des sommets du graph */ int32_t N_t=3*N; /* index maximum d'une arete de ga */ Rbt *L; /* ensembles des aretes adjacentes à exactement un label */ if (depth(ga) == 1){ return MSF(ga, marqueurs); } if ((rowsize(marqueurs) != rs) || (colsize(marqueurs) != cs) || (depth(marqueurs) != ds)) { fprintf(stderr, "%s: incompatible image sizes\n", F_NAME); return 0; } IndicsInit(N_t); L = mcrbt_CreeRbtVide(N_t); for(u = 0; u < N_t; u ++){ if( ( (u < N) && (u%rs < rs-1)) || ((u >= N) && (u < 2*N) && ( (u%ps) < (ps-rs))) || ((u >= 2*N) && (((u- (2*N))/ps) < (ds-1)))){ x = Sommetx3d(u,N,rs,ps); y = Sommety3d(u,N,rs,ps); if((mcmin(G[x],G[y]) == 0) && (mcmax(G[x],G[y]) > 0)){ /* u est growing edge */ /* printf("Initialisation: ds Rbt: (%d,%d)\n", x,y);*/ mcrbt_RbtInsert(&L, (TypRbtKey)F[u], u); Set(u, TRUE); }else Set(u, FALSE); }else Set(u,FALSE); } while(!mcrbt_RbtVide(L)){ u = RbtPopMin(L); #ifdef DEBUG printf("poped arete u no: %d de niveau %d\n",u,F[u]); #endif x = Sommetx3d(u,N,rs,ps); y = Sommety3d(u,N,rs,ps); if(G[x] > G[y]){z=x; x=y; y=z;} #ifdef DEBUG printf("extremites de u (%d,%d);(%d,%d) \n",x%rs, x/rs, y%rs, y/rs); #endif if((mcmin(G[x],G[y]) == 0) && (mcmax(G[x],G[y]) > 0)){ /* si u est une growing edge */ #ifdef DEBUG printf("label x: %d, label y :%d\n", G[x], G[y]); #endif G[x] = G[y]; /* parcours des aretes incidente à x */ for(i = 0; i < 6; i++){ v = incidente3d(x,i,rs,N,ps); if((v != -1) && (!IsSet(v, TRUE))){ /* si v n'est pas dans L */ #ifdef DEBUG printf("aretes incidentes F[%d] %d\n", v, F[v]); #endif x_1 = Sommetx3d(v,N,rs,ps); y_1 = Sommety3d(v,N,rs,ps); #ifdef DEBUG printf("extremites de v (%d), incidente à u (%d,%d);(%d,%d) \n",v, x_1%rs, x_1/rs, y_1%rs, y_1/rs); #endif if((mcmin(G[x_1],G[y_1]) == 0) && (mcmax(G[x_1],G[y_1]) > 0)){ /* v est une growing edge */ mcrbt_RbtInsert(&L, (TypRbtKey)F[v], v); Set(v,TRUE); } } } } UnSet(u,TRUE); } writeimage(marqueurs,"./toto1"); for(u = 0; u < N_t; u++) if( ( (u < N) && (u%rs < rs-1)) || ((u >= N) && (u < 2*N) && ( (u%ps) < (ps-rs))) || ((u >= 2*N) && (((u- (2*N))/ps) < (ds-1)))){ if(G[Sommetx3d(u,N,rs,ps)] != G[Sommety3d(u,N,rs,ps)]) F[u] = 255; else F[u] = 0; } /* Terminer indicateur + R&B tree ... */ IndicsTermine(); mcrbt_RbtTermine(L); return 1; }
//-----------------------------------------------------------------------------------------------------------------------// // main //-----------------------------------------------------------------------------------------------------------------------// int main(int argc, char * argv[]) { int rc=0; int rank=0; #ifdef MPI int comsize; // init MPI MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &comsize); MPI_Comm_rank(MPI_COMM_WORLD, &rank); fprintf(stderr,"rank=%d\n", rank); #ifdef BGQ install_signal_handler(); #endif #endif args = parseargs(argc, argv); // init, initcamera, initvolattrs if ((rc=init(args, rank) != 0)) { fprintf(stderr, "initialization failed: %d\n", rc); return 0; }; //---------------------------- Platform Specific Display and Interaction ----------------------------------------// #if LOCAL resettransforms(); mystate.alpha=0.25f; glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(WINDOWWIDTH, WINDOWHEIGHT); glutCreateWindow("iVR"); glutReshapeFunc(reshape); glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutMouseFunc(mousebutton); glutMotionFunc(mousemotion); // glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glDisable(GL_DEPTH_TEST); glutMainLoop(); #elif MPI // BEGIN MPI CODE #ifdef REMOTE // START OF REMOTE RENDERING HANDSHAKE // connect to relay server if (rank == 0) { sockfd = initconnection(HOSTNAME, PORT); if (sockfd == -1) { fprintf(stderr,"remote connection failed, sockfd=%d\n",sockfd); freeall(); exit(0); } fprintf(stderr,"relay connection succeeded\n"); } PRINTDEBUG("%3d: \n", rank); boolean_t connected = TRUE; int ctr = 0; while (connected) { // main loop when steering fprintf(stderr,"%3d: before steering control\n", rank); if (rank == 0) { rc = recvstate(sockfd, &mystate); fprintf(stderr,"bytes recvd=%d\n", rc); if (mystate.finish) connected = 0;; winwidth = mystate.winwidth; winheight=mystate.winheight; } // end if rank == 0 for remote visualization // wait until we've completed the handshake with steering client before proceeding; MPI_Barrier(MPI_COMM_WORLD); MPI_Bcast(&connected, 1, MPI_INT, 0, MPI_COMM_WORLD); if (!connected) break; MPI_Bcast((float *)&winwidth, 1, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast((float *)&winheight, 1, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast(&mystate.alpha, 1, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast(mystate.newconst, 6, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast(mystate.mvm, 16, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast(mystate.pm, 16, MPI_FLOAT, 0, MPI_COMM_WORLD); MPI_Bcast(mystate.vv, 4, MPI_FLOAT, 0, MPI_COMM_WORLD); #endif float planeconst[6] = {pzero[0], pzero[1], pzero[2], pzero[3], pzero[4], pzero[5]}; setviewport(&viewport, 0, 0, winwidth, winheight); setplaneconst(planeconst, mystate.newconst); setmvm(mvm, mystate.mvm); setpm(pm, mystate.pm); setfrustum(&viewvolume, mystate.vv); updatevolbbox(); initcolbufs(rank); // create and display the image unsigned long long lstart, lstop; for (int i=0; i<1; i++) { TIME(RENDER, lstart); createlocalimage(rank); // can't composite until all ranks have completed local image generation MPI_Barrier(MPI_COMM_WORLD); compositelocalimage(); TIME(RENDER, lstop); PERFORMANCE(lstart, lstop, framenum, elapsed, avg); } // wait until all ranks exit composite step before writing image MPI_Barrier(MPI_COMM_WORLD); writeimage(ctr++); #ifdef REMOTE } // end while remote loop if (rank == 0) disconnect(sockfd); #endif // END OF REMOTE CLIENT HANDSHAKE fprintf(stderr,"%3d: finished\n", rank); MPI_Barrier(MPI_COMM_WORLD); MPI_Finalize(); #endif // clean up freeall(); exit(0); }