int main(int argc, char **argv){ if( argc<6){ if(argc>1) fprintf(stderr,"Error, not enough arguments\n"); usage(); exit(1); } // read arguments color_image_t *im1 = color_image_load(argv[1]); color_image_t *im2 = color_image_load(argv[2]); float_image edges = read_edges(argv[3], im1->width, im1->height); float_image matches = read_matches(argv[4]); const char *outputfile = argv[5]; // prepare variables epic_params_t epic_params; epic_params_default(&epic_params); variational_params_t flow_params; variational_params_default(&flow_params); image_t *wx = image_new(im1->width, im1->height), *wy = image_new(im1->width, im1->height); // read optional arguments #define isarg(key) !strcmp(a,key) int current_arg = 6; while(current_arg < argc ){ const char* a = argv[current_arg++]; if( isarg("-h") || isarg("-help") ) usage(); else if( isarg("-nw") ) strcpy(epic_params.method, "NW"); else if( isarg("-p") || isarg("-prefnn") ) epic_params.pref_nn = atoi(argv[current_arg++]); else if( isarg("-n") || isarg("-nn") ) epic_params.nn = atoi(argv[current_arg++]); else if( isarg("-k") ) epic_params.coef_kernel = atof(argv[current_arg++]); else if( isarg("-i") || isarg("-iter") ) flow_params.niter_outer = atoi(argv[current_arg++]); else if( isarg("-a") || isarg("-alpha") ) flow_params.alpha= atof(argv[current_arg++]); else if( isarg("-g") || isarg("-gamma") ) flow_params.gamma= atof(argv[current_arg++]); else if( isarg("-d") || isarg("-delta") ) flow_params.delta= atof(argv[current_arg++]); else if( isarg("-s") || isarg("-sigma") ) flow_params.sigma= atof(argv[current_arg++]); else if( isarg("-sintel") ){ epic_params.pref_nn= 25; epic_params.nn= 160; epic_params.coef_kernel = 1.1f; flow_params.niter_outer = 5; flow_params.alpha = 1.0f; flow_params.gamma = 0.72f; flow_params.delta = 0.0f; flow_params.sigma = 1.1f; } else if( isarg("-kitti") ){ epic_params.pref_nn= 25; epic_params.nn= 160; epic_params.coef_kernel = 1.1f; flow_params.niter_outer = 2; flow_params.alpha = 1.0f; flow_params.gamma = 0.77f; flow_params.delta = 0.0f; flow_params.sigma = 1.7f; } else if( isarg("-middlebury") ){ epic_params.pref_nn= 15; epic_params.nn= 65; epic_params.coef_kernel = 0.2f; flow_params.niter_outer = 25; flow_params.alpha = 1.0f; flow_params.gamma = 0.72f; flow_params.delta = 0.0f; flow_params.sigma = 1.1f; } else{ fprintf(stderr, "unknown argument %s", a); usage(); exit(1); } } // compute interpolation and energy minimization color_image_t *imlab = rgb_to_lab(im1); epic(wx, wy, imlab, &matches, &edges, &epic_params, 1); // energy minimization variational(wx, wy, im1, im2, &flow_params); // write output file and free memory writeFlowFile(outputfile, wx, wy); color_image_delete(im1); color_image_delete(imlab); color_image_delete(im2); free(matches.pixels); free(edges.pixels); image_delete(wx); image_delete(wy); return 0; }
int main(int argc, char *argv[]){ int n_search; int i_halo; char filename_SSimPL_root[MAX_FILENAME_LENGTH]; char filename_in[MAX_FILENAME_LENGTH]; char group_text_prefix[4]; int n_files; int k_read; int max_n_groups; int l_read; int n_groups; int j_read; int mode; int n_groups_i; int n_groups_j; int j_halo; int match; int i_read; int i_read_start; int i_read_stop; SID_fp fp_in; SID_init(&argc,&argv,NULL,NULL); // Fetch user inputs strcpy(filename_SSimPL_root,argv[1]); if(!strcmp(argv[2],"groups") || !strcmp(argv[2],"group")) mode=MATCH_GROUPS; else if(!strcmp(argv[2],"subgroups") || !strcmp(argv[2],"subgroup")) mode=MATCH_SUBGROUPS; else{ SID_log("Invalid mode selection {%s}. Should be 'group' or 'subgroup'.",SID_LOG_COMMENT,argv[2]); SID_exit(ERROR_SYNTAX); } i_read=atoi(argv[3]); j_read=atoi(argv[4]); SID_log("Searching match information for halo #%d in file #%d of {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,i_halo,i_read,filename_SSimPL_root); // Convert filename_root to filename switch(mode){ case MATCH_SUBGROUPS: sprintf(group_text_prefix,"sub"); break; case MATCH_GROUPS: sprintf(group_text_prefix,""); break; } // Set the standard SSiMPL match file path char filename_root_in[MAX_FILENAME_LENGTH]; sprintf(filename_root_in,"%s/trees/matches/",filename_SSimPL_root); // Set the output file char filename_base[MAX_FILENAME_LENGTH]; char filename_out[MAX_FILENAME_LENGTH]; sprintf(filename_base,filename_SSimPL_root); if(!strcmp(&(filename_base[strlen(filename_base)-1]),"/")) strcpy(&(filename_base[strlen(filename_base)-1]),"\0"); strip_path(filename_base); sprintf(filename_out,"%s_%d_%d_2way_matches.txt",filename_base,i_read,j_read); // Read header information SID_log("Reading header information...",SID_LOG_OPEN); sprintf(filename_in,"%s/%sgroup_matches_header.dat",filename_root_in,group_text_prefix); SID_fopen(filename_in,"r",&fp_in); SID_fread(&i_read_start,sizeof(int),1,&fp_in);SID_log("snap start =%d",SID_LOG_COMMENT,i_read_start); SID_fread(&i_read_stop, sizeof(int),1,&fp_in);SID_log("snap stop =%d",SID_LOG_COMMENT,i_read_stop); SID_fread(&n_search, sizeof(int),1,&fp_in);SID_log("search range=%d",SID_LOG_COMMENT,n_search); SID_fread(&n_files, sizeof(int),1,&fp_in);SID_log("# of files =%d",SID_LOG_COMMENT,n_files); for(k_read=0,max_n_groups=0;k_read<n_files;k_read++){ SID_fread(&l_read, sizeof(int),1,&fp_in); SID_fread(&n_groups,sizeof(int),1,&fp_in); SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR); if(mode==MATCH_GROUPS) SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR); max_n_groups=MAX(max_n_groups,n_groups); } SID_log("Max # groups=%d",SID_LOG_COMMENT,max_n_groups); SID_fclose(&fp_in); SID_log("Done.",SID_LOG_CLOSE); // Initialize some arrays int *n_particles_i =(int *)SID_malloc(sizeof(int) *max_n_groups); int *n_particles_j =(int *)SID_malloc(sizeof(int) *max_n_groups); int *match_forward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups); size_t *match_forward_index =(size_t *)SID_malloc(sizeof(size_t)*max_n_groups); float *match_forward_score =(float *)SID_malloc(sizeof(float) *max_n_groups); char *match_forward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups); int *match_backward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups); size_t *match_backward_index=(size_t *)SID_malloc(sizeof(size_t)*max_n_groups); float *match_backward_score=(float *)SID_malloc(sizeof(float) *max_n_groups); char *match_backward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups); // Loop over all matching combinations SID_log("Reading forward matches...",SID_LOG_OPEN|SID_LOG_TIMER); SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT); read_matches(filename_root_in, i_read, j_read, max_n_groups, mode, &n_groups_i, &n_groups_j, n_particles_i, n_particles_j, NULL, NULL, match_forward_ids, match_forward_score, match_forward_index, match_forward_2way, FALSE); SID_log("Done.",SID_LOG_CLOSE); SID_log("Processing backwards matches...",SID_LOG_OPEN|SID_LOG_TIMER); read_matches(filename_root_in, j_read, i_read, max_n_groups, mode, &n_groups_j, &n_groups_i, n_particles_j, n_particles_i, NULL, NULL, match_backward_ids, match_backward_score, match_backward_index, match_backward_2way, FALSE); SID_log("Done.",SID_LOG_CLOSE); // Open output file FILE *fp_out; fp_out=fopen(filename_out,"w"); int i_column=1; fprintf(fp_out,"# Column (%02d): Halo index for snapshot %d\n", i_column++,i_read); fprintf(fp_out,"# (%02d): Halo index for snapshot %d\n", i_column++,j_read); fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,i_read); fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,j_read); fprintf(fp_out,"# (%02d): Forward match score\n", i_column++); fprintf(fp_out,"# (%02d): Forward match score/min match score\n",i_column++); fprintf(fp_out,"# (%02d): Backward match score\n", i_column++); fprintf(fp_out,"# (%02d): Backward match score/min match score\n",i_column++); for(int i_halo=0;i_halo<n_groups_i;i_halo++){ int j_halo=match_forward_ids[i_halo]; if(match_forward_2way[i_halo]){ if(j_halo<0 || j_halo>n_groups_j) SID_trap_error("There's an invalid match id (ie. %d<0 || %d>%d) attached to a 2-way match!",ERROR_LOGIC,j_halo,j_halo,n_groups_j); fprintf(fp_out,"%7d %7d %6d %6d %10.3le %10.3le %10.3le %10.3le\n", i_halo, j_halo, n_particles_i[i_halo], n_particles_j[j_halo], match_forward_score[i_halo], match_forward_score[i_halo]/minimum_match_score((double)n_particles_i[i_halo]), match_backward_score[j_halo], match_backward_score[j_halo]/minimum_match_score((double)n_particles_j[j_halo])); } } fclose(fp_out); // Clean-up SID_free(SID_FARG n_particles_i); SID_free(SID_FARG n_particles_j); SID_free(SID_FARG match_forward_ids); SID_free(SID_FARG match_forward_index); SID_free(SID_FARG match_forward_score); SID_free(SID_FARG match_forward_2way); SID_free(SID_FARG match_backward_ids); SID_free(SID_FARG match_backward_index); SID_free(SID_FARG match_backward_score); SID_free(SID_FARG match_backward_2way); SID_log("Done.",SID_LOG_CLOSE); SID_exit(ERROR_NONE); }
int main(int argc, char *argv[]){ SID_init(&argc,&argv,NULL,NULL); SID_log("Constructing match catalog...",SID_LOG_OPEN|SID_LOG_TIMER); // Parse arguments char filename_catalog_root[MAX_FILENAME_LENGTH]; char filename_matches_root[MAX_FILENAME_LENGTH]; char filename_out[MAX_FILENAME_LENGTH]; char prefix_text[32]; int flag_matches_type; int i_read; int j_read; int catalog_read_mode; int matches_read_mode; strcpy(filename_catalog_root,argv[1]); strcpy(filename_matches_root,argv[2]); flag_matches_type =atoi(argv[3]); strcpy(prefix_text, argv[4]); i_read =atoi(argv[5]); j_read =atoi(argv[6]); strcpy(filename_out, argv[7]); if(!strcpy(prefix_text,"subgroup") || !strcpy(prefix_text,"subgroups") || !strcpy(prefix_text,"sub")){ sprintf(prefix_text,"sub"); catalog_read_mode=READ_CATALOG_SUBGROUPS|READ_CATALOG_PROPERTIES; matches_read_mode=MATCH_SUBGROUPS; } else if(!strcpy(prefix_text,"group") || !strcpy(prefix_text,"groups")){ sprintf(prefix_text,""); catalog_read_mode=READ_CATALOG_GROUPS|READ_CATALOG_PROPERTIES; matches_read_mode=MATCH_GROUPS; } else SID_trap_error("Invalid catalog type (%s).",ERROR_SYNTAX,prefix_text); // Set filenames char filename_cat1[MAX_FILENAME_LENGTH]; char filename_cat2[MAX_FILENAME_LENGTH]; sprintf(filename_cat1,"%s_%03d.catalog_%sgroups_properties",filename_catalog_root,prefix_text,i_read); sprintf(filename_cat2,"%s_%03d.catalog_%sgroups_properties",filename_catalog_root,prefix_text,j_read); // Contents of the halo properties structure //struct halo_properties_info{ // long long id_MBP; // ID of most bound particle in structure // int n_particles; // Number of particles in the structure // float position_COM[3]; // Centre-of-mass position [Mpc/h] // float position_MBP[3]; // Most bound particle position [Mpc/h] // float velocity_COM[3]; // Centre-of-mass velocity [km/s] // float velocity_MBP[3]; // Most bound particle velocity [km/s] // double M_vir; // Bryan & Norman (ApJ 495, 80, 1998) virial mass [M_sol/h] // float R_vir; // Virial radius [Mpc/h] // float R_halo; // Distance of last halo particle from MBP [Mpc/h] // float R_max; // Radius of maximum circular velocity [Mpc/h] // float V_max; // Maximum circular velocity [km/s] // float sigma_v; // Total 3D velocity dispersion [km/s] // float spin[3]; // Specific angular momentum vector [Mpc/h*km/s] // float q_triaxial; // Triaxial shape parameter q=b/a // float s_triaxial; // Triaxial shape parameter s=c/a // float shape_eigen_vectors[3][3]; // Normalized triaxial shape eigenvectors //}; // Read matches int *n_subgroups =NULL; int *n_groups =NULL; int *n_particles_i=NULL; int *n_particles_j=NULL; int *match_ids =NULL; float *match_score =NULL; size_t *match_index =NULL; int n_halos_i; int n_halos_j; int n_files; int n_subgroups_max; int n_groups_max; int n_halos_max; read_matches_header(filename_matches_root, 0, MAX(i_read,j_read), 1, &n_files, &n_subgroups, &n_groups, &n_subgroups_max, &n_groups_max, &n_halos_max); read_matches(filename_matches_root, i_read, j_read, n_halos_max, matches_read_mode, &n_halos_i, &n_halos_j, n_particles_i, n_particles_j, NULL, NULL, match_ids, match_score, match_index, NULL, FALSE); // Create a storage array mapping the indices of the second catalog // to those of the halos they are matched to in the first catalog int i_halo; int j_halo; int *storage_index; storage_index=(int *)SID_malloc(sizeof(int)*n_halos_j); for(j_halo=0;j_halo<n_halos_j;j_halo++) storage_index[j_halo]=-1; for(i_halo=0,j_halo=0;j_halo<n_halos_j && i_halo<n_halos_i;j_halo++){ while(match_ids[match_index[i_halo]]<j_halo && i_halo<(n_halos_i-1)) i_halo++; if(match_ids[match_index[i_halo]]<j_halo) i_halo++; if(match_ids[match_index[i_halo]]==j_halo) storage_index[j_halo]=match_index[i_halo]; } // Open catalog files fp_catalog_info fp_properties_i; fp_catalog_info fp_properties_j; fopen_catalog(filename_catalog_root, i_read, catalog_read_mode, &fp_properties_i); fopen_catalog(filename_catalog_root, j_read, catalog_read_mode, &fp_properties_j); // Read catalogs halo_properties_info *properties_i; halo_properties_info *properties_j; properties_i =(halo_properties_info *)SID_malloc(sizeof(halo_properties_info)*n_halos_i); properties_j =(halo_properties_info *)SID_malloc(sizeof(halo_properties_info)*n_halos_i); for(i_halo=0;i_halo<n_halos_i;i_halo++) fread_catalog_file(&fp_properties_i,NULL,NULL,&(properties_i[i_halo]),NULL,i_halo); for(j_halo=0;j_halo<n_halos_j;j_halo++){ if(storage_index[j_halo]>=0) fread_catalog_file(&fp_properties_j,NULL,NULL,&(properties_j[storage_index[j_halo]]),NULL,j_halo); } fclose_catalog(&fp_properties_i); fclose_catalog(&fp_properties_j); // Write results int i_column=0; FILE *fp_out; fp_out=fopen(filename_out,"w"); fprintf(fp_out,"# Catalog for matches {root %s} and catalog {root %s}; snap No. %d to %d.\n", filename_matches_root, filename_catalog_root, i_read,j_read); fprintf(fp_out,"# Columns:(%02d) id (catalog No. 1)\n", i_column++); fprintf(fp_out,"# (%02d) id (catalog No. 2)\n", i_column++); fprintf(fp_out,"# (%02d) M (catalog No. 1) [M_sol/h]\n",i_column++); fprintf(fp_out,"# (%02d) M (catalog No. 2) [M_sol/h]\n",i_column++); fprintf(fp_out,"# (%02d) x (catalog No. 1) [Mpc/h]\n", i_column++); fprintf(fp_out,"# (%02d) y (catalog No. 1) [Mpc/h]\n", i_column++); fprintf(fp_out,"# (%02d) z (catalog No. 1) [Mpc/h]\n", i_column++); fprintf(fp_out,"# (%02d) x (catalog No. 2) [Mpc/h]\n", i_column++); fprintf(fp_out,"# (%02d) y (catalog No. 2) [Mpc/h]\n", i_column++); fprintf(fp_out,"# (%02d) z (catalog No. 2) [Mpc/h]\n", i_column++); for(i_halo=0;i_halo<n_halos_i;i_halo++){ fprintf(fp_out,"%10d %10d %10.4le %10.4le %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f\n", i_halo, match_ids[i_halo], properties_i[i_halo].M_vir, properties_j[i_halo].M_vir, properties_i[i_halo].position_COM[0], properties_i[i_halo].position_COM[1], properties_i[i_halo].position_COM[2], properties_j[i_halo].position_COM[0], properties_j[i_halo].position_COM[1], properties_j[i_halo].position_COM[2]); } fclose(fp_out); // Clean-up SID_free(SID_FARG n_subgroups); SID_free(SID_FARG n_groups); SID_free(SID_FARG n_particles_i); SID_free(SID_FARG n_particles_j); SID_free(SID_FARG properties_i); SID_free(SID_FARG properties_j); SID_free(SID_FARG match_ids); SID_free(SID_FARG match_score); SID_free(SID_FARG match_index); SID_free(SID_FARG storage_index); SID_log("Done.",SID_LOG_CLOSE); SID_exit(ERROR_NONE); }