////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////// #include #include #include #include void solder_points(point_3d *p, point_3d a, point_3d b); void insert_coordinates(point_3d *p, double x, double y, double z); void copy_coordinates_point(point_3d *p, point_3d c); double compare_images(image *img1, image *img2, image *masc); void create_cube_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in); void create_volvox_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in); void create_bezier_elegans_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in); void create_bezier_paramecium_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in); void update_set_of_candidates_cube(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale); void update_set_of_candidates_volvox(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale); void update_set_of_candidates_elegans(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale); //Cria registro de descrição do modelo: model *get_model(int model_num) { model *mod = malloc(sizeof(model)); switch(model_num) { case CUBE: mod->choose_init_ranges = &choose_init_ranges_CUBE; mod->put_ranges = &put_ranges_CUBE; mod->get_ranges = &get_ranges_CUBE; break; case VOLVOX: mod->choose_init_ranges = &choose_init_ranges_VOLVOX; mod->put_ranges = &put_ranges_VOLVOX; mod->get_ranges = &get_ranges_VOLVOX; break; case ELEGANS: mod->choose_init_ranges = &choose_init_ranges_ELEGANS; mod->put_ranges = &put_ranges_ELEGANS; mod->get_ranges = &get_ranges_ELEGANS; break; case PARAMECIUM: mod->choose_init_ranges = &choose_init_ranges_PARAMECIUM; mod->put_ranges = &put_ranges_PARAMECIUM; mod->get_ranges = &get_ranges_PARAMECIUM; break; default: affirm(FALSE, "invalid model number"); } } void choose_initial_param_ranges(model *mod, int NX, int NY, interval_t range[]) { mod->choose_init_ranges(mod, NX, NY, param); } void choose_init_ranges_CUBE(model *mod, int NX, int NY, interval_t range[]) { ranges_CUBE p; p->rot_x = (interval_t){{ -M_PI/4, +M_PI/4 }}; //rotação em torno de X. p->rot_y = (interval_t){{ -M_PI/4, +M_PI/4 }}; //rotação em torno de Y. p->rot_z = (interval_t){{ -M_PI/4, +M_PI/4 }}; //rotação em torno de Z. int Nmin = (NX < NY ? NX : NY); p->scale = (interval_t){{ 0.25*Nmin, 0.50*Nmin }}; //raio do cubo. mod->put_ranges(mod, &p, range); range[0] = (interval_t){{ 0, NX }}; //translação em X range[1] = (interval_t){{ 0, NY }}; //translação em Y } void put_params_CUBE(struct model_ *mod, void *vp, double param[]) { params_CUBE *p = (params_CUBE)vp; param[2] = p->rot_x; param[3] = p->rot_y; param[4] = p->rot_z; param[5] = p->scale; int i; for (i=6; i < MAX_PARAMS; i++) { param[i] = (double){{ 0,0 }}; } } void get_params_CUBE(struct model_ *mod, void *vp, double param[]) { params_CUBE *p = (params_CUBE)vp; p->rot_x = param[2]; p->rot_y = param[3]; p->rot_z = param[4]; p->scale = param[5]; } void put_ranges_CUBE(struct model_ *mod, void *vp, interval_t range[]) { ranges_CUBE *p = (ranges_CUBE)vp; range[2] = p->rot_x; range[3] = p->rot_y; range[4] = p->rot_z; range[5] = p->scale; int i; for (i=6; i < MAX_PARAMS; i++) { range[i] = (interval_t){{ 0,0 }}; } } void get_ranges_CUBE(struct model_ *mod, void *vp, interval_t range[]) { ranges_CUBE *p = (ranges_CUBE)vp; p->rot_x = range[2]; p->rot_y = range[3]; p->rot_z = range[4]; p->scale = range[5]; } /////////////////////////////////////////////////////////// // calcula a media para os pontos de solda void solder_points(point_3d *p, point_3d a, point_3d b) { p->x = (a.x + b.x)/2.0; p->y = (a.y + b.y)/2.0; p->z = (a.z + b.z)/2.0; return; } /////////////////////////////////////////////////////////// // insere as coordenadas em um ponto void insert_coordinates(point_3d *p, double x, double y, double z) { p->x = x; p->y = y; p->z = z; return; } /////////////////////////////////////////////////////////// // rotaciona um vetor tridimensional void copy_coordinates_point(point_3d *p, point_3d c) { p->x = c.x; p->y = c.y; p->y = c.z; return; } /////////////////////////////////////////////////////////// // rotaciona um vetor bidimensional void rotation_vector_2d(double x, double y, double r, double angle, double *xn, double *yn) { if(angle == 0.0) { *xn = x; *yn = y; } else { *xn = -(r+y)*sin(angle/3); *yn = (r+y)*cos(angle/3) - r; } return; } /////////////////////////////////////////////////////////// // posiciona os pontos do retalho segundo os parametro a e b de inclinacao void modification_vector_2d(double x, double y, double ini, double fim, double a, double b, double *xn, double *yn) { double nx; double b1,b2; //normaliza o parametro x nx = (x-ini)/(fim - ini); b1 = 3.0*nx*pow((1.0-nx),2.0); b2 = 3.0*pow(nx,2.0)*(1.0-nx); *xn = x; *yn = y + a*b1 - b*b2; } ////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////// double compare_images(image *img1, image *img2, image *masc) { int x,y; double sum = 0.0; float (*p1) = NULL, (*p2) = NULL; int count = 1; if(/*img1->sz[CHANELL] != img2->sz[CHANELL] ||*/ img1->sz[X] != img2->sz[X] || img1->sz[Y] != img2->sz[Y]) { printf("\n ERRO - Imagens com dimensoes diferentes - comp_imgs(%d,%d) - CMPI.C",(int)img1->sz[Y],(int)img2->sz[Y]); exit(1); } for(x = 0; x < masc->sz[X]; x++) { for(y = 0; y < masc->sz[Y]; y++) { if((float_image_get_sample(masc,0,x,y)) != 1.0) { count++; p1 = float_image_get_sample_address(img1,0,x,y); p2 = float_image_get_sample_address(img2,0,x,y); if(((*p1) > 0.01 && (*p2) > 0.01) ) sum += 0.0; else sum += 1.0; } } } if(count <= 1) return(INF); return((sum/(count))); } ////////////////////////////////////////////////////////////// //funcao que aloca a estrutura set_of_candidates void allocate_set_of_candidates(set_of_candidates *candidates, int num_candidates) { candidates->candidates = malloc(sizeof(candidate)*num_candidates+1); candidates->num_candidates = num_candidates; if(candidates->candidates == NULL) { printf("\n ERRO - Alocacao de candidatos - allocate_set_of_candidates(%d) - AJST.C \n",num_candidates); } return; } ////////////////////////////////////////////////////////////// //funcao que desaloca a estrutura set_of_candidates void deallocate_set_of_candidates(set_of_candidates *candidates) { candidates->num_candidates = 0; free(candidates->candidates); candidates->candidates = NULL; return; } ////////////////////////////////////////////////////////////// //funcao que retorna o maximo entre 3 numeros int max(int a, int b, int c) { if(a >= b && a>= c) return (a); else if(b >=a && b >= c) return(b); else return(c); } ////////////////////////////////////////////////////////////// //funcao que cria uma lista inicial de candidatos para ser usada //na escala mais grosseira void create_initial_set_of_candidates(set_of_candidates *candidates, int scale, int model, int num_variation) { int tx,ty; //translacao long unsigned int index = 0; //indice double d_trans = 0.1*pow(2.0,scale); //aloca o conjunto inicial de candidadtos allocate_set_of_candidates(candidates,(long int)pow((double)num_variation,2.0)); printf("\n %ld Candidatos alocados na escala inicial [%d x %d]",(long int)pow((double)num_variation,2.0),(int)pow(2.0,scale),(int)pow(2.0,scale)); printf("\n Passo de translacao %.3lf ",d_trans); printf("\n "); //cria um conjunto de parametros iniciais for(tx = 0; tx < num_variation; tx++) { for(ty = 0; ty < num_variation; ty++) { double mult_tx = 0.0, mult_ty = 0.0; if(model == CUBE) strcpy(candidates->candidates[index].model_name,"cube"); else if(model == VOLVOX) strcpy(candidates->candidates[index].model_name,"c_volvox"); else if(model == ELEGANS) strcpy(candidates->candidates[index].model_name,"elegans"); else strcpy(candidates->candidates[index].model_name,"paramecium"); if(tx > (num_variation/2)) mult_tx = -1.0 * (tx - num_variation/2 + 0.0) ; else mult_tx = 1.0 * (tx + 0.0); if(ty > (num_variation/2)) mult_ty = -1.0 * (ty - num_variation/2 + 0.0); else mult_ty = 1.0 * (ty + 0.0); candidates->candidates[index].parameters.trans_x = d_trans*mult_tx; candidates->candidates[index].parameters.trans_y = d_trans*mult_ty; candidates->candidates[index].parameters.rot_x = 0.0; candidates->candidates[index].parameters.rot_y = 0.0; candidates->candidates[index].parameters.rot_z = 0.0; if(model == CUBE) { //para o tamanho do lado ser equivalente a 32 p candidates->candidates[index].parameters.scale = log2(4.34); candidates->candidates[index].range.trans = (0.1*pow(2.0,scale+1)); candidates->candidates[index].range.scale = (0.0); candidates->candidates[index].range.rot = (0.0); candidates->candidates[index].steps.trans = 0.1*pow(2.0,scale); candidates->candidates[index].steps.rot = 0.0; //rever...pq nao lembro da onde veio esse valor candidates->candidates[index].steps.scale = 2.0*log2(0.1*pow(2.0,scale-2.0*candidates->candidates[index].parameters.scale )+ 1); } else { if(model == VOLVOX) { candidates->candidates[index].parameters.scale = 2.5; int spheres; candidates->candidates[index].parameters.num_spheres = 1; for(spheres = 0; spheres < candidates->candidates[index].parameters.num_spheres; spheres++) { candidates->candidates[index].parameters.tx[spheres] = 0.0; candidates->candidates[index].parameters.ty[spheres] = 0.0; candidates->candidates[index].parameters.scale_sphere[spheres] = 0.75; } candidates->candidates[index].range.trans = (0.1*pow(2.0,scale+1)); candidates->candidates[index].range.scale = (0.1*pow(2.0,scale+1)); candidates->candidates[index].steps.trans = 0.1*pow(2.0,scale); candidates->candidates[index].steps.scale = 0.1*pow(2.0,scale); } else { if(model == ELEGANS) { candidates->candidates[index].parameters.height = 0.2; candidates->candidates[index].parameters.radius = 0.75; candidates->candidates[index].parameters.alpha = 0; candidates->candidates[index].parameters.beta = 0; candidates->candidates[index].steps.trans = (0.1*pow(2.0,scale+1)); candidates->candidates[index].steps.radius = (0.1*pow(2.0,scale+1))/8.0; candidates->candidates[index].steps.height = (0.1*pow(2.0,scale+1))/4.0; candidates->candidates[index].steps.angle = 1.57; } } } index++; } } } ////////////////////////////////////////////////////////////// //funcao que cria uma lista inicial de candidatos para ser usada //na escala mais grosseira void create_images_of_candidates(set_of_candidates *candidates, float_image_t *image_in, int scale, int dim_img_in, int num_scale, int save) { int i; scene scene; filme pelicula; float_image_t *image = NULL; float_image_t *mask = NULL; float_image_t *edge = NULL; char name_img[50]; int num_rays = 1; double noise = 0; if(save == TRUE) num_rays = 1; for(i = 0; i < candidates->num_candidates; i++) { if(strcmp(candidates->candidates[i].model_name,"elegans") == 0) { create_bezier_elegans_masc_model(&scene,&pelicula,&(candidates->candidates[i]),scale,dim_img_in); noise = 0.1; } else if(strcmp(candidates->candidates[i].model_name,"cube") == 0) { create_cube_masc_model(&scene,&pelicula,&(candidates->candidates[i]),scale,dim_img_in); noise = 0.1; } else if(strcmp(candidates->candidates[i].model_name,"c_volvox") == 0) { create_volvox_masc_model(&scene,&pelicula,&(candidates->candidates[i]),scale,dim_img_in); noise = 0.1; } else { if(strcmp(candidates->candidates[i].model_name,"paramecium") == 0) { noise = 0.1; //create_bezier_paramecium_masc_model(&scene,&pelicula,candidates,i,scale,dim_img_in); } else { printf(" \n ERRO - Modelo desconhecido - AJST.C - create_images_of_candidates(%d %s)\n" ,i,candidates->candidates[i].model_name); exit(1); } } ray_tracing(&scene,image,&pelicula,num_rays); deallocate_scene(&scene); image = filme_to_image(&pelicula); mask = create_mask(image); edge = float_image_new(1,pelicula.n_c,pelicula.n_l); //if(save != TRUE) // deallocate_filme(&pelicula); float_image_gradient_sqr_relative_2(image,0,noise,edge,0); candidates->candidates[i].quality = compare_images(image_in,edge,image); if(save == TRUE) { sprintf(name_img,"img/%s_scale%d_%02d_edge.pgm",candidates->candidates[i].model_name,scale,i); ex_write_image(NULL,name_img,edge); sprintf(name_img,"img/%s_scale%d_%02d.pgm",candidates->candidates[i].model_name,scale,i); ex_write_image(NULL,name_img,image); } float_image_free(mask); float_image_free(edge); float_image_free(image); } } /////////////////////////////////////////////////////////////////////////////////////////// // funcao que cria uma lista de step para cada uma das escalas, tendo como resultado um // conjunto de imagens void create_candidate_image_sorting(set_of_candidates *best, candidate *c, int ind, float_image_t *image_in, int scale, int dim_img_in, int num_scale, int save) { scene scene; filme pelicula; float_image_t *image = NULL; float_image_t *mask = NULL; float_image_t *edge = NULL; char name_img[50]; int num_rays = 1; double noise = 0; if(save == TRUE) num_rays = 1; if(strcmp(c->model_name,"elegans") == 0) { create_bezier_elegans_masc_model(&scene,&pelicula,c,scale,dim_img_in); noise = 0.1; } else if(strcmp(c->model_name,"cube") == 0) { create_cube_masc_model(&scene,&pelicula,c,scale,dim_img_in); noise = 0.1; } else if(strcmp(c->model_name,"c_volvox") == 0) { create_volvox_masc_model(&scene,&pelicula,c,scale,dim_img_in); noise = 0.1; } else { if(strcmp(c->model_name,"paramecium") == 0) { noise = 0.1; //create_bezier_paramecium_masc_model(&scene,&pelicula,candidates,i,scale,dim_img_in); } else { printf(" \n ERRO - Modelo desconhecido - AJST.C - create_images_of_candidates(%s %d)\n" ,c->model_name,ind); exit(1); } } ray_tracing(&scene,image,&pelicula,num_rays); deallocate_scene(&scene); image = filme_to_image(&pelicula); mask = create_mask(image); edge = float_image_new(1,pelicula.n_c,pelicula.n_l); if(save != TRUE) deallocate_filme(&pelicula); float_image_gradient_sqr_relative_2(image,0,noise,edge,0); c->quality = compare_images(image_in,edge,mask); insert_sorting(best,c); if(save == TRUE) { sprintf(name_img,"img/%s_scale%d_%02d_edge.pgm",c->model_name,scale,ind); ex_write_image(NULL,name_img,edge); //sprintf(name_img,"img/%s_scale%d_%02d.pgm",candidates->candidates[i].model_name,scale,i); //ex_write_image(NULL,name_img,image); } float_image_free(mask); float_image_free(edge); float_image_free(image); } ////////////////////////////////////////////////////////////// // funcao responsavel pelo preenchimento dos parametros do // modelo do cubo void create_cube_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in) { int i = 0; double dim_img = 0.0; double dim = 0.0; allocate_scene_objects(scene,0,1,0,0); scene->cubes[0].x = c->parameters.trans_x; scene->cubes[0].y = c->parameters.trans_y; scene->cubes[0].z = 0.0; //calcula o tamanho das arestas do cubo baseado no log da diagonal double diagonal = pow(2.0,c->parameters.scale); double edge = sqrt((diagonal*diagonal)/3.0); scene->cubes[0].d = edge; scene->cubes[0].surface.transp.r = 0.0; scene->cubes[0].surface.transp.g = 0.0; scene->cubes[0].surface.transp.b = 0.0; scene->cubes[0].surface.dif.r = 0.5; scene->cubes[0].surface.dif.g = 0.5; scene->cubes[0].surface.dif.b = 0.5; scene->cubes[0].surface.espec.r = 0.0; scene->cubes[0].surface.espec.g = 0.0; scene->cubes[0].surface.espec.b = 0.0; scene->cubes[0].rot_x = c->parameters.rot_x; scene->cubes[0].rot_y = c->parameters.rot_y; scene->cubes[0].rot_z = c->parameters.rot_z; //atributos da luz scene->num_lights = 1; allocate_scene_light(scene,scene->num_lights); for( i = 0; i < scene->num_lights; i++) { scene->l[i].position.x = 500.01; scene->l[i].position.y = 500.01; scene->l[i].position.z = 10000; scene->l[i].intensity = 0.9; } //position do olho/observador scene->observer.x = 0.1; scene->observer.y = 0.1; scene->observer.z = 1000000.0; //coordenadas do ponto de interesse scene->look_at.x = 0.01; scene->look_at.y = 0.01; scene->look_at.z = 0.01; dim_img = (dim_img_in)/((int)(pow(2.0,(double)scale))); matrix_transformation(scene,CUBE,0); dim = 0.1*(pow(2.0,scale)); allocate_filme(pelicula,(int)dim_img,(int)dim_img,dim,999990.0); return; } ////////////////////////////////////////////////////////////// // funcao responsavel pelo preenchimento dos parametros do // modelo do volvox void create_volvox_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in) { int spheres = 0; int i = 0; double dim_img = 0.0; double dim = 0.0; allocate_scene_objects(scene,c->parameters.num_spheres+1,0,0,0); scene->spheres[0].x = c->parameters.trans_x; scene->spheres[0].y = c->parameters.trans_y; scene->spheres[0].z = 0.0; scene->spheres[0].radius = c->parameters.scale; scene->spheres[0].surface.transp.r = 0.5; scene->spheres[0].surface.transp.g = 0.5; scene->spheres[0].surface.transp.b = 0.5; scene->spheres[0].surface.dif.r = 0.0; scene->spheres[0].surface.dif.g = 0.0; scene->spheres[0].surface.dif.b = 0.0; scene->spheres[0].surface.espec.r = 0.0; scene->spheres[0].surface.espec.g = 0.0; scene->spheres[0].surface.espec.b = 0.0; scene->spheres[0].rot_x = 0.0; scene->spheres[0].rot_y = 0.0; scene->spheres[0].rot_z = 0.0; for(spheres = 0; spheres < c->parameters.num_spheres; spheres++) { scene->spheres[spheres+1].x = c->parameters.trans_x + c->parameters.tx[spheres]; scene->spheres[spheres+1].y = c->parameters.trans_y + c->parameters.ty[spheres]; scene->spheres[spheres+1].z = 0.0; scene->spheres[spheres+1].radius = c->parameters.scale_sphere[spheres]; scene->spheres[spheres+1].surface.transp.r = 0.25; scene->spheres[spheres+1].surface.transp.g = 0.25; scene->spheres[spheres+1].surface.transp.b = 0.25; scene->spheres[spheres+1].surface.dif.r = 0.0; scene->spheres[spheres+1].surface.dif.g = 0.0; scene->spheres[spheres+1].surface.dif.b = 0.0; scene->spheres[spheres+1].surface.espec.r = 0.0; scene->spheres[spheres+1].surface.espec.g = 0.0; scene->spheres[spheres+1].surface.espec.b = 0.0; scene->spheres[spheres+1].rot_x = 0.0; scene->spheres[spheres+1].rot_y = 0.0; scene->spheres[spheres+1].rot_z = 0.0; } //atributos da luz scene->num_lights = 1; allocate_scene_light(scene,scene->num_lights); for( i = 0; i < scene->num_lights; i++) { scene->l[i].position.x = 0.01; scene->l[i].position.y = 0.01; scene->l[i].position.z = 100; scene->l[i].intensity = 0.9; } //position do olho/observador scene->observer.x = 0.1; scene->observer.y = 0.1; scene->observer.z = 100; //coordenadas do ponto de interesse scene->look_at.x = 0.01; scene->look_at.y = 0.01; scene->look_at.z = 0.01; dim_img = (dim_img_in)/((int)(pow(2.0,(double)scale))); //printf("\n * %lf * \n",dim_img); dim = 0.1*(pow(2.0,(double)scale)); allocate_filme(pelicula,(int)dim_img,(int)dim_img,dim,100); return; } ////////////////////////////////////////////////////////////// // funcao responsavel pelo preenchimento dos parametros do // modelo do elegans por meio de bezier void create_bezier_elegans_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in) { int i; double dim_img = 0.0; double dim = 0.0; double x = c->parameters.radius, y = c->parameters.height, z = 0.2; //pontos de liberdade da grade point_3d p[14]; allocate_scene_objects(scene,0,0,0,6); //insere os atributos da superficie for(i = 0; i < 6; i++) { scene->beziers[i].surface.transp.r = 0.5; scene->beziers[i].surface.transp.g = 0.5; scene->beziers[i].surface.transp.b = 0.5; scene->beziers[i].surface.dif.r = 0.0; scene->beziers[i].surface.dif.g = 0.0; scene->beziers[i].surface.dif.b = 0.0; scene->beziers[i].surface.espec.r = 0.0; scene->beziers[i].surface.espec.g = 0.0; scene->beziers[i].surface.espec.b = 0.0; scene->beziers[i].rot_x = 0.0; scene->beziers[i].rot_y = 0.0; scene->beziers[i].rot_z = 0.0; } //////////////////////////////////////////////////////////////////////////////////////// // pontos de liberdades double a = -c->parameters.alpha, b = c->parameters.beta; //rotacao dos pontos de controle do meio modification_vector_2d(-5.0*x,2.0*y,-6.0*x,6.0*x,a,b,&p[0].x,&p[0].y); modification_vector_2d(-3.0*x,2.0*y,-6.0*x,6.0*x,a,b,&p[1].x,&p[1].y); modification_vector_2d(-5.0*x,-2.0*y,-6.0*x,6.0*x,a,b,&p[2].x,&p[2].y); modification_vector_2d(-3.0*x,-2.0*y,-6.0*x,6.0*x,a,b,&p[3].x,&p[3].y); modification_vector_2d(-1.0*x,2.0*y,-6.0*x,6.0*x,a,b,&p[4].x,&p[4].y); modification_vector_2d(1.0*x, 2.0*y,-6.0*x,6.0*x,a,b,&p[5].x,&p[5].y); modification_vector_2d(-1.0*x,-2.0*y,-6.0*x,6.0*x,a,b,&p[6].x,&p[6].y); modification_vector_2d(1.0*x, -2.0*y,-6.0*x,6.0*x,a,b,&p[7].x,&p[7].y); modification_vector_2d(3.0*x,2.0*y,-6.0*x,6.0*x,a,b,&p[8].x, &p[8].y); modification_vector_2d(5.0*x,2.0*y,-6.0*x,6.0*x,a,b,&p[9].x, &p[9].y); modification_vector_2d(3.0*x,-2.0*y,-6.0*x,6.0*x,a,b,&p[10].x,&p[10].y); modification_vector_2d(5.0*x,-2.0*y,-6.0*x,6.0*x,a,b,&p[11].x,&p[11].y); //rotacao dos bicos modification_vector_2d(-6.0*x,3.0*y,-6.0*x,6.0*x,a,b,&p[12].x,&p[12].y); modification_vector_2d( 6.0*x,3.0*y,-6.0*x,6.0*x,a,b,&p[13].x,&p[13].y); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////// PONTOS LIBERDADE PARTE SUPERIOR ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////// //pontos de liberdade do retalho 0 insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[0].x,c->parameters.trans_y+p[0].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[1].x,c->parameters.trans_y+p[1].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[2].x,c->parameters.trans_y+p[2].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[3].x,c->parameters.trans_y+p[3].y,0.0); //pontos de liberdade do retalho 1 insert_coordinates(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[4].x,c->parameters.trans_y+p[4].y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[5].x,c->parameters.trans_y+p[5].y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[6].x,c->parameters.trans_y+p[6].y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[7].x,c->parameters.trans_y+p[7].y,0.0); //pontos de liberdade do retalho 2 insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[8].x, c->parameters.trans_y+p[8].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[9].x, c->parameters.trans_y+p[9].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[10].x,c->parameters.trans_y+p[10].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[11].x,c->parameters.trans_y+p[11].y,0.0); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////// PONTOS LIBERDADE PARTE INFERIOR ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////// //pontos de liberdade do retalho 0 insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[0].x,c->parameters.trans_y+p[0].y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[1].x,c->parameters.trans_y+p[1].y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[2].x,c->parameters.trans_y+p[2].y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[3].x,c->parameters.trans_y+p[3].y,-2.0*z); //pontos de liberdade do retalho 2 insert_coordinates(&(scene->beziers[4].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[4].x,c->parameters.trans_y+p[4].y,-2.0*z); insert_coordinates(&(scene->beziers[4].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[5].x,c->parameters.trans_y+p[5].y,-2.0*z); insert_coordinates(&(scene->beziers[4].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[6].x,c->parameters.trans_y+p[6].y,-2.0*z); insert_coordinates(&(scene->beziers[4].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[7].x,c->parameters.trans_y+p[7].y,-2.0*z); //pontos de liberdade do retalho 3 insert_coordinates(&(scene->beziers[5].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p[8].x,c->parameters.trans_y+p[8].y,-2.0*z); insert_coordinates(&(scene->beziers[5].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p[9].x,c->parameters.trans_y+p[9].y,-2.0*z); insert_coordinates(&(scene->beziers[5].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p[10].x,c->parameters.trans_y+p[10].y,-2.0*z); insert_coordinates(&(scene->beziers[5].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p[11].x,c->parameters.trans_y+p[11].y,-2.0*z); /////////////////////////////////////////////////////////////////// ///////////////// insere os bicos esquerda insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+0]),c->parameters.trans_x+p[12].x,c->parameters.trans_y+p[12].y,0.0); /////////////////////////////////////////////////////////////////// ///////////////// insere os bicos direita insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[5].bezier.control_points[1*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[5].bezier.control_points[2*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[5].bezier.control_points[0*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); insert_coordinates(&(scene->beziers[5].bezier.control_points[3*DIM_GRID+3]),c->parameters.trans_x+p[13].x,c->parameters.trans_y+p[13].y,0.0); ////////////////////////////////////////////////////////////////////// ////////////////////// //retalhos superiores// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 0 //pontos de solda simples de baixo solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+1]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+2]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+3]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[1].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+3]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[1].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+1]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+2]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 1 //pontos de solda simples de baixo solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+1]),scene->beziers[1].bezier.control_points[1*DIM_GRID+1],scene->beziers[4].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+2]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[4].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+0]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[1].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+0]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[1].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+3]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[2].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+3]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[2].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+1]),scene->beziers[1].bezier.control_points[2*DIM_GRID+1],scene->beziers[4].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+2]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[4].bezier.control_points[2*DIM_GRID+2]); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 2 //pontos de solda simples de baixo solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+1]),scene->beziers[2].bezier.control_points[1*DIM_GRID+1],scene->beziers[5].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+2]),scene->beziers[2].bezier.control_points[1*DIM_GRID+2],scene->beziers[5].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+0]),scene->beziers[2].bezier.control_points[1*DIM_GRID+1],scene->beziers[1].bezier.control_points[1*DIM_GRID+2]); solder_points(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+0]),scene->beziers[2].bezier.control_points[2*DIM_GRID+1],scene->beziers[1].bezier.control_points[2*DIM_GRID+2]); //pontos de solda simples de cima solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+1]),scene->beziers[2].bezier.control_points[2*DIM_GRID+1],scene->beziers[5].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+2]),scene->beziers[2].bezier.control_points[2*DIM_GRID+2],scene->beziers[5].bezier.control_points[2*DIM_GRID+2]); ////////////////////// //retalhos inferiores// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 3 //pontos de solda simples de baixo solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+1]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+2]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+3]),scene->beziers[3].bezier.control_points[1*DIM_GRID+2],scene->beziers[4].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+3]),scene->beziers[3].bezier.control_points[2*DIM_GRID+2],scene->beziers[4].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+1]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+2]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 4 //pontos de solda simples de baixo solder_points(&(scene->beziers[4].bezier.control_points[0*DIM_GRID+1]),scene->beziers[1].bezier.control_points[1*DIM_GRID+1],scene->beziers[4].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[0*DIM_GRID+2]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[4].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[4].bezier.control_points[1*DIM_GRID+0]),scene->beziers[3].bezier.control_points[1*DIM_GRID+2],scene->beziers[4].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[2*DIM_GRID+0]),scene->beziers[3].bezier.control_points[2*DIM_GRID+2],scene->beziers[4].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[1*DIM_GRID+3]),scene->beziers[4].bezier.control_points[1*DIM_GRID+2],scene->beziers[5].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[2*DIM_GRID+3]),scene->beziers[4].bezier.control_points[2*DIM_GRID+2],scene->beziers[5].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[4].bezier.control_points[3*DIM_GRID+1]),scene->beziers[1].bezier.control_points[2*DIM_GRID+1],scene->beziers[4].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[3*DIM_GRID+2]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[4].bezier.control_points[2*DIM_GRID+2]); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 5 //pontos de solda simples de baixo solder_points(&(scene->beziers[5].bezier.control_points[0*DIM_GRID+1]),scene->beziers[2].bezier.control_points[1*DIM_GRID+1],scene->beziers[5].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[5].bezier.control_points[0*DIM_GRID+2]),scene->beziers[2].bezier.control_points[1*DIM_GRID+2],scene->beziers[5].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[5].bezier.control_points[1*DIM_GRID+0]),scene->beziers[5].bezier.control_points[1*DIM_GRID+1],scene->beziers[4].bezier.control_points[1*DIM_GRID+2]); solder_points(&(scene->beziers[5].bezier.control_points[2*DIM_GRID+0]),scene->beziers[5].bezier.control_points[2*DIM_GRID+1],scene->beziers[4].bezier.control_points[2*DIM_GRID+2]); //pontos de solda simples de cima solder_points(&(scene->beziers[5].bezier.control_points[3*DIM_GRID+1]),scene->beziers[2].bezier.control_points[2*DIM_GRID+1],scene->beziers[5].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[5].bezier.control_points[3*DIM_GRID+2]),scene->beziers[2].bezier.control_points[2*DIM_GRID+2],scene->beziers[5].bezier.control_points[2*DIM_GRID+2]); ///////////////////soldas finais solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+3]),scene->beziers[0].bezier.control_points[0*DIM_GRID+2],scene->beziers[1].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+3]),scene->beziers[0].bezier.control_points[3*DIM_GRID+2],scene->beziers[1].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+0]),scene->beziers[0].bezier.control_points[0*DIM_GRID+2],scene->beziers[1].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+0]),scene->beziers[0].bezier.control_points[3*DIM_GRID+2],scene->beziers[1].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+3]),scene->beziers[1].bezier.control_points[0*DIM_GRID+2],scene->beziers[2].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+3]),scene->beziers[1].bezier.control_points[3*DIM_GRID+2],scene->beziers[2].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+0]),scene->beziers[1].bezier.control_points[0*DIM_GRID+2],scene->beziers[2].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+0]),scene->beziers[1].bezier.control_points[3*DIM_GRID+2],scene->beziers[2].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+3]),scene->beziers[3].bezier.control_points[0*DIM_GRID+2],scene->beziers[4].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+3]),scene->beziers[3].bezier.control_points[3*DIM_GRID+2],scene->beziers[4].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[0*DIM_GRID+0]),scene->beziers[3].bezier.control_points[0*DIM_GRID+2],scene->beziers[4].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[3*DIM_GRID+0]),scene->beziers[3].bezier.control_points[3*DIM_GRID+2],scene->beziers[4].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[0*DIM_GRID+3]),scene->beziers[4].bezier.control_points[0*DIM_GRID+2],scene->beziers[5].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[4].bezier.control_points[3*DIM_GRID+3]),scene->beziers[4].bezier.control_points[3*DIM_GRID+2],scene->beziers[5].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[5].bezier.control_points[0*DIM_GRID+0]),scene->beziers[4].bezier.control_points[0*DIM_GRID+2],scene->beziers[5].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[5].bezier.control_points[3*DIM_GRID+0]),scene->beziers[4].bezier.control_points[3*DIM_GRID+2],scene->beziers[5].bezier.control_points[3*DIM_GRID+1]); //atributos da luz scene->num_lights = 1; allocate_scene_light(scene,scene->num_lights); double px,py,pz; px = 0.01; py = 0.01; pz = 200.0; for( i = 0; i < scene->num_lights; i++) { scene->l[i].position.x = px; scene->l[i].position.y = py; scene->l[i].position.z = pz; scene->l[i].intensity = 0.9; } //position do olho/observador scene->observer.x = px; scene->observer.y = py; scene->observer.z = pz; //coordenadas do ponto de interesse scene->look_at.x = 0.0*x; scene->look_at.y = 2.0*y; scene->look_at.z = 0.0; matrix_transformation(scene,BEZIER,0); matrix_transformation(scene,BEZIER,1); matrix_transformation(scene,BEZIER,2); matrix_transformation(scene,BEZIER,3); matrix_transformation(scene,BEZIER,4); matrix_transformation(scene,BEZIER,5); dim_img = ((int)dim_img_in)/((int)(pow(2.0,(double)scale))); dim = 0.1*(pow(2.0,(double)scale)); allocate_filme(pelicula,(int)dim_img,(int)dim_img,dim,200); } ////////////////////////////////////////////////////////////// // funcao responsavel pelo preenchimento dos parametros do // modelo do paramecium por meio de bezier void create_bezier_paramecium_masc_model(scene *scene, filme *pelicula, candidate *c, int scale, int dim_img_in) { int i; double dim_img = 0.0; double dim = 0.0; double fator = c->parameters.scale; double x = c->parameters.height*fator, y = c->parameters.radius*fator, z = 0.1*fator; //pontos de liberdade da grade point_3d p1,p2,p3,p4, p5,p6,p7,p8, p9,p10; allocate_scene_objects(scene,0,0,0,4); //insere os atributos da superficie for(i = 0; i < 4; i++) { scene->beziers[i].surface.transp.r = 0.5; scene->beziers[i].surface.transp.g = 0.5; scene->beziers[i].surface.transp.b = 0.5; scene->beziers[i].surface.dif.r = 0.0; scene->beziers[i].surface.dif.g = 0.0; scene->beziers[i].surface.dif.b = 0.0; scene->beziers[i].surface.espec.r = 0.0; scene->beziers[i].surface.espec.g = 0.0; scene->beziers[i].surface.espec.b = 0.0; scene->beziers[i].rot_x = 0.0; scene->beziers[i].rot_y = 0.0; scene->beziers[i].rot_z = 0.0; } //////////////////////////////////////////////////////////////////////////////////////// // pontos de liberdades //rotacao dos pontos de controle do meio rotation_vector_2d(-4.0*x,5.0*y,1.0,0.0,&p1.x,&p1.y); rotation_vector_2d(-2.0*x,5.5*y,1.0,0.0,&p2.x,&p2.y); rotation_vector_2d(-4.0*x,2.0*y,1.0,0.0,&p3.x,&p3.y); rotation_vector_2d(-2.0*x,1.75*y,1.0,0.0,&p4.x,&p4.y); rotation_vector_2d(2.0*x,4.0*y,1.0,0.0,&p5.x,&p5.y); rotation_vector_2d(4.0*x,4.0*y,1.0,0.0,&p6.x,&p6.y); rotation_vector_2d(2.0*x,2.0*y,1.0,0.0,&p7.x,&p7.y); rotation_vector_2d(4.0*x,2.0*y,1.0,0.0,&p8.x,&p8.y); //rotacao dos bicos rotation_vector_2d(-5.0*x,3.0*y,1.0,0.0,&p9.x,&p9.y); rotation_vector_2d( 5.0*x,3.0*y,1.0,0.0,&p10.x,&p10.y); ////////////////////////////////////////////////////////////////////////////////////////// //pontos de liberdade do retalho 0 insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p1.x,c->parameters.trans_y+p1.y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p2.x,c->parameters.trans_y+p2.y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p3.x,c->parameters.trans_y+p3.y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p4.x,c->parameters.trans_y+p4.y,0.0); //pontos de liberdade do retalho 2 insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p1.x,c->parameters.trans_y+p1.y,-2.0*z); insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p2.x,c->parameters.trans_y+p2.y,-2.0*z); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p3.x,c->parameters.trans_y+p3.y,-2.0*z); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p4.x,c->parameters.trans_y+p4.y,-2.0*z); //pontos de liberdade do retalho 1 insert_coordinates(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p5.x,c->parameters.trans_y+p5.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p6.x,c->parameters.trans_y+p6.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p7.x,c->parameters.trans_y+p7.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p8.x,c->parameters.trans_y+p8.y,0.0); //pontos de liberdade do retalho 3 insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+1]),c->parameters.trans_x+p5.x,c->parameters.trans_y+p5.y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+2]),c->parameters.trans_x+p6.x,c->parameters.trans_y+p6.y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+1]),c->parameters.trans_x+p7.x,c->parameters.trans_y+p7.y,-2.0*z); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+2]),c->parameters.trans_x+p8.x,c->parameters.trans_y+p8.y,-2.0*z); //insere os bicos insert_coordinates(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////soldas do retalho 0 //pontos de solda simples de baixo solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+1]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[2].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+2]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[2].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[0].bezier.control_points[1*DIM_GRID+3]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[1].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[2*DIM_GRID+3]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[1].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+1]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[2].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+2]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[2].bezier.control_points[2*DIM_GRID+2]); //pontos da quina solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+0]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[2].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+0]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[2].bezier.control_points[2*DIM_GRID+1]); ////////////////////////////////////////////////soldas do retalho 1 //pontos de solda simples de baixo solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+1]),scene->beziers[1].bezier.control_points[1*DIM_GRID+1],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+2]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[1].bezier.control_points[1*DIM_GRID+0]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[1].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[2*DIM_GRID+0]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[1].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+1]),scene->beziers[1].bezier.control_points[2*DIM_GRID+1],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+2]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); //pontos da quina solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+3]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+3]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); ////////////////////////////////////////////////soldas do retalho 2 //pontos de solda simples de baixo solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+1]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[2].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+2]),scene->beziers[0].bezier.control_points[1*DIM_GRID+2],scene->beziers[2].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[2].bezier.control_points[1*DIM_GRID+3]),scene->beziers[2].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[2*DIM_GRID+3]),scene->beziers[2].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+1]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[2].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+2]),scene->beziers[0].bezier.control_points[2*DIM_GRID+2],scene->beziers[2].bezier.control_points[2*DIM_GRID+2]); //pontos da quina solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+0]),scene->beziers[0].bezier.control_points[1*DIM_GRID+1],scene->beziers[2].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+0]),scene->beziers[0].bezier.control_points[2*DIM_GRID+1],scene->beziers[2].bezier.control_points[2*DIM_GRID+1]); ////////////////////////////////////////////////soldas do retalho 3 //pontos de solda simples de baixo solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+1]),scene->beziers[1].bezier.control_points[1*DIM_GRID+1],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+2]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); //pontos de solda da juncao da placas no eixo X solder_points(&(scene->beziers[3].bezier.control_points[1*DIM_GRID+0]),scene->beziers[2].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[2*DIM_GRID+0]),scene->beziers[2].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); //pontos de solda simples de cima solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+1]),scene->beziers[1].bezier.control_points[2*DIM_GRID+1],scene->beziers[3].bezier.control_points[2*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+2]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); //pontos da quina solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+3]),scene->beziers[1].bezier.control_points[1*DIM_GRID+2],scene->beziers[3].bezier.control_points[1*DIM_GRID+2]); solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+3]),scene->beziers[1].bezier.control_points[2*DIM_GRID+2],scene->beziers[3].bezier.control_points[2*DIM_GRID+2]); ///////////////////soldas finais solder_points(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+3]),scene->beziers[0].bezier.control_points[0*DIM_GRID+2],scene->beziers[1].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+3]),scene->beziers[0].bezier.control_points[3*DIM_GRID+2],scene->beziers[1].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+0]),scene->beziers[0].bezier.control_points[0*DIM_GRID+2],scene->beziers[1].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+0]),scene->beziers[0].bezier.control_points[3*DIM_GRID+2],scene->beziers[1].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+3]),scene->beziers[2].bezier.control_points[0*DIM_GRID+2],scene->beziers[3].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+3]),scene->beziers[2].bezier.control_points[3*DIM_GRID+2],scene->beziers[3].bezier.control_points[3*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+0]),scene->beziers[2].bezier.control_points[0*DIM_GRID+2],scene->beziers[3].bezier.control_points[0*DIM_GRID+1]); solder_points(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+0]),scene->beziers[2].bezier.control_points[3*DIM_GRID+2],scene->beziers[3].bezier.control_points[3*DIM_GRID+1]); insert_coordinates(&(scene->beziers[0].bezier.control_points[0*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[0].bezier.control_points[3*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[0*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[1].bezier.control_points[3*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[0*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[2].bezier.control_points[3*DIM_GRID+0]),c->parameters.trans_x+p9.x,c->parameters.trans_y+p9.y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[0*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); insert_coordinates(&(scene->beziers[3].bezier.control_points[3*DIM_GRID+3]),c->parameters.trans_x+p10.x,c->parameters.trans_y+p10.y,0.0); //atributos da luz scene->num_lights = 1; allocate_scene_light(scene,scene->num_lights); double px,py,pz; px = 0.0; py = 0.0; pz = 50.0; for( i = 0; i < scene->num_lights; i++) { scene->l[i].position.x = px; scene->l[i].position.y = py; scene->l[i].position.z = pz; scene->l[i].intensity = 0.9; } //position do olho/observador scene->observer.x = px; scene->observer.y = py; scene->observer.z = pz; //coordenadas do ponto de interesse scene->look_at.x = 0.0; scene->look_at.y = 3.5*y; scene->look_at.z = 0.0; matrix_transformation(scene,BEZIER,0); matrix_transformation(scene,BEZIER,1); matrix_transformation(scene,BEZIER,2); matrix_transformation(scene,BEZIER,3); dim_img = (dim_img_in)/((int)(pow(2.0,(double)scale))); dim = 0.1*(pow(2.0,scale)); //printf("\n * DIM_IMG: %lf DIM_PIXEL: %lf * \n",dim_img,dim); allocate_filme(pelicula,(int)dim_img,(int)dim_img,dim,99999999970); ; } ////////////////////////////////////////////////////////////// // funcao que candidato a para o b void copy_candidate(candidate *a, candidate *b) { //joga o index2 no index1 strcpy(b->model_name,a->model_name); b->parameters = a->parameters; b->parameters.trans_x = a->parameters.trans_x; b->parameters.trans_y = a->parameters.trans_y; b->parameters.rot_x = a->parameters.rot_x; b->parameters.rot_y = a->parameters.rot_y; b->parameters.rot_z = a->parameters.rot_z; b->parameters.scale = a->parameters.scale; b->quality = a->quality; b->parameters.height = a->parameters.height; b->parameters.radius = a->parameters.radius; b->parameters.alpha = a->parameters.alpha; b->parameters.beta = a->parameters.beta; b->parameters.num_spheres = a->parameters.num_spheres; b->range.trans = a->range.trans; b->range.scale = a->range.scale; b->range.rot = a->range.rot; b->range.radius = a->range.radius; b->range.height = a->range.height; b->range.angle = a->range.angle; b->steps.trans = a->steps.trans; b->steps.rot = a->steps.rot; b->steps.scale = a->steps.scale; b->steps.height = a->steps.height; b->steps.radius = a->steps.radius; b->steps.angle = a->steps.angle; b->steps.trans_sphere = a->steps.trans_sphere; b->steps.scale_sphere = a->steps.scale_sphere; return; } ////////////////////////////////////////////////////////////// // funcao que realiza a troca de posicao entre dois candidatos void swap_candidates(set_of_candidates * candidates, int index1, int index2) { //parametros double trans_x, trans_y; //translacoes double rot_x, rot_y, rot_z; //rotacoes double scale; //escalas double height; //altura cilindro double alpha,beta;//angulos double tx[NUM_SPHERES],ty[NUM_SPHERES],scale_sphere[NUM_SPHERES];//esferas internas do volvox double radius; //raio do elegans/paramecium float quality; //qualidade do casamento entre as imagens int num_spheres; //numero de esferas no caso do volvox //range double range_trans; //intervalo translacoes double range_scale; //escalas double range_rot; //rotacoes double range_height; //parametros do elegans/paramecium double range_radius; //parametros do elegans/paramecium double range_angle; //angulos do elegans //steps double s_trans; //translacoes double s_rot; //rotacoes double s_scale; //escalas double s_height;//altura double s_radius;//altura double s_angle; //angulos da bacteria prototipo double s_trans_sphere; //deslocamento das esfera interiores double s_scale_sphere; //escala das esferas interiores int spheres; char model_name[30]; //copia os dados do index1 strcpy(model_name,candidates->candidates[index1].model_name); trans_x = candidates->candidates[index1].parameters.trans_x; trans_y = candidates->candidates[index1].parameters.trans_y; rot_x = candidates->candidates[index1].parameters.rot_x; rot_y = candidates->candidates[index1].parameters.rot_y; rot_z = candidates->candidates[index1].parameters.rot_z; height = candidates->candidates[index1].parameters.height; radius = candidates->candidates[index1].parameters.radius; alpha = candidates->candidates[index1].parameters.alpha; beta = candidates->candidates[index1].parameters.beta; scale = candidates->candidates[index1].parameters.scale; quality = candidates->candidates[index1].quality; num_spheres = candidates->candidates[index1].parameters.num_spheres; range_trans = candidates->candidates[index1].range.trans; range_scale = candidates->candidates[index1].range.scale; range_rot = candidates->candidates[index1].range.rot; range_radius = candidates->candidates[index1].range.radius; range_height = candidates->candidates[index1].range.height; range_angle = candidates->candidates[index1].range.angle; s_trans = candidates->candidates[index1].steps.trans; s_rot = candidates->candidates[index1].steps.rot; s_scale = candidates->candidates[index1].steps.scale; s_height = candidates->candidates[index1].steps.height; s_radius = candidates->candidates[index1].steps.radius; s_angle = candidates->candidates[index1].steps.angle; s_trans_sphere = candidates->candidates[index1].steps.trans_sphere; s_scale_sphere = candidates->candidates[index1].steps.scale_sphere; if(strcmp(model_name,"c_volvox") == 0) { for(spheres = 0; spheres < candidates->candidates[index1].parameters.num_spheres; spheres++) { tx[spheres] = candidates->candidates[index1].parameters.tx[spheres]; ty[spheres] = candidates->candidates[index1].parameters.ty[spheres]; scale_sphere[spheres] = candidates->candidates[index1].parameters.scale_sphere[spheres]; } } //joga o index2 no index1 strcpy(candidates->candidates[index1].model_name,candidates->candidates[index1].model_name); candidates->candidates[index1].parameters.trans_x = candidates->candidates[index2].parameters.trans_x; candidates->candidates[index1].parameters.trans_y = candidates->candidates[index2].parameters.trans_y; candidates->candidates[index1].parameters.rot_x = candidates->candidates[index2].parameters.rot_x; candidates->candidates[index1].parameters.rot_y = candidates->candidates[index2].parameters.rot_y; candidates->candidates[index1].parameters.rot_z = candidates->candidates[index2].parameters.rot_z; candidates->candidates[index1].parameters.scale = candidates->candidates[index2].parameters.scale; candidates->candidates[index1].quality = candidates->candidates[index2].quality; candidates->candidates[index1].parameters.height = candidates->candidates[index2].parameters.height; candidates->candidates[index1].parameters.radius = candidates->candidates[index2].parameters.radius; candidates->candidates[index1].parameters.alpha = candidates->candidates[index2].parameters.alpha; candidates->candidates[index1].parameters.beta = candidates->candidates[index2].parameters.beta; candidates->candidates[index1].parameters.num_spheres = candidates->candidates[index2].parameters.num_spheres; candidates->candidates[index1].range.trans = candidates->candidates[index2].range.trans; candidates->candidates[index1].range.scale = candidates->candidates[index2].range.scale; candidates->candidates[index1].range.rot = candidates->candidates[index2].range.rot; candidates->candidates[index1].range.radius = candidates->candidates[index2].range.radius; candidates->candidates[index1].range.height = candidates->candidates[index2].range.height; candidates->candidates[index1].range.angle = candidates->candidates[index2].range.angle; candidates->candidates[index1].steps.trans = candidates->candidates[index2].steps.trans; candidates->candidates[index1].steps.rot = candidates->candidates[index2].steps.rot; candidates->candidates[index1].steps.scale = candidates->candidates[index2].steps.scale; candidates->candidates[index1].steps.height = candidates->candidates[index2].steps.height; candidates->candidates[index1].steps.radius = candidates->candidates[index2].steps.radius; candidates->candidates[index1].steps.angle = candidates->candidates[index2].steps.angle; candidates->candidates[index1].steps.trans_sphere = candidates->candidates[index2].steps.trans_sphere; candidates->candidates[index1].steps.scale_sphere = candidates->candidates[index2].steps.scale_sphere; if(strcmp(model_name,"c_volvox") == 0) { for(spheres = 0; spheres < candidates->candidates[index1].parameters.num_spheres; spheres++) { candidates->candidates[index1].parameters.tx[spheres] = candidates->candidates[index2].parameters.tx[spheres]; candidates->candidates[index1].parameters.ty[spheres] = candidates->candidates[index2].parameters.ty[spheres]; candidates->candidates[index1].parameters.scale_sphere[spheres] = candidates->candidates[index2].parameters.scale_sphere[spheres]; } } //joga o swap no index2 strcpy(candidates->candidates[index2].model_name,model_name); candidates->candidates[index2].parameters.trans_x = trans_x; candidates->candidates[index2].parameters.trans_y = trans_y; candidates->candidates[index2].parameters.rot_x = rot_x; candidates->candidates[index2].parameters.rot_y = rot_y; candidates->candidates[index2].parameters.rot_z = rot_z; candidates->candidates[index2].parameters.scale = scale; candidates->candidates[index2].quality = quality; candidates->candidates[index2].parameters.height = height; candidates->candidates[index2].parameters.alpha = alpha; candidates->candidates[index2].parameters.beta = beta; candidates->candidates[index2].parameters.num_spheres = num_spheres; candidates->candidates[index2].parameters.radius = radius; candidates->candidates[index2].range.trans = range_trans; candidates->candidates[index2].range.scale = range_scale; candidates->candidates[index2].range.rot = range_rot; candidates->candidates[index2].range.radius = range_radius; candidates->candidates[index2].range.height = range_height; candidates->candidates[index2].range.angle = range_angle; candidates->candidates[index2].steps.trans = s_trans; candidates->candidates[index2].steps.rot = s_rot; candidates->candidates[index2].steps.scale = s_scale; candidates->candidates[index2].steps.height = s_height; candidates->candidates[index2].steps.radius = s_radius; candidates->candidates[index2].steps.angle = s_angle; candidates->candidates[index2].steps.trans_sphere = s_trans_sphere; candidates->candidates[index2].steps.scale_sphere = s_scale_sphere; if(strcmp(model_name,"c_volvox") == 0) { for(spheres = 0; spheres < candidates->candidates[index1].parameters.num_spheres; spheres++) { candidates->candidates[index2].parameters.tx[spheres] = tx[spheres]; candidates->candidates[index2].parameters.ty[spheres] = ty[spheres]; candidates->candidates[index2].parameters.scale_sphere[spheres] = scale_sphere[spheres]; } } return; } ///////////////////////////////////////////////////////////////////// // funcao que inicia o conjunto de candidatos inserindo valores altos // de qualidade void initialize_best_candidates(set_of_candidates *best) { int i = 0; for(i = 0; i < best->num_candidates; i++) { best->candidates[i].quality = INF; } return; } ////////////////////////////////////////////////////////////// // funcao que ordena o conjunto de candidatos na insercao int insert_sorting(set_of_candidates *best, candidate *c) { int num_candidates = best->num_candidates; int i,j; int index_swap = -1; //indice de onde ocorrera o swap candidate tmp; if(c->quality > best->candidates[num_candidates - 1].quality) return FALSE; for(i = 0; i < num_candidates; i++) { if(c->quality < best->candidates[i].quality) { index_swap = i; break; } } if(index_swap >= 0) { for(j = num_candidates-1; j > index_swap; j--) { copy_candidate(&(best->candidates[j]),&tmp); copy_candidate(&(best->candidates[j-1]),&(best->candidates[j])); copy_candidate(&tmp,&(best->candidates[j-1])); } copy_candidate(c,&(best->candidates[index_swap])); return TRUE; } else return FALSE; } ////////////////////////////////////////////////////////////// // funcao que ordena o conjunto de candidatos void sort_candidates(set_of_candidates *candidates) { int i; int j; int qtd = candidates->num_candidates; int k = qtd - 2 ; int aux = 0; for(i = 0; i < qtd-1; i++) { for(j = 0; j < k; j++) { if(candidates->candidates[j].quality > candidates->candidates[j+1].quality) { swap_candidates(candidates,j,j+1); } } } aux = candidates->num_candidates; if(aux > 10) aux = 10; // for(i = 0; i < aux; i++) // printf("\n qualidade [%d] : %.8lf ",i,candidates->candidates[i].quality); } ////////////////////////////////////////////////////////////// // funcao que retorna o id menor candidatos com menor diferenca de qualidade int id_lower(set_of_candidates *candidates) { int i; double lower = 10000; int id_lower; int qtd = candidates->num_candidates-1; for(i = 0; i < qtd; i++) { if(candidates->candidates[i].quality <= lower) { lower = candidates->candidates[i].quality; id_lower = i; } } return(i); } ////////////////////////////////////////////////////////////// // funcao que imprime os parametros dos melhores candidatos void print_parameters(set_of_candidates *candidates, int scale) { int i; char name_file[50]; int lim; sprintf(name_file,"img/bests_scale%02d.txt",scale); FILE *tmp = fopen(name_file,"w"); if(tmp == NULL) { printf("\n ERRO - Criacao Arquivo - print_parameters -AJST.C"); exit(1); } if(candidates->num_candidates < pow(2.0,scale)) lim = candidates->num_candidates; else lim = pow(2.0,scale); for(i = 0; i < 10; i++) { fprintf(tmp,"\n\n **** Candidate %d",i); fprintf(tmp,"\nTx: %.3lf Ty: %.3lf ",candidates->candidates[i].parameters.trans_x,candidates->candidates[i].parameters.trans_y); fprintf(tmp,"\nH: %.3lf R: %.3lf ",candidates->candidates[i].parameters.height,candidates->candidates[i].parameters.radius); fprintf(tmp,"\nA: %.3lf B: %.3lf ",candidates->candidates[i].parameters.alpha,candidates->candidates[i].parameters.beta); fprintf(tmp,"\nS: %.3lf ",candidates->candidates[i].parameters.scale); } fclose(tmp); } ////////////////////////////////////////////////////////////////// // funcao que calcula o range de cada um dos parametros do cubo void calculate_range_steps_cube(candidate *c, int scale, int *num_var_trans, int *num_var_scale, int *num_var_rot) { //range dos parametros c->range.trans = fabs(c->steps.trans); c->range.scale = fabs(c->steps.scale); c->range.rot = fabs(c->steps.rot); if(scale == 3) c->range.rot = 1.57; else c->range.rot = fabs(c->steps.rot); //step da translacao e sempre fixo pois independe de tamanho e etc c->steps.trans = 0.1*pow(2.0,scale); //step da scale c->steps.scale = log2( ( pow(2.0,scale - c->parameters.scale) / pow(2.0,c->parameters.scale) + 1)); //step da rotacao if(scale > 3) c->steps.rot = 0.0; else c->steps.rot = (0.1 * pow(2.0,scale-1.0)) / (pow(2.0,c->parameters.scale)); //calculando o numero de intervalos necessarios para cada parametro *num_var_trans = (int) ceil((c->range.trans+ EPS)/ (c->steps.trans + EPS)); *num_var_scale = (int) ceil((c->range.scale+ EPS)/ (c->steps.scale + EPS)); if(scale <= 3) *num_var_rot = (int) ceil((c->range.rot+ EPS) / (c->steps.rot + EPS)); else *num_var_rot = 1; if(*num_var_trans <= 0) *num_var_trans = 1; if(*num_var_scale <= 0) *num_var_scale = 1; if(*num_var_rot <= 0) *num_var_rot = 1; return; } ////////////////////////////////////////////////////////////////// // funcao que calcula o range de cada um dos parametros do volvox void calculate_range_steps_volvox(candidate *c, int scale, int *num_var_trans, int *num_var_scale, int *num_var_it, int *num_var_is) { //range dos parametros c->range.trans = 2.0*fabs(c->steps.trans); c->range.scale = fabs(c->steps.scale); if(scale > 1) { c->range.i_trans = 0.0; c->range.i_scale = 0.0; } else { if(scale == 1) { c->range.i_trans = (c->parameters.scale); c->range.i_scale = (c->parameters.scale)/2.0; } else { c->range.i_trans = fabs(c->steps.trans); c->range.scale = fabs(c->steps.scale); } } //step da translacao e sempre fixo pois independe de tamanho e etc c->steps.trans = 0.1*pow(2.0,scale); //step da scale c->steps.scale = 0.1*pow(2.0,scale); //calculando o numero de intervalos necessarios para cada parametro *num_var_trans = (int) ceil((c->range.trans+ EPS) / (c->steps.trans + EPS)) + 1; *num_var_scale = (int) ceil((c->range.scale+ EPS) / (c->steps.scale + EPS)) + 1; *num_var_it = (int) ceil((c->range.i_trans+ EPS) / (2.0*c->steps.trans + EPS)) + 1; *num_var_is = (int) ceil((c->range.i_scale+ EPS) / (2.0*c->steps.scale + EPS)) + 1; if(*num_var_trans <= 0) *num_var_trans = 1; if(*num_var_scale <= 0) *num_var_scale = 1; if(*num_var_it <= 0) *num_var_trans = 1; if(*num_var_is <= 0) *num_var_scale = 1; return; } ////////////////////////////////////////////////////////////////// // funcao que calcula o range de cada um dos parametros do elegans void calculate_range_steps_elegans(candidate *c, int scale, int *num_var_trans, int *num_var_radius, int *num_var_height, int *num_var_angle, int *num_var_rot) { //range dos parametros c->range.trans = fabs(c->steps.trans); c->range.radius = fabs(c->steps.radius); c->range.height = fabs(c->steps.height); c->range.angle = fabs(c->steps.angle); c->range.rot = fabs(c->steps.rot); //step da translacao e sempre fixo pois independe de tamanho e etc c->steps.trans = (0.1*pow(2.0,scale))/2.0; c->steps.radius = (0.1*pow(2.0,scale))/10.0; c->steps.height = (0.1*pow(2.0,scale))/4.0; c->steps.angle = 4.0*(0.1*pow(2.0,scale))/(5.0*c->parameters.radius); c->steps.rot = (0.1*pow(2.0,scale))/(10.0*c->parameters.radius); //calculando o numero de intervalos necessarios para cada parametro *num_var_trans = (int) ceil(c->range.trans / (c->steps.trans + EPS)); *num_var_radius = (int) ceil(c->range.radius / (c->steps.radius + EPS)); *num_var_height = (int) ceil(c->range.height / (c->steps.height + EPS)); *num_var_angle = (int) ceil(c->range.angle / (c->steps.angle + EPS)); *num_var_rot = (int) ceil(c->range.rot / (c->steps.rot + EPS)); //evitar negativos if(*num_var_trans <= 0) *num_var_trans = 1; if(*num_var_radius <= 0) *num_var_radius = 1; if(*num_var_height <= 0) *num_var_height = 1; if(*num_var_angle <= 0) *num_var_angle = 1; if(*num_var_rot <= 0) *num_var_rot = 1; return; } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de deslocamentos do cubo void fill_displacements_cube(displacements *d, candidate *c, int num_var_trans, int num_var_scale, int num_var_rot) { int i = 0; int lim1 = (num_var_trans/2), lim2 = (num_var_trans); /////////////////////////////////////// // steps de translacao //////////////////////////////////////// d->trans[0] = (double)c->steps.trans*(0.0); for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i-lim1-0.5); } /////////////////////////////////////// // steps de scale //////////////////////////////////////// lim1 = (num_var_scale/2), lim2 = (num_var_scale); if(num_var_scale == 1) d->scale[0] = (double)c->steps.scale*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->scale[i] = (double)c->steps.scale*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->scale[i] = (double)-c->steps.scale*(i-lim1-0.5); } } /////////////////////////////////////// // steps de rotacao //////////////////////////////////////// lim1 = (num_var_rot/2), lim2 = (num_var_rot); if(num_var_rot == 1) d->rot[0] = (double)c->steps.rot*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->rot[i] = (double)-c->steps.scale*(i-0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->rot[i] = (double)c->steps.scale*(i-lim1+0.5); } } } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de deslocamentos do cubo void fill_displacements_volvox(displacements *d, candidate *c, int num_var_trans, int num_var_scale, int num_var_it, int num_var_is) { int i = 0; int lim1 = (num_var_trans/2), lim2 = (num_var_trans); /////////////////////////////////////// // steps de translacao //////////////////////////////////////// d->trans[0] = (double)c->steps.trans*(0.0); for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i-lim1-0.5); } /////////////////////////////////////// // steps de scale //////////////////////////////////////// lim1 = (num_var_scale/2), lim2 = (num_var_scale); if(num_var_scale == 1) d->scale[0] = (double)c->steps.scale*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->scale[i] = (double)c->steps.scale*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->scale[i] = (double)c->steps.scale*(i-lim1-0.5); } } /////////////////////////////////////// // steps de scale //////////////////////////////////////// lim1 = (num_var_it/2), lim2 = (num_var_it); if(num_var_it == 1) d->trans_sphere[0] = (double)c->steps.trans*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->trans_sphere[i] = (double)c->steps.trans*(i); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->trans_sphere[i] = (double)c->steps.trans*(i-lim1); } } /////////////////////////////////////// // steps de scale //////////////////////////////////////// lim1 = (num_var_is/2), lim2 = (num_var_is); if(num_var_is == 1) d->scale_sphere[0] = (double)c->steps.scale*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->scale_sphere[i] = (double)c->steps.scale*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->scale_sphere[i] = (double)-c->steps.scale*(i-lim1-0.5); } } } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de deslocamentos do cubo void fill_displacements_elegans(displacements *d, candidate *c, int num_var_trans, int num_var_radius, int num_var_height, int num_var_angle) { int i = 0; int lim1 = (num_var_trans/2), lim2 = (num_var_trans); /////////////////////////////////////// // steps de translacao //////////////////////////////////////// d->trans[0] = (double)c->steps.trans*(0.0); for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->trans[i] = (double)c->steps.trans*(i-lim1-0.5); } /////////////////////////////////////// // steps de radius //////////////////////////////////////// lim1 = (num_var_radius/2), lim2 = (num_var_radius); if(num_var_radius == 1) d->radius[0] = (double)c->steps.radius*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->radius[i] = (double)c->steps.radius*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->radius[i] = (double)-c->steps.radius*(i-lim1-0.5); } } /////////////////////////////////////// // steps de height //////////////////////////////////////// lim1 = (num_var_height/2), lim2 = (num_var_height); if(num_var_height == 1) d->height[0] = (double)c->steps.height*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->height[i] = (double)c->steps.height*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->height[i] = (double)-c->steps.height*(i-lim1-0.5); } } /////////////////////////////////////// // steps de height //////////////////////////////////////// lim1 = (num_var_height/2), lim2 = (num_var_height); if(num_var_angle == 1) d->angle[0] = (double)c->steps.angle*(0.0); else { for(i = 0; i <= lim1; i++) { //preenche os deslocamentos d->angle[i] = (double)c->steps.angle*(i+0.5); } for(i = lim1+1; i < lim2; i++) { //preenche os deslocamentos d->angle[i] = (double)-c->steps.angle*(i-lim1-0.5); } } } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de candidatos do cubo void update_set_of_candidates_cube(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale) { int tx,ty; //translacao int s; //escala int rx,ry,rz; //rotacao long unsigned int index = 0; //indice long unsigned int num_candidates = 0; //numero de raw candidatos gerados int *num_var_trans, //numero de variacoes dos parametros *num_var_scale, *num_var_rot; int candidates_adjst = 0; //numero de candidatos a serem refinados displacements d;//displacements dos candidatos set_of_candidates best_prev; //copia os melhores candidatos da escala anterior para essa variavel int i = 0; //contador dos melhores candidatos candidate c; //alloca os melhores da escala anterior allocate_set_of_candidates(&best_prev,(long int)best->num_candidates); //realiza a copia dos melhores da escala anterior para best_prev for(i = 0; i < best->num_candidates; i++) { copy_candidate(&(best->candidates[i]),&(best_prev.candidates[i])); } //verifica o numero de candidatos que serao usados if(best->num_candidates < pow(2.0,scale)) { candidates_adjst = best->num_candidates; } else { candidates_adjst = (int) ceil(pow(2.0,scale)); } //aloca o numero de passos necessario para cada parametro num_var_trans = malloc(sizeof(int)*candidates_adjst+1); num_var_scale = malloc(sizeof(int)*candidates_adjst+1); num_var_rot = malloc(sizeof(int)*candidates_adjst+1); //desaloca os melhores anteriores que já foram copiados para best_prev deallocate_set_of_candidates(best); //alloca a quantidade necessaria de ajusted candidatos allocate_set_of_candidates(best,(int)pow(2.0,scale)); initialize_best_candidates(best); //calcula os ranges e os steps for(i = 0; i < candidates_adjst; i++) { //calcula o range, step e o numero de candidatos calculate_range_steps_cube(&(best_prev.candidates[i]),scale-1,&(num_var_trans[i]),&(num_var_scale[i]),&(num_var_rot[i])); //imprime os valores dos parametros, range e steps printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.scale, best_prev.candidates[i].parameters.rot_x,best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].range.trans,best_prev.candidates[i].range.scale,best_prev.candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.scale,best_prev.candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); num_candidates += (long int) pow(num_var_trans[i],2.0) * (long int) pow(num_var_scale[i],1.0) * (long int) pow(num_var_rot[i],3.0); printf("\n %ld %ld %ld [%ld]",(long int)pow(num_var_trans[i],2.0),(long int)pow(num_var_scale[i],1.0),(long int)pow(num_var_rot[i],3.0),num_candidates); } //copia os nomes dos modelos for(i = 0; i < best->num_candidates; i++) { strcpy(best->candidates[i].model_name,best_prev.candidates[0].model_name); } printf("\n ============================================================================================"); printf("\n A ESCALA %d POSSUI %ld RAW CANDIDATOS e %d AJUSTED CANDIDATES",scale,num_candidates,candidates_adjst); printf("\n ESCALA (%d) BEST_PREV : %d BEST : %d",scale,candidates_adjst,best->num_candidates); printf("\n ============================================================================================"); index = 0; //cria um conjunto de parametros iniciais for(i = 0; i < candidates_adjst; i++) { //printf(" best %d ",i);int tmp; scanf("%d",&tmp); fill_displacements_cube(&d,&(best_prev.candidates[i]),num_var_trans[i],num_var_scale[i],num_var_rot[i]); for(s = 0; s < num_var_scale[i]; s++) { for(tx = 0; tx < num_var_trans[i]; tx++) { for(ty = 0; ty < num_var_trans[i]; ty++) { for(rx = 0; rx < num_var_rot[i]; rx++) { for(ry = 0; ry < num_var_rot[i]; ry++) { for(rz = 0; rz < num_var_rot[i]; rz++) { //copia os melhores candidatos para o vetor best copy_candidate(&(best_prev.candidates[i]),&c); c.parameters.trans_x = best_prev.candidates[i].parameters.trans_x + d.trans[tx]; c.parameters.trans_y = best_prev.candidates[i].parameters.trans_y + d.trans[ty]; c.parameters.scale = best_prev.candidates[i].parameters.scale + d.scale[s]; c.parameters.rot_x = best_prev.candidates[i].parameters.rot_x + d.rot[rx]; c.parameters.rot_y = best_prev.candidates[i].parameters.rot_y + d.rot[ry]; c.parameters.rot_z = best_prev.candidates[i].parameters.rot_z + d.rot[rz]; create_candidate_image_sorting(best,&c,index,image_in,scale,dim_img_in,num_scale,FALSE); index++; } } } } } } } /*for(i = 0; i < best_prev.num_candidates; i++) { printf("\n PREV ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best_prev.candidates[i].model_name, best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y, best_prev.candidates[i].parameters.scale,best_prev.candidates[i].parameters.rot_x, best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.scale, best_prev.candidates[i].parameters.rot_x,best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].range.trans,best_prev.candidates[i].range.scale,best_prev.candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.scale,best_prev.candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); } printf("\n \n"); for(i = 0; i < best->num_candidates; i++) { printf("\n BEST ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best->candidates[i].model_name, best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y, best->candidates[i].parameters.scale,best->candidates[i].parameters.rot_x, best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y,best->candidates[i].parameters.scale, best->candidates[i].parameters.rot_x,best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].range.trans,best->candidates[i].range.scale,best->candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].steps.trans,best->candidates[i].steps.scale,best->candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); }*/ //desaloca memoria alocada free(num_var_trans); free(num_var_scale); free(num_var_rot); deallocate_set_of_candidates(&best_prev); return; } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de candidatos do volvox void update_set_of_candidates_volvox(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale) { int tx,ty; //translacao int s; //escala int ix,iy; //translacao das esferas internas int is; //scale of internal spheres long unsigned int index = 0; //indice long unsigned int num_candidates = 0; //numero de raw candidatos gerados int *num_var_trans, //numero de variacoes dos parametros *num_var_scale, *num_var_it, *num_var_is; int num_spheres; int candidates_adjst = 0; //numero de candidatos a serem refinados displacements d;//displacements dos candidatos set_of_candidates best_prev; //copia os melhores candidatos da escala anterior para essa variavel int i = 0; //contador dos melhores candidatos int n = 0; //contador do numero de esferas candidate c; double mult = 0; //alloca os melhores da escala anterior allocate_set_of_candidates(&best_prev,(long int)best->num_candidates); //realiza a copia dos melhores da escala anterior para best_prev for(i = 0; i < best->num_candidates; i++) { copy_candidate(&(best->candidates[i]),&(best_prev.candidates[i])); } //verifica o numero de candidatos que serao usados if(best->num_candidates < pow(2.0,scale)) { candidates_adjst = best->num_candidates; } else { candidates_adjst = (int) ceil(pow(2.0,scale)); } //aloca o numero de passos necessario para cada parametro num_var_trans = malloc(sizeof(int)*candidates_adjst+1); num_var_scale = malloc(sizeof(int)*candidates_adjst+1); num_var_it = malloc(sizeof(int)*candidates_adjst+1); num_var_is = malloc(sizeof(int)*candidates_adjst+1); //desaloca os melhores anteriores que já foram copiados para best_prev deallocate_set_of_candidates(best); //alloca a quantidade necessaria de ajusted candidatos allocate_set_of_candidates(best,(int)pow(2.0,scale)); initialize_best_candidates(best); //calcula os ranges e os steps //introducao do parametro na escala 2 if(scale <= 3) num_spheres = best_prev.candidates[0].parameters.num_spheres; else num_spheres = 1; for(i = 0; i < candidates_adjst; i++) { //calcula o range e o numero de candidatos calculate_range_steps_volvox(&(best_prev.candidates[i]),scale-1,&(num_var_trans[i]),&(num_var_scale[i]),&(num_var_it[i]),&(num_var_is[i])); //imprime os valores dos parametros, range e steps printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Internal_Spheres: %d", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.scale,num_spheres); int k = 0; for(k = 0; k < best_prev.candidates[i].parameters.num_spheres; k++) { printf("\n SPHERE INTERNAL %d -> X:%.2lf Y:%.2lf S:%.2lf", k,best_prev.candidates[i].parameters.tx[k],best_prev.candidates[i].parameters.ty[k],best_prev.candidates[i].parameters.scale_sphere[k]); } printf("\n RANGE -> T[%.2lf] S[%.2lf] Ti[%.2lf] Si[%.2lf]",best_prev.candidates[i].range.trans,best_prev.candidates[i].range.scale,best_prev.candidates[i].range.i_trans,best_prev.candidates[i].range.i_scale); printf("\n STEPS -> T[%.2lf] S[%.2lf] ",best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.scale); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_Ti: [%d] N_steps_Si: [%d]",num_var_trans[i],num_var_scale[i],num_var_it[i],num_var_is[i]); printf("\n **********************************"); num_candidates += (long int) pow(num_var_trans[i],2.0) * (long int) pow(num_var_scale[i],1.0) * (long int) pow(num_var_it[i],2.0) * (long int) pow(num_var_is[i],1.0) * (long int) num_spheres; printf("\n %ld %ld %d %d [%ld]",(long int)pow(num_var_trans[i],2.0),(long int)pow(num_var_scale[i],1.0),(int)pow(num_var_it[i],2.0),(int)pow(num_var_is[i],2.0),num_candidates); } //copia os nomes dos modelos for(i = 0; i < best->num_candidates; i++) { strcpy(best->candidates[i].model_name,best_prev.candidates[0].model_name); } printf("\n ============================================================================================"); printf("\n A ESCALA %d POSSUI %ld RAW CANDIDATOS e %d AJUSTED CANDIDATES",scale,num_candidates,candidates_adjst); printf("\n ESCALA (%d) BEST_PREV : %d BEST : %d",scale,candidates_adjst,best->num_candidates); printf("\n ============================================================================================"); if(scale <= 3) mult = 1.0; else mult = 0.0; index = 0; //printf(" best %d ",i);int tmp; scanf("%d",&tmp); //cria um conjunto de parametros iniciais for(i = 0; i < candidates_adjst; i++) { //printf(" best %d ",i);int tmp; scanf("%d",&tmp); fill_displacements_volvox(&d,&(best_prev.candidates[i]),num_var_trans[i],num_var_scale[i],num_var_it[i],num_var_is[i]); for(s = 0; s < num_var_scale[i]; s++) { for(tx = 0; tx < num_var_trans[i]; tx++) { for(ty = 0; ty < num_var_trans[i]; ty++) { for(ix = 0; ix < num_var_it[i]; ix++) { for(iy = 0; iy < num_var_it[i]; iy++) { for(is = 0; is < num_var_is[i]; is++) { for(n = 0; n < num_spheres; n++) { //copia os melhores candidatos para o vetor best copy_candidate(&(best_prev.candidates[i]),&c); c.parameters.trans_x = best_prev.candidates[i].parameters.trans_x + d.trans[tx]; c.parameters.trans_y = best_prev.candidates[i].parameters.trans_y + d.trans[ty]; c.parameters.scale = best_prev.candidates[i].parameters.scale + d.scale[s]; c.parameters.tx[n] = best_prev.candidates[i].parameters.tx[n] + mult*d.trans_sphere[ix]; c.parameters.ty[n] = best_prev.candidates[i].parameters.ty[n] + mult*d.trans_sphere[iy]; c.parameters.scale_sphere[n] = best_prev.candidates[i].parameters.scale_sphere[n] + mult*d.scale_sphere[is]; create_candidate_image_sorting(best,&c,index,image_in,scale,dim_img_in,num_scale,FALSE); index++; } } } } } } } } /*for(i = 0; i < best_prev.num_candidates; i++) { printf("\n PREV ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best_prev.candidates[i].model_name, best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y, best_prev.candidates[i].parameters.scale,best_prev.candidates[i].parameters.rot_x, best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.scale, best_prev.candidates[i].parameters.rot_x,best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].range.trans,best_prev.candidates[i].range.scale,best_prev.candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.scale,best_prev.candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); } printf("\n \n"); for(i = 0; i < best->num_candidates; i++) { printf("\n BEST ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best->candidates[i].model_name, best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y, best->candidates[i].parameters.scale,best->candidates[i].parameters.rot_x, best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y,best->candidates[i].parameters.scale, best->candidates[i].parameters.rot_x,best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].range.trans,best->candidates[i].range.scale,best->candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].steps.trans,best->candidates[i].steps.scale,best->candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); }*/ //desaloca memoria alocada free(num_var_trans); free(num_var_scale); deallocate_set_of_candidates(&best_prev); return; } ////////////////////////////////////////////////////////////// // funcao que atualiza o conjutno de candidatos do volvox void update_set_of_candidates_elegans(set_of_candidates *best, int scale, float_image_t *image_in, int dim_img_in, int num_scale) { int tx,ty; //translacao int h,r; //escala int a,b,rz; //angulos de deformacao e rotacao long unsigned int index = 0; //indice long unsigned int num_candidates = 0; //numero de raw candidatos gerados int *num_var_trans, //numero de variacoes dos parametros *num_var_r, *num_var_h, *num_var_angle, *num_var_rot; int candidates_adjst = 0; //numero de candidatos a serem refinados displacements d;//displacements dos candidatos set_of_candidates best_prev; //copia os melhores candidatos da escala anterior para essa variavel int i = 0; //contador dos melhores candidatos candidate c; //alloca os melhores da escala anterior allocate_set_of_candidates(&best_prev,(long int)best->num_candidates); //realiza a copia dos melhores da escala anterior para best_prev for(i = 0; i < best->num_candidates; i++) { copy_candidate(&(best->candidates[i]),&(best_prev.candidates[i])); } //verifica o numero de candidatos que serao usados if(best->num_candidates < pow(2.0,scale)) { candidates_adjst = best->num_candidates; } else { candidates_adjst = (int) ceil(pow(2.0,scale)); } //aloca o numero de passos necessario para cada parametro num_var_trans = malloc(sizeof(int)*candidates_adjst+1); num_var_r = malloc(sizeof(int)*candidates_adjst+1); num_var_h = malloc(sizeof(int)*candidates_adjst+1); num_var_angle = malloc(sizeof(int)*candidates_adjst+1); num_var_rot = malloc(sizeof(int)*candidates_adjst+1); //desaloca os melhores anteriores que já foram copiados para best_prev deallocate_set_of_candidates(best); //alloca a quantidade necessaria de ajusted candidatos allocate_set_of_candidates(best,(int)pow(2.0,scale)); initialize_best_candidates(best); //calcula os ranges e os steps for(i = 0; i < candidates_adjst; i++) { //calcula o range e o numero de candidatos calculate_range_steps_elegans(&(best_prev.candidates[i]),scale-1,&(num_var_trans[i]),&(num_var_r[i]),&(num_var_h[i]),&(num_var_angle[i]),&(num_var_rot[i])); //imprime os valores dos parametros, range e steps printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf R:%.2lf H:%.2lf A:%.2lf B:%.2lf RZ:%.2lf", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.radius, best_prev.candidates[i].parameters.height,best_prev.candidates[i].parameters.alpha,best_prev.candidates[i].parameters.beta, best_prev.candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] R[%.2lf] H[%.2lf] A[%.2lf] RZ[%.2lf]" , best_prev.candidates[i].range.trans,best_prev.candidates[i].range.radius,best_prev.candidates[i].range.height, best_prev.candidates[i].range.angle,best_prev.candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] R[%.2lf] H[%.2lf] A[%.2lf] RZ[%.2lf]", best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.radius,best_prev.candidates[i].steps.height, best_prev.candidates[i].steps.angle,best_prev.candidates[i].steps.rot); printf("\n VARIACOES -> N_T: [%d] N_R: [%d] N_H: [%d] N_A: [%d] N_RZ: [%d]", num_var_trans[i],num_var_r[i],num_var_h[i],num_var_angle[i],num_var_rot[i]); printf("\n **********************************"); num_candidates += (long int) pow(num_var_trans[i],2.0) * (long int) pow(num_var_r[i],1.0) * (long int) pow(num_var_h[i],1.0) * (long int) pow(num_var_angle[i],2.0) * (long int) pow(num_var_rot[i],1.0); } //copia os nomes dos modelos for(i = 0; i < best->num_candidates; i++) { strcpy(best->candidates[i].model_name,best_prev.candidates[0].model_name); } printf("\n ============================================================================================"); printf("\n A ESCALA %d POSSUI %ld RAW CANDIDATOS e %d AJUSTED CANDIDATES",scale,num_candidates,candidates_adjst); printf("\n ESCALA (%d) BEST_PREV : %d BEST : %d",scale,candidates_adjst,best->num_candidates); printf("\n ============================================================================================"); index = 0; //printf(" best %d ",i);int tmp; scanf("%d",&tmp); //cria um conjunto de parametros iniciais for(i = 0; i < candidates_adjst; i++) { //printf(" best %d ",i);int tmp; scanf("%d",&tmp); fill_displacements_elegans(&d,&(best_prev.candidates[i]),num_var_trans[i],num_var_r[i],num_var_h[i],num_var_angle[i]); for(tx = 0; tx < num_var_trans[i]; tx++) { for(ty = 0; ty < num_var_trans[i]; ty++) { for(r = 0; r < num_var_r[i]; r++) { for(h = 0; h < num_var_h[i]; h++) { for(a = 0; a < num_var_angle[i]; a++) { for(b = 0; b < num_var_angle[i]; b++) { for(rz = 0; rz < num_var_angle[i]; rz++) { //copia os melhores candidatos para o vetor best copy_candidate(&(best_prev.candidates[i]),&c); c.parameters.trans_x = best_prev.candidates[i].parameters.trans_x + d.trans[tx]; c.parameters.trans_y = best_prev.candidates[i].parameters.trans_y + d.trans[ty]; c.parameters.radius = best_prev.candidates[i].parameters.radius + d.radius[r]; c.parameters.height = best_prev.candidates[i].parameters.height + d.height[h]; c.parameters.alpha = best_prev.candidates[i].parameters.alpha + d.angle[a]; c.parameters.beta = best_prev.candidates[i].parameters.beta + d.angle[b]; create_candidate_image_sorting(best,&c,index,image_in,scale,dim_img_in,num_scale,FALSE); index++; } } } } } } } } /*for(i = 0; i < best_prev.num_candidates; i++) { printf("\n PREV ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best_prev.candidates[i].model_name, best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y, best_prev.candidates[i].parameters.scale,best_prev.candidates[i].parameters.rot_x, best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best_prev.candidates[i].parameters.trans_x,best_prev.candidates[i].parameters.trans_y,best_prev.candidates[i].parameters.scale, best_prev.candidates[i].parameters.rot_x,best_prev.candidates[i].parameters.rot_y,best_prev.candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].range.trans,best_prev.candidates[i].range.scale,best_prev.candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best_prev.candidates[i].steps.trans,best_prev.candidates[i].steps.scale,best_prev.candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); } printf("\n \n"); for(i = 0; i < best->num_candidates; i++) { printf("\n BEST ... %s (%.2lf , %.2lf) %.2lf [%.2lf , %.2lf , %.2lf]",best->candidates[i].model_name, best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y, best->candidates[i].parameters.scale,best->candidates[i].parameters.rot_x, best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n ********** BEST %d **************",i); printf("\n PARAMETRO -> Tx:%.2lf Ty:%.2lf S:%.2lf Rx:%.2lf Ry:%.2lf Rz:%.2lf", best->candidates[i].parameters.trans_x,best->candidates[i].parameters.trans_y,best->candidates[i].parameters.scale, best->candidates[i].parameters.rot_x,best->candidates[i].parameters.rot_y,best->candidates[i].parameters.rot_z); printf("\n RANGE -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].range.trans,best->candidates[i].range.scale,best->candidates[i].range.rot); printf("\n STEPS -> T[%.2lf] S[%.2lf] R[%.2lf]", best->candidates[i].steps.trans,best->candidates[i].steps.scale,best->candidates[i].steps.rot); printf("\n VARIACOES -> N_steps_T: [%d] N_steps_S: [%d] N_steps_R: [%d]", num_var_trans[i],num_var_scale[i],num_var_rot[i]); printf("\n **********************************"); }*/ //desaloca memoria alocada free(num_var_trans); free(num_var_r); free(num_var_h); free(num_var_angle); free(num_var_rot); deallocate_set_of_candidates(&best_prev); return; } // Last edited on 2011-01-19 15:45:48 by stolfilocal