int main(int argc, char* argv[]) { int n_rows; Measurements *table; double mean; printf("----------------- \n" " Classify test 2 \n" "----------------- \n" " \n" " Uses a length threshold to seperate hair/microvibrissae from main whiskers. \n" " A histogram method is used to measure the expected number of whiskers per \n" " frame. A range of thresholds is examined. \n" "-- \n"); Process_Arguments( argc, argv, Spec, 0); table = Measurements_Table_From_Filename( Get_String_Arg("source"), NULL, &n_rows ); if(!table) error("Couldn't read %s\n",Get_String_Arg("source")); { int thresh; for( thresh = 0; thresh < 400; thresh ++ ) { int count, argmax; Measurements_Table_Label_By_Threshold( table, n_rows, 0 /*length*/, thresh, 1/*use gt*/ ); count = Measurements_Table_Best_Frame_Count_By_State( table, n_rows, 1, &argmax ); printf("%4d %3d %3d\n", thresh, count, argmax ); } } Free_Measurements_Table(table); }
int main(int argc, char * argv[]) { auto begin = std::chrono::high_resolution_clock::now(); static char *Spec[] = { "[-r <int(20)>] [-d <int(2)>] [-l <int(1)>] [-t <int(100)>] [-hmd] [-hmr] [-mi] [-v] -in <inputFile> -out <outputFile>", NULL }; ProjectionMethod::ParaSet parameter (argc,argv,Spec); std::string outputString = Get_String_Arg("-out"); ProjectionMethod::ProjectionAlgorithm imgProjection (Get_String_Arg("-in")); imgProjection.SetParameters (parameter); imgProjection.ProjectImageStack(); imgProjection.DrawProjection(outputString); if (parameter.printHeightMap == true) { imgProjection.DrawDownsampledHeightMap(outputString); } if (parameter.printRealHeightMap == true) { imgProjection.DrawInterpolatedHeightMap(outputString); } if (parameter.verbose == true) { auto end = std::chrono::high_resolution_clock::now(); auto dur = end - begin; auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count(); std::cout << "Runtime: " << ms << " ms"<< std::endl; } return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string> -o <string> --intv <int> <int> <int>", "[--option <string>] [--fgc] [--help]", NULL}; if (help(argc, argv, Spec) == 1) { return 0; } Process_Arguments(argc, argv, Spec, 1); Stack *stack = Read_Stack_U(Get_String_Arg("input")); Stack *out = NULL; int option = DS_NEAREST; if (Is_Arg_Matched("--option")) { const char *arg = Get_String_Arg("--option"); if (eqstr(arg, "max")) { option = DS_MAX; } else if (eqstr(arg, "mean")) { option = DS_MEAN; } else if (eqstr(arg, "nearest")) { option = DS_NEAREST; } else { printf("Invalid option: %s\n. The default option (nearest) will be used.", arg); } } switch (option) { case DS_NEAREST: out = Downsample_Stack(stack, Get_Int_Arg("--intv", 1), Get_Int_Arg("--intv", 2), Get_Int_Arg("--intv", 3)); break; case DS_MAX: out = Downsample_Stack_Max(stack, Get_Int_Arg("--intv", 1), Get_Int_Arg("--intv", 2), Get_Int_Arg("--intv", 3), NULL); break; case DS_MEAN: if (Is_Arg_Matched("--fgc")) { out = Downsample_Stack_Mean_F(stack, Get_Int_Arg("--intv", 1), Get_Int_Arg("--intv", 2), Get_Int_Arg("--intv", 3), NULL); } else { out = Downsample_Stack_Mean(stack, Get_Int_Arg("--intv", 1), Get_Int_Arg("--intv", 2), Get_Int_Arg("--intv", 3), NULL); } break; default: break; } Write_Stack(Get_String_Arg("-o"), out); return 0; }
/* * bwdist - build a distance map for a binary stack * * bwdist [-b<int>] infile -o outfile * * -i: inverse the image * -b: byte number for output file (1 (default) or 2) * -sq: build square distance map */ int main(int argc, char *argv[]) { static char *Spec[] = {"<image:string> -o <string>", "[-b<int> | -sq] [-i] [--plane]", NULL}; Process_Arguments(argc, argv, Spec, 1); char *image_file = Get_String_Arg("image"); Stack *stack = Read_Stack(image_file); if (Is_Arg_Matched("-i")) { Stack_Not(stack, stack); } Stack *distmap = NULL; if (!Is_Arg_Matched("-sq")) { distmap = Stack_Bwdist_L(stack, NULL, NULL); Kill_Stack(stack); int kind = GREY; if (Is_Arg_Matched("-b")) { kind = Get_Int_Arg("-b"); } stack = Scale_Float_Stack((float *) distmap->array, distmap->width, distmap->height, distmap->depth, kind); Kill_Stack(distmap); distmap = stack; } else { if (Is_Arg_Matched("--plane")) { distmap = Stack_Bwdist_L_U16P(stack, NULL, 0); Translate_Stack(distmap, GREY, 1); } else { distmap = Stack_Bwdist_L_U16(stack, NULL, 0); } Kill_Stack(stack); } char *out_file = Get_String_Arg("-o"); Write_Stack(out_file, distmap); Kill_Stack(distmap); return 1; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<file:string>", "[-u <int>]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (!fexist(Get_String_Arg("file"))) { printf("%s does not exist.\n", Get_String_Arg("file")); return 1; } struct stat buf; stat(Get_String_Arg("file"), &buf); int file_size = buf.st_size; printf("file size: %d\n", file_size); FILE *fp = fopen(Get_String_Arg("file"), "r"); int length; if (fp != NULL) { if (fread(&length, sizeof(int), 1, fp) != 1) { printf("Wrong file format.\n"); return 1; } else { if (((file_size - sizeof(int)) % length) != 0) { printf("Bad array file.\n"); return 1; } else { if (Is_Arg_Matched("-u")) { int unit = Get_Int_Arg("-u"); if (length * unit != file_size - sizeof(int)) { printf("Bad array file.\n"); return 1; } } } } fclose(fp); } printf("%d elements (%lu)\n", length, (file_size - sizeof(int)) / length); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string>", NULL}; Process_Arguments(argc, argv, Spec, 1); String_Workspace *sw = New_String_Workspace(); FILE *fp = fopen(Get_String_Arg("input"), "r"); char *line; int start = 10000; int end = 0; while((line = Read_Line(fp, sw)) != NULL) { int value = String_First_Integer(line); if (value < start) { start = value; } if (value > end) { end = value; } } fclose(fp); printf("%d %d\n", start, end); return 0; }
int main(int argc, char *argv[]) { Stack *movie, *out; FILE *fp; int i,j,iPlane,depth; int area; Process_Arguments(argc,argv,Spec,0); progress("Loading...\n"); fflush(stdout); movie = load(Get_String_Arg("movie")); if( Is_Arg_Matched("-t") ) { Stack *tmovie = transpose_copy_uint8( movie ); Free_Stack(movie); movie = tmovie; } progress("Done.\n"); Write_Stack( Get_String_Arg("output"), movie ); Free_Stack( movie ); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<image:string> -s <int> -o <string>", "[-n <int>]", NULL}; Process_Arguments(argc, argv, Spec, 1); Stack *stack = Read_Stack(Get_String_Arg("image")); int n_nbr = 26; if (Is_Arg_Matched("-n")) { n_nbr = Get_Int_Arg("-n"); } Stack_Label_Large_Objects_N(stack, NULL, 1, 2, Get_Int_Arg("-s") + 1, n_nbr); Stack_Threshold_Binarize(stack, 2); Write_Stack(Get_String_Arg("-o"), stack); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"[<number:string> | -a <num1:string> <num2:string>]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (Is_Arg_Matched("-a")) { char *numstr1 = Get_String_Arg("num1"); char *numstr2 = Get_String_Arg("num2"); uint32_t num1; uint32_t num2; if (numstr1[0] == 'x') { num1 = Hexstr_To_Uint(numstr1 + 1); } else { num1 = atoi(numstr1); } if (numstr2[0] == 'x') { num2 = Hexstr_To_Uint(numstr2 + 1); } else { num2 = atoi(numstr2); } char str[12]; printf("%s\n", Uint_To_Hexstr(num1 + num2, str)); } else { char *numstr = Get_String_Arg("number"); if (numstr[0] == 'x') { printf("%u\n", Hexstr_To_Uint(numstr + 1)); } else { char str[12]; printf("%s\n", Uint_To_Hexstr(atoi(numstr), str)); } } return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string> -o <string> -tile_number <int> [-upsample <string>]", NULL}; Process_Arguments(argc, argv, Spec, 1); char filepath[500]; int i; int n = Get_Int_Arg("-tile_number"); for (i = 0; i < n; i++) { sprintf(filepath, "%s/%03d", Get_String_Arg("input"), i+1); int n = dir_fnum(filepath, "tif"); sprintf(filepath, "%s/%03d.xml", Get_String_Arg("-o"), i+1); FILE *fp = GUARDED_FOPEN(filepath, "w"); fprintf(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); fprintf(fp, "<trace>\n"); fprintf(fp, "<data>\n"); fprintf(fp, "<image type=\"bundle\">\n"); fprintf(fp, "<prefix>%s/%03d/</prefix>\n", Get_String_Arg("input"), i+1); fprintf(fp, "<suffix>.tif</suffix>\n"); if (n > 100) { fprintf(fp, "<num_width>3</num_width>\n"); } else { fprintf(fp, "<num_width>2</num_width>\n"); } fprintf(fp, "<first_num>1</first_num>\n"); fprintf(fp, "</image>\n"); fprintf(fp, "<resolution><x>0.0375</x><y>0.0375</y><z>0.2</z></resolution>\n"); fprintf(fp, "</data>\n"); fprintf(fp, "</trace>\n"); fclose(fp); printf("%s created\n", filepath); } if (Is_Arg_Matched("-upsample")) { if (fexist(Get_String_Arg("-upsample"))) { FILE *fp = fopen(Get_String_Arg("-upsample"), "r"); String_Workspace *sw = New_String_Workspace(); char *line = NULL; int n; line = Read_Line(fp, sw); int *array = String_To_Integer_Array(line, NULL, &n); int i; for (i = 0; i < n; i++) { upsample(Get_String_Arg("-o"), array[i]); } fclose(fp); } } return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string> -o <string> [--dim <string>]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (Is_Arg_Matched("--dim")) { if (strcmp(Get_String_Arg("--dim"), "x") == 0 || strcmp(Get_String_Arg("--dim"), "X") == 0) { Stack *stack = Read_Stack(Get_String_Arg("input")); Image *image = Proj_Stack_Xmax(stack); Write_Image(Get_String_Arg("-o"), image); } } else { Mc_Stack *stack = Read_Mc_Stack(Get_String_Arg("input"), -1); Mc_Stack *proj = Mc_Stack_Mip(stack); Write_Mc_Stack(Get_String_Arg("-o"), proj, NULL); } return 0; }
int main(int argc, char *argv[]) { char *in, *out; Tiff_Reader *reader; Tiff_Writer *writer; Tiff_IFD *ifd; int flag64, first, source, target; int *colors, nchan; Process_Arguments(argc,argv,Spec,0); in = Get_String_Arg("in"); out = Get_String_Arg("out"); reader = Open_Tiff_Reader(in,NULL,&flag64,strcmp(in+(strlen(in)-4),".lsm") == 0); if (reader == NULL) { fprintf(stderr,"Error opening tif %s:\n %s\n",in,Tiff_Error_String()); exit (1); } writer = Open_Tiff_Writer(out,flag64,0); if (writer == NULL) { fprintf(stderr,"Error opening tif %s:\n %s\n",out,Tiff_Error_String()); exit (1); } nchan = 0; colors = NULL; target = 0; source = 0; first = 1; while ( ! End_Of_Tiff(reader)) { ifd = Read_Tiff_IFD(reader); if (ifd == NULL) { fprintf(stderr,"Error reading IFD:\n %s\n",Tiff_Error_String()); exit (1); } if (first) { first = 0; if (Is_Arg_Matched("-m")) { source = Get_Int_Arg("-m",1); target = Get_Int_Arg("-m",2); if (source < 0 || source > 1) { fprintf(stderr,"Source is not 0 or 1\n"); exit (1); } if (target < 0 || target > 2) { fprintf(stderr,"Target is not 0, 1, or 2\n"); exit (1); } } else if (Get_Tiff_Tag(ifd,TIFF_CZ_LSM_INFO,NULL,NULL) != NULL) { if (nchan == 0) { nchan = Count_LSM_Colors(ifd); colors = (int *) Guarded_Malloc(sizeof(int)*((size_t) nchan),Program_Name()); } Get_LSM_Colors(ifd,nchan,colors); // Figure out which channel is green for (source = 0; source < nchan; source++) // and map to green in the RGB if ((colors[source] & 0xff00) != 0) break; if (source >= nchan) source = 0; target = 1; } else { source = 0; target = 1; } } if (Convert_2_RGB(ifd,source,target) != NULL) { if (Write_Tiff_IFD(writer,ifd)) { fprintf(stderr,"Error writing IFD:\n %s\n",Tiff_Error_String()); exit (1); } } else { fprintf(stderr,"Error adding extra channel:\n %s\n",Tiff_Error_String()); exit (1); } Free_Tiff_IFD(ifd); } Free_Tiff_Writer(writer); exit (0); }
int main(int argc, char *argv[]) { static char *Spec[] = {"[-outfolder <string>] [-redgreenimagefolder <string>]", "[-blueimagefolder <string>]", NULL}; Process_Arguments(argc, argv, Spec, 1); int nredgreenimage; int nblueimage; char** redgreenfilepath = get_image_paths(Get_String_Arg("-redgreenimagefolder"), ".*\\.lsm", &nredgreenimage); char** bluefilepath = get_image_paths(Get_String_Arg("-blueimagefolder"), ".*\\.lsm", &nblueimage); if (redgreenfilepath == NULL || bluefilepath == NULL) { printf("no image!\n"); return 1; } else if (nredgreenimage != nblueimage) { printf("image number don't match, abort! red: %d, blue: %d\n", nredgreenimage, nblueimage); return 1; } else { printf("%d images\n", nblueimage); } qsort(redgreenfilepath, nblueimage, sizeof(char*), compare_string_by_num); qsort(bluefilepath, nblueimage, sizeof(char*), compare_string_by_num); char prefix[500]; char outfilepath[500]; char filenamenoext[500]; int k; for (k = 0; k < nblueimage; ++k) { strcpy(prefix, Get_String_Arg("-outfolder")); strcpy(filenamenoext, redgreenfilepath[k]); char *end = strrchr(filenamenoext, '.'); if (end != NULL) { *end = '\0'; } else { printf("something stange happens..\n"); } char *start = strrchr(filenamenoext, '/'); if (start != NULL) { start++; } else { start = filenamenoext; } if (prefix[strlen(prefix)-1]=='/') { sprintf(outfilepath, "%s%s.tif", prefix, start); } else { sprintf(outfilepath, "%s/%s.tif", prefix, start); } FILE* fp = open_file(outfilepath, "wb"); fclose(fp); Mc_Stack* mc_stack1 = Read_Mc_Stack(redgreenfilepath[k], -1); Mc_Stack* mc_stack2 = Read_Mc_Stack(bluefilepath[k], -1); Mc_Stack* mc_stack = Combine_Mc_Stack(mc_stack1, mc_stack2); Write_Mc_Stack(outfilepath, mc_stack, NULL); printf("Write %s done!\n", outfilepath); Kill_Mc_Stack(mc_stack1); Kill_Mc_Stack(mc_stack2); Kill_Mc_Stack(mc_stack); } free(redgreenfilepath); free(bluefilepath); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<dataset:string> | -D <string>", NULL}; Process_Arguments(argc, argv, Spec, 1); char file_path[100]; if (Is_Arg_Matched("-D")) { sprintf(file_path, "%s/error.xml", Get_String_Arg("-D")); } else { sprintf(file_path, "../data/diadem_%s/error.xml", Get_String_Arg("dataset")); } xmlDocPtr doc; xmlNodePtr cur; doc = xmlParseFile(file_path); if (doc == NULL) { fprintf(stderr, "XML parsing failed.\n"); return 1; } cur = xmlDocGetRootElement(doc); if (cur == NULL) { fprintf(stderr, "empty document\n"); xmlFreeDoc(doc); return 1; } if (xmlStrcmp(cur->name, (const xmlChar*) "diadem_metric")) { fprintf(stderr, "document of wrong type\n"); xmlFreeDoc(doc); return 1; } cur = cur->xmlChildrenNode; char *miss_file = NULL; char *golden_file = NULL; char *extra_file = NULL; char *nearby_file = NULL; char *test_file = NULL; char *miss_swc_file = NULL; char *extra_swc_file = NULL; char *nearby_swc_file = NULL; char *miss_vlm_file = NULL; char *extra_vlm_file = NULL; char *nearby_vlm_file = NULL; char *miss_score_file = NULL; char *extra_score_file = NULL; double EuDistThre_xy = 0.0; double EuDistThre_z = 0.0; double score; while (cur != NULL) { if (Xml_Node_Is_Element(cur, "miss") == TRUE) { miss_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "extra") == TRUE) { extra_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "score") == TRUE) { score = Xml_Node_Double_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "golden") == TRUE) { golden_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "nearby") == TRUE) { nearby_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "test") == TRUE) { test_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "miss_swc") == TRUE) { miss_swc_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "extra_swc") == TRUE) { extra_swc_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "nearby_swc") == TRUE) { nearby_swc_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "miss_vlm") == TRUE) { miss_vlm_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "extra_vlm") == TRUE) { extra_vlm_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "nearby_vlm") == TRUE) { nearby_vlm_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "miss_score") == TRUE) { miss_score_file = Xml_Node_String_Value(doc, cur); } else if (Xml_Node_Is_Element(cur, "extra_score") == TRUE) { extra_score_file = Xml_Node_String_Value(doc, cur); }else if(Xml_Node_Is_Element(cur, "xyth") == TRUE) { EuDistThre_xy = Xml_Node_Double_Value(doc, cur); }else if(Xml_Node_Is_Element(cur, "zth") == TRUE) { EuDistThre_z = Xml_Node_Double_Value(doc, cur); } cur = cur->next; } if ((EuDistThre_xy <= 0.0) || (EuDistThre_z <= 0.0)) { fprintf(stderr, "Invalid threshold value\n"); xmlFreeDoc(doc); return 1; } Swc_Tree *tree = Read_Swc_Tree(golden_file); double bound[6]; Swc_Tree_Bound_Box(tree, bound); double marker_ratio = dmax3(bound[3] - bound[0], bound[4] - bound[1], bound[5] - bound[2]) / 512.0; Geo3d_Scalar_Field *miss_field = read_node_file(miss_file); printf("The missed nodes:\n"); Print_Geo3d_Scalar_Field(miss_field); Geo3d_Scalar_Field *extra_field = read_node_file(extra_file); printf("The extra nodes:\n"); Print_Geo3d_Scalar_Field(extra_field); Geo3d_Scalar_Field *nearby_field = read_node_file(nearby_file); // Print_Geo3d_Scalar_Field(nearby_field); double wm = darray_sum(miss_field->values, miss_field->size); double we = darray_sum(extra_field->values, extra_field->size); double wg = round((score * we + wm) / (1 - score)); // printf("%g %g %g\n", wm, we, wg); Swc_Tree_Iterator_Start(tree, 2, FALSE); int max_id = 0; Swc_Tree_Node *tn = NULL; while ((tn = Swc_Tree_Next(tree)) != NULL) { Swc_Tree_Node_Data(tn)->type = 3; if (max_id < Swc_Tree_Node_Data(tn)->id) { max_id = Swc_Tree_Node_Data(tn)->id; } } uint8 *nearby_mask = u8array_calloc(max_id + 1); /* process nearby nodes */ FILE *fp = NULL; FILE *fp3 = NULL; if (nearby_swc_file != NULL) { fp = fopen(nearby_swc_file, "w"); } if (nearby_vlm_file != NULL) { fp3 = fopen(nearby_vlm_file, "w"); } // printf("Nearby list\n"); int i; for (i = 0; i < nearby_field->size; i++) { Swc_Tree_Node *tn = Swc_Tree_Closest_Node(tree, nearby_field->points[i]); nearby_mask[Swc_Tree_Node_Data(tn)->id] = 1; double w = (1.0+3.0/(1+exp(-(nearby_field->values[i]*2.0-2.0)))) * marker_ratio; if (fp != NULL) { fprintf(fp, "%d %d %g %g %g %g %d\n", i + 1, 7, Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z,w, -1); } if (fp3 != NULL) { fprintf(fp3, "%g,%g,%g,%g,1,%g\n", Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z, w, nearby_field->values[i]); } } if (fp != NULL) { fclose(fp); } if (fp3 != NULL) { fclose(fp3); } /* process missing nodes */ fp = NULL; FILE *fp2 = fopen(miss_score_file, "w"); fp3 = NULL; if (miss_swc_file != NULL) { fp = fopen(miss_swc_file, "w"); } if (miss_vlm_file != NULL) { fp3 = fopen(miss_vlm_file, "w"); } Swc_Tree *test_tree = Read_Swc_Tree(test_file); // printf("Missing list\n"); int n_leaves = 0; int n_branchings = 0; int n_leaves_distance = 0; int n_leaves_path = 0; int n_branchings_distance = 0; int n_branchings_path = 0; double score_leaves = 0.0; double score_branchings = 0.0; double score_leaves_distance = 0.0; double score_leaves_path = 0.0; double score_branching_distance = 0.0; double score_branching_path = 0.0; BOOL error_type; // 'true' indicates distance-error, 'false' indicates path-error for (i = 0; i < miss_field->size; i++) { Swc_Tree_Node *tn = Swc_Tree_Closest_Node(tree, miss_field->points[i]); double cur_score = miss_field->values[i] / (wg + we); fprintf(fp2, "%4d | %5.2f %5.2f %5.2f | %g | %g\n", Swc_Tree_Node_Data(tn)->id, Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z, miss_field->values[i], cur_score); Swc_Tree_Node_Data(tn)->type = 2; double w = (1.0+3.0/(1+exp(-(miss_field->values[i]*2.0-2.0)))) * marker_ratio; if (fp != NULL) { int type = 0; if (nearby_mask[Swc_Tree_Node_Data(tn)->id] == 1) { type = 1; } fprintf(fp, "%d %d %g %g %g %g %d\n", i + 1, type, Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z, w, -1); } if (fp3 != NULL) { double xy_dist, z_dist; Swc_Tree_Node *test_tn; double pos[3]; Swc_Tree_Node_Pos(tn, pos); if(Swc_Tree_Node_Is_Branch_Point(tn)) test_tn = Find_Closest_Branch_Point(test_tree, pos, &xy_dist, &z_dist); else test_tn = Find_Closest_Leaf_Point(test_tree, pos, &xy_dist, &z_dist); if(xy_dist >= EuDistThre_xy || z_dist >= EuDistThre_z){ fprintf(fp3, "%g,%g,%g,%g,1,%g,[xy-%g z-%g | distance_error], 255, 255, 0\n",Swc_Tree_Node_Data(tn)->x + 1.0, Swc_Tree_Node_Data(tn)->y + 1.0, Swc_Tree_Node_Data(tn)->z + 1.0, w, miss_field->values[i], xy_dist, z_dist); error_type = TRUE; }else{ fprintf(fp3, "%g,%g,%g,%g,1,%g,[xy-%g z-%g | path_error], 255, 0, 255\n",Swc_Tree_Node_Data(tn)->x + 1.0, Swc_Tree_Node_Data(tn)->y + 1.0, Swc_Tree_Node_Data(tn)->z + 1.0, w, miss_field->values[i], xy_dist, z_dist); error_type = FALSE; } } if(miss_field->values[i]==1){ n_leaves ++; score_leaves += cur_score; if(error_type){ // distance error n_leaves_distance ++; score_leaves_distance += cur_score; }else{ n_leaves_path ++; score_leaves_path += cur_score; } }else{ n_branchings ++; score_branchings += cur_score; if(error_type){ // distance error n_branchings_distance ++; score_branching_distance += cur_score; }else{ n_branchings_path ++; score_branching_path += cur_score; } } } if(fp2 != NULL){ fprintf(fp2, "\nleaf errors: \t %d | loss score: %g(%2.1f%%)\n", n_leaves, score_leaves, 100*score_leaves/(1 - score)); fprintf(fp2, "leaf errors (dist): %d | loss score: %g(%2.1f%%) \n", n_leaves_distance, score_leaves_distance, 100*score_leaves_distance/(1 - score)); fprintf(fp2, "leaf errors (path): %d | loss score: %g(%2.1f%%) \n", n_leaves_path, score_leaves_path, 100*score_leaves_path/(1 - score)); fprintf(fp2, "\nbranching errors: \t %d | score loss: %g(%2.1f%%) \n", n_branchings, score_branchings, 100*score_branchings/(1 - score)); fprintf(fp2, "branching error (dist): %d | score loss: %g(%2.1f%%) \n", n_branchings_distance, score_branching_distance, 100*score_branching_distance/(1 - score)); fprintf(fp2, "branching error (path): %d | score loss: %g(%2.1f%%) \n", n_branchings_path, score_branching_path, 100*score_branching_path/(1 - score)); } if (fp != NULL) { fclose(fp); } fclose(fp2); if (fp3 != NULL) { fclose(fp3); } /* sprintf(file_path, "../data/diadem_%s/error.swc", Get_String_Arg("dataset")); Write_Swc_Tree(file_path, tree); */ tree = test_tree; /* process extra nodes*/ fp = NULL; fp2 = fopen(extra_score_file, "w"); fp3 = NULL; if (extra_swc_file != NULL) { fp = fopen(extra_swc_file, "w"); } if (extra_vlm_file != NULL) { fp3 = fopen(extra_vlm_file, "w"); } // printf("Extra list\n"); n_leaves = 0; n_branchings = 0; score_leaves = 0.0; score_branchings = 0.0; for (i = 0; i < extra_field->size; i++) { Swc_Tree_Node *tn = Swc_Tree_Closest_Node(tree, extra_field->points[i]); double cur_score = extra_field->values[i] * (wg - wm) / (wg + we) / (wg + we - extra_field->values[i]); fprintf(fp2, "%4d | %5.2f %5.2f %5.2f | %g | %g\n", Swc_Tree_Node_Data(tn)->id, Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z, extra_field->values[i], cur_score); double w = (1.0+3.0/(1+exp(-(extra_field->values[i]*2.0-2.0)))) * marker_ratio; if (fp != NULL) { fprintf(fp, "%d %d %g %g %g %g %d\n", i + 1, 1, Swc_Tree_Node_Data(tn)->x, Swc_Tree_Node_Data(tn)->y, Swc_Tree_Node_Data(tn)->z, w, -1); } if (fp3 != NULL) { fprintf(fp3, "%g,%g,%g,%g,1,%g, error, 255, 255, 0\n", Swc_Tree_Node_Data(tn)->x + 1.0, Swc_Tree_Node_Data(tn)->y + 1.0, Swc_Tree_Node_Data(tn)->z + 1.0, w, extra_field->values[i]); } if(extra_field->values[i]==1){ n_leaves ++; score_leaves += cur_score; }else{ n_branchings ++; score_branchings += cur_score; } } if(fp2 != NULL){ fprintf(fp2, "\nleaf errors: %d | loss score: %g(%2.1f%%)\n", n_leaves, score_leaves, 100*score_leaves/(1 - score)); fprintf(fp2, "branching errors: %d | score loss: %g(%2.1f%%) \n", n_branchings, score_branchings, 100*score_branchings/(1 - score)); } if (fp != NULL) { fclose(fp); } fclose(fp2); if (fp3 != NULL) { fclose(fp3); } xmlFreeDoc(doc); printf("Score = %g\n", score); return 0; }
int main(int argc, char *argv[]) { FILE *output; Process_Arguments(argc,argv,Spec,0); #ifdef PROGRESS printf("\nParameters: c=%g e=%g s=%d\n", Get_Double_Arg("-c"),Get_Double_Arg("-e"),Get_Int_Arg("-s")); printf("SubFolder: %s\n",Get_String_Arg("folder")); printf("CoreName: %s\n",Get_String_Arg("core")); fflush(stdout); #endif RezFolder = strdup(Get_String_Arg("folder")); if (RezFolder[strlen(RezFolder)-1] == '/') RezFolder[strlen(RezFolder)-1] = '\0'; if (mkdir(RezFolder,S_IRWXU|S_IRWXG|S_IRWXO)) { if (errno != EEXIST) { fprintf(stderr,"Error trying to create directory %s: %s\n",RezFolder,strerror(errno)); exit (1); } } CoreName = strdup(Get_String_Arg("core")); sprintf(NameBuf,"%s.neu",CoreName); output = fopen(NameBuf,"w"); fprintf(output,"NEUSEP: Version 0.9\n"); { Histogram *hist; int curchan; int maxchans; int i, n; n = Get_Repeat_Count("inputs"); fwrite(&n,sizeof(int),1,output); hist = Make_Histogram(UVAL,0x10000,VALU(1),VALU(0)); maxchans = 0; for (i = 0; i < n; i++) { curchan = NumChans; maxchans = Read_All_Channels(Get_String_Arg("inputs",i),maxchans); int channelsInCurrentFile=NumChans-curchan; { Size_Type sum, max; Indx_Type p; int j, wch; uint16 *val; max = -1; for (j = curchan; j < NumChans; j++) { val = AUINT16(Images[j]); sum = 0; for (p = 0; p < Images[j]->size; p++) sum += val[p]; if (sum > max) { max = sum; wch = j; } } fprintf(output,"%s\n",Get_String_Arg("inputs",i)); j = wch-curchan; fwrite(&j,sizeof(int),1,output); #ifdef PROGRESS printf("\n Eliminating channel %d from %s\n",j+1,Get_String_Arg("inputs",i)); fflush(stdout); #endif { // Section to write out the reference channel printf("\n Considering reference channel output, channelsInCurrentFile=%d\n", channelsInCurrentFile); fflush(stdout); if (channelsInCurrentFile>2) { // should work with both lsm pair with channels=3, or raw file with channels=4 sprintf(NameBuf,"%s/Reference.tif",RezFolder,CoreName,i); Write_Image(NameBuf,Images[wch],LZW_PRESS); } } Free_Array(Images[wch]); NumChans -= 1; for (j = wch; j < NumChans; j++) Images[j] = Images[j+1]; } { int j, ceil; Indx_Type p; uint16 *val; for (j = curchan; j < NumChans; j++) { Histagain_Array(hist,Images[j],0); ceil = Percentile2Bin(hist,1e-5); if (ceil==0) { fprintf(stderr, "Channel must have non-zero values for this program to function\n"); exit(1); } #ifdef PROGRESS printf(" Clipping channel %d at ceil = %d\n",j,ceil); fflush(stdout); fflush(stdout); #endif val = AUINT16(Images[j]); for (p = 0; p < Images[j]->size; p++) { if (val[p] > ceil) val[p] = ceil; val[p] = (val[p]*4095)/ceil; } // Convert_Array_Inplace(Images[j],PLAIN_KIND,UINT8_TYPE,8,0); } } } Free_Histogram(hist); printf("Starting ConsolidatedSignal.tif section\n"); fflush(stdout); // NA addition: write tif with re-scaled intensities to serve as basis for mask file { Array *signalStack; signalStack = Make_Array(RGB_KIND,UINT8_TYPE,3,Images[0]->dims); uint8 *sp=AUINT8(signalStack); int m; Indx_Type signalIndex; signalIndex=0; for (m=0;m<NumChans;m++) { sprintf(NameBuf, "%s/Signal_%d.tif", RezFolder, m); printf("Writing 16-bit channel file %s...", NameBuf); Write_Image(NameBuf, Images[m], LZW_PRESS); printf("done\n"); uint16 *ip=AUINT16(Images[m]); Indx_Type channelIndex; for (channelIndex=0;channelIndex<Images[m]->size;channelIndex++) { int value=ip[channelIndex]/16; if (value>255) { value=255; } sp[signalIndex++]=value; // convert 12-bit to 8-bit } } sprintf(NameBuf,"%s/ConsolidatedSignal.tif", RezFolder); printf("Writing 8-bit consolidated signal file %s...", NameBuf); Write_Image(NameBuf,signalStack,LZW_PRESS); printf("done"); //Free_Array(signalStack); - this is causing a bug } printf("Finished ConsolidatedSignal.tif section\n"); fflush(stdout); } { int i; Segmentation *segs; Overlaps *ovl; Clusters *clust; int numneur; Region **neurons; segs = (Segmentation *) Guarded_Malloc(sizeof(Segmentation)*NumChans,Program_Name()); for (i = 0; i < NumChans; i++) { Segment_Channel(Images[i],segs+i); if (i == 0) segs[i].base = 0; else segs[i].base = segs[i-1].base + segs[i-1].nsegs; printf("channel=%d segmentBase=%d\n", i, segs[i].base); } ovl = Find_Overlaps(segs); clust = Merge_Segments(segs,ovl); neurons = Segment_Clusters(segs,ovl,clust,&numneur); if (Is_Arg_Matched("-gp")) Output_Clusters(segs,ovl,clust); if (Is_Arg_Matched("-nr")) Output_Neurons(numneur,neurons,1); // Added for NA Output_Consolidated_Mask(numneur,neurons,1); fwrite(&numneur,sizeof(int),1,output); for (i = 0; i < numneur; i++) Write_Region(neurons[i],output); #ifdef PROGRESS printf("\nProduced %d neurons/fragments in %s.neu\n",numneur,CoreName); fflush(stdout); #endif printf("DEBUG: starting cleanup\n"); fflush(stdout); for (i = 0; i < numneur; i++) { printf("DEBUG: calling Kill_Region on neuron=%d\n", i); fflush(stdout); Kill_Region(neurons[i]); } printf("DEBUG: calling Kill_Clusters\n"); fflush(stdout); Kill_Clusters(clust); printf("DEBUG: calling Kill_Overlaps\n"); fflush(stdout); //Kill_Overlaps(ovl); - causing a bug printf("DEBUG: starting Kill_Segmentation loop\n"); fflush(stdout); for (i = 0; i < NumChans; i++) { printf("DEBUG: Kill_Segmentation on index=%d\n", i); fflush(stdout); Kill_Segmentation(segs+i); } printf("DEBUG: calling free() on segs\n"); fflush(stdout); free(segs); } printf("DEBUG: starting filestream cleanup\n"); fflush(stdout); { int i; fclose(output); free(CoreName); free(RezFolder); for (i = 0; i < NumChans; i++) Kill_Array(Images[i]); free(Images); } #ifdef VERBOSE printf("\nDid I free all arrays?:\n"); Print_Inuse_List(stdout,4); #endif exit (0); }
const char* ZArgumentProcessor::getStringArg(const char *arg, int index) { return Get_String_Arg(const_cast<char*>(arg), index); }
int main(int argc, char* argv[]) { int n_rows, count; Measurements *table,*cursor; double thresh, px2mm, low_px, high_px; int face_x, face_y; int follicle_thresh = 0, follicle_col = 4, follicle_high; int n_cursor; Process_Arguments( argc, argv, Spec, 0); if( Is_Arg_Matched("-h") | Is_Arg_Matched("--help") ) { Print_Argument_Usage(stdout,0); printf("-------------------------- \n" " Classify 4 (radius filter) \n" "--------------------------- \n" " \n" " Uses a length threshold to seperate hair/microvibrissae from main whiskers. \n" " Then, for frames where the expected number of whiskers are found, \n" " label the whiskers according to their order on the face. \n" "\n" " This version of classify filters out curves where the follicle side falls \n" " outside of a circle centered at the face position with the radius specified \n" " by the --follicle option." "\n" " <source> Filename with Measurements table.\n" " <dest> Filename to which labelled Measurements will be saved.\n" " This can be the same as <source>.\n" " <faceX> <faceY> <faceAxis>\n" " These are used for determining the order of whisker segments along \n" " the face. This requires an approximate position for the center of \n" " the face and can be specified in pixel coordinates with <x> and <y>.\n" " <axis> indicates the orientaiton of the face. Values for <axis> may\n" " be 'x' or 'h' for horizontal. 'y' or 'v' indicate a vertical face. \n" " If the face is located along the edge of the frame then specify \n" " that edge with 'left', 'right', 'top' or 'bottom'. \n" " --px2mm <double>\n" " The length of a pixel in millimeters. This is used to determine \n" " appropriate thresholds for discriminating hairs from whiskers. \n" " -n <int> (Optional) Optimize the threshold to find this number of whiskers. \n" " If this isn't specified, or if this is set to a number less than 1 \n" " then the number of whiskers is automatically determined. \n" " --follicle <int>\n" " Only count follicles that lie inside a circle with this radius in \n" " (in pixels) and centered at the face position as whiskers. \n" "-- \n"); return 0; } px2mm = Get_Double_Arg("--px2mm"); low_px = Get_Double_Arg("--limit",1) / px2mm; high_px = Get_Double_Arg("--limit",2) / px2mm; #ifdef DEBUG_CLASSIFY_4 debug("mm/px %f\n" " low %f\n" " high %f\n", px2mm, low_px, high_px ); #endif table = Measurements_Table_From_Filename ( Get_String_Arg("source"), NULL, &n_rows ); if(!table) error("Couldn't read %s\n",Get_String_Arg("source")); Sort_Measurements_Table_Time(table,n_rows); { int maxx,maxy; const char *axis = Get_String_Arg("faceAxis"); static const int x = 4, y = 5; Measurements_Table_Pixel_Support( table, n_rows, &maxx, &maxy ); face_x = Get_Int_Arg("faceX"); face_y = Get_Int_Arg("faceY"); follicle_thresh = 0; // set defaults if( Is_Arg_Matched("--follicle") && Get_Int_Arg("--follicle")>0 ) { follicle_thresh = Get_Int_Arg("--follicle"); switch( axis[0] ) // respond to <follicle> option { case 'x': // follicle must be between threshold and face case 'h': case 'y': case 'v': break; default: error("Could not recognize <axis>. Must be 'x','h','y', or 'v'. Got %s\n",axis); } } } // Follicle location threshold if( Is_Arg_Matched("--follicle") && Get_Int_Arg("--follicle")>0 ) follicle_thresh = Get_Int_Arg("--follicle"); //inline void Measurements_Table_Label_By_RadialThreshold( Measurements *table, int n_rows, double thresh, int ox, int oy, int colx, int coly) Measurements_Table_Label_By_RadialThreshold( table, n_rows, follicle_thresh, face_x, face_y, follicle_col, follicle_col+1); #ifdef DEBUG_CLASSIFY_4 debug(" Face Position: ( %3d, %3d )\n", face_x, face_y); #endif // Shuffle to select subset with good follicles Sort_Measurements_Table_State_Time( table, n_rows ); { cursor = table; while( (cursor->state == 0) && (cursor < table+n_rows ) ) cursor++; n_cursor = n_rows - (cursor-table); } Sort_Measurements_Table_Time(cursor,n_cursor); //resort selected by time #ifdef DEBUG_CLASSIFY_1 { Measurements *row = cursor + n_cursor; //Assert all state==1 while(row-- > cursor) assert(row->state == 1); } #endif // // Estimate best length threshold and apply // if( Is_Arg_Matched("-n") && ( (count = Get_Int_Arg("-n"))>=1 ) ) { thresh = Measurements_Table_Estimate_Best_Threshold_For_Known_Count( cursor, //table, n_cursor, //n_rows, 0 /*length column*/, low_px, high_px, 1, /*use > */ count ); } else { thresh = Measurements_Table_Estimate_Best_Threshold( cursor, //table, n_cursor, //n_rows, 0 /*length column*/, low_px, high_px, 1, /* use > */ &count ); } /* Measurements_Table_Label_By_Threshold ( cursor, n_cursor, follicle_col, follicle_thresh, is_gt); */ Measurements_Table_Label_By_RadialThreshold( table, n_rows, follicle_thresh, face_x, face_y, follicle_col, follicle_col+1); #ifdef DEBUG_CLASSIFY_4 { Measurements *row = cursor + n_cursor; //Assert all state==1 while(row-- > cursor) assert(row->state == 1); } #endif Measurements_Table_Label_By_Threshold_And ( cursor, n_cursor, 0 /*length column*/, thresh, 1 /*use gt*/); #ifdef DEBUG_CLASSIFY_4 debug(" Length threshold: %f\n" " Target count: %d\n", thresh,count); #endif Measurements_Table_Set_Constant_Face_Position ( table, n_rows, face_x, face_y); Measurements_Table_Set_Follicle_Position_Indices ( table, n_rows, 4, 5 ); Measurements_Table_Label_By_Order(table, n_rows, count ); //re-sorts Measurements_Table_To_Filename( Get_String_Arg("dest"), NULL, table, n_rows ); Free_Measurements_Table(table); return 0; }
int main(int argc, char *argv[]) { char *whisker_file_name, *bar_file_name, *prefix; size_t prefix_len; FILE *fp; Image *bg=0, *image=0; int i,depth; char * movie; /* Process Arguments */ Process_Arguments(argc,argv,Spec,0); { char* paramfile = "default.parameters"; if(Load_Params_File("default.parameters")) { warning( "Could not load parameters from file: %s\n" "Writing %s\n" "\tTrying again\n",paramfile,paramfile); Print_Params_File(paramfile); if(Load_Params_File("default.parameters")) error("\tStill could not load parameters.\n"); } } prefix = Get_String_Arg("prefix"); prefix_len = strlen(prefix); { char *dot = strrchr(prefix,'.'); // Remove any file extension from the prefix if(dot) *dot = 0; } whisker_file_name = (char*) Guarded_Malloc( (prefix_len+32)*sizeof(char), "whisker file name"); bar_file_name = (char*) Guarded_Malloc( (prefix_len+32)*sizeof(char), "bar file name"); memset(whisker_file_name, 0, (prefix_len+32)*sizeof(char) ); memset(bar_file_name , 0, (prefix_len+32)*sizeof(char) ); sprintf( whisker_file_name, "%s.whiskers", prefix ); sprintf( bar_file_name, "%s.bar", prefix ); progress("Loading...\n"); fflush(stdout); movie = Get_String_Arg("movie"); TRY(image = load(movie,0,&depth),ErrorOpen); progress("Done.\n"); // No background subtraction (init to blank) { bg = Make_Image( image->kind, image->width, image->height ); memset(bg->array, 0, bg->width * bg->height ); } Free_Image( image ); #if 0 /* * Bar tracking */ if( !Is_Arg_Matched("--no-bar") ) { double x,y; BarFile *bfile = Bar_File_Open( bar_file_name, "w" ); progress( "Finding bar positions\n" ); for( i=0; i<depth; i++ ) { progress_meter(i, 0, depth-1, 79, "Finding post: [%5d/%5d]",i,depth); image = load(movie,i,NULL); invert_uint8( image ); Compute_Bar_Location( image, &x, // Output: x position &y, // Output: y position 15, // Neighbor distance 15, // minimum contour length 0, // minimum intensity of interest 255, // maximum intentity of interest 10.0, // minimum radius of interest 30.0 );// maximum radius of interest Bar_File_Append_Bar( bfile, Bar_Static_Cast(i,x,y) ); Free_Image(image); } Bar_File_Close( bfile ); } #endif /* * Trace whisker segments */ //if( !Is_Arg_Matched("--no-whisk") ) { int nTotalSegs = 0; Whisker_Seg *wv; int wv_n; WhiskerFile wfile = Whisker_File_Open(whisker_file_name,"whiskbin1","w"); if( !wfile ) { fprintf(stderr, "Warning: couldn't open %s for writing.", whisker_file_name); } else { //int step = (int) pow(10,round(log10(depth/100))); for( i=0; i<depth; i++ ) //for( i=450; i<460; i++ ) //for( i=0; i<depth; i+= step ) { int k; TRY(image=load(movie,i,NULL),ErrorRead); progress_meter(i, 0, depth, 79, "Finding segments: [%5d/%5d]",i,depth-1); wv = find_segments(i, image, bg, &wv_n); // Thrashing heap k = Remove_Overlapping_Whiskers_One_Frame( wv, wv_n, image->width, image->height, 2.0, // scale down by this 2.0, // distance threshold 0.5 ); // significant overlap fraction Whisker_File_Append_Segments(wfile, wv, k); Free_Whisker_Seg_Vec( wv, wv_n ); Free_Image(image); } printf("\n"); Whisker_File_Close(wfile); } } load(movie,-1,NULL); // Close (and free) if(bg) Free_Image( bg ); return 0; ErrorRead: load(movie,-1,NULL); // Close (and free) if(bg) Free_Image( bg ); error("Could not read frame %d from %s"ENDL,i,movie); return 1; ErrorOpen: error("Could not open %s"ENDL,movie); return 2; }
int main(int argc, char *argv[]) { static char *Spec[] = {"[-root_id <int>] [<input:string>]", "[-a <string>] [-b <string>]", "[-stitch_script] [-exclude <string>] [-tile_number <int>]", NULL}; Process_Arguments(argc, argv, Spec, 1); int *excluded = NULL; int nexc = 0; int *excluded_pair = NULL; int nexcpair = 0; if (Is_Arg_Matched("-exclude")) { String_Workspace *sw = New_String_Workspace(); FILE *fp = fopen(Get_String_Arg("-exclude"), "r"); char *line = Read_Line(fp, sw); excluded = String_To_Integer_Array(line, NULL, &nexc); line = Read_Line(fp, sw); if (line != NULL) { excluded_pair = String_To_Integer_Array(line, NULL, &nexcpair); nexcpair /= 2; } Kill_String_Workspace(sw); fclose(fp); } int n = 0; Graph *graph = Make_Graph(n + 1, n, TRUE); char filepath1[100]; char filepath2[100]; int i, j; Stack *stack1 = NULL; FILE *fp = NULL; if (Is_Arg_Matched("-stitch_script")) { Cuboid_I *boxes = read_tile_array(Get_String_Arg("-a"), &n); for (i = 0; i < n; i++) { for (j = i + 1; j < n; j++) { BOOL is_excluded = FALSE; int k; for (k = 0; k < nexc; k++) { if ((i == excluded[k] - 1) || (j == excluded[k] - 1)) { is_excluded = TRUE; break; } } for (k = 0; k < nexcpair; k++) { if (((i == excluded_pair[k*2]) && (j == excluded_pair[k*2+1])) || ((j == excluded_pair[k*2]) && (i == excluded_pair[k*2+1]))) { is_excluded = TRUE; break; } } /* if ((i != 103) && (j != 103) && (i != 115) && (j != 115) && (i != 59) && (j != 59) && !(i == 116 && j == 116)) { */ if (is_excluded == FALSE) { Cuboid_I_Overlap_Volume(boxes + i, boxes + j); Cuboid_I ibox; Cuboid_I_Intersect(boxes + i, boxes + j, &ibox); int width, height, depth; Cuboid_I_Size(&ibox, &width, &height, &depth); if ((imax2(width, height) > 1024 / 3) && (imin2(width, height) > 0)) { sprintf(filepath1, "%s/stack/%03d.xml", Get_String_Arg("input"), i + 1); sprintf(filepath2, "%s/stack/%03d.xml", Get_String_Arg("input"), j + 1); if (stack1 == NULL) { stack1 = Read_Stack_U(filepath1); } Stack *stack2 = Read_Stack_U(filepath2); Stack *substack1= Crop_Stack(stack1, ibox.cb[0] - boxes[i].cb[0], ibox.cb[1] - boxes[i].cb[1], 0, width, height, stack1->depth, NULL); Stack *substack2 = Crop_Stack(stack2, ibox.cb[0] - boxes[j].cb[0], ibox.cb[1] - boxes[j].cb[1], 0, width, height, stack2->depth, NULL); Image *img1 = Proj_Stack_Zmax(substack1); Image *img2 = Proj_Stack_Zmax(substack2); double w = u16array_corrcoef((uint16_t*) img1->array, (uint16_t*) img2->array, img1->width * img1->height); Kill_Stack(stack2); Kill_Stack(substack1); Kill_Stack(substack2); Kill_Image(img1); Kill_Image(img2); printf("%d, %d : %g\n", i + 1, j + 1, w); Graph_Add_Weighted_Edge(graph, i + 1, j + 1, 1000.0 / (w + 1.0)); } } if (stack1 != NULL) { Kill_Stack(stack1); stack1 = NULL; } } } Graph_Workspace *gw = New_Graph_Workspace(); Graph_To_Mst2(graph, gw); Arrayqueue q = Graph_Traverse_B(graph, Get_Int_Arg("-root_id"), gw); Print_Arrayqueue(&q); int *grown = iarray_malloc(graph->nvertex); for (i = 0; i < graph->nvertex; i++) { grown[i] = 0; } int index = Arrayqueue_Dequeue(&q); grown[index] = 1; char stitch_p_file[5][500]; FILE *pfp[5]; for (i = 0; i < 5; i++) { sprintf(stitch_p_file[i], "%s/stitch/stitch_%d.sh", Get_String_Arg("input"), i); pfp[i] = fopen(stitch_p_file[i], "w"); } sprintf(filepath1, "%s/stitch/stitch_all.sh", Get_String_Arg("input")); fp = GUARDED_FOPEN(filepath1, "w"); fprintf(fp, "#!/bin/bash\n"); int count = 0; while ((index = Arrayqueue_Dequeue(&q)) > 0) { for (i = 0; i < graph->nedge; i++) { int index2 = -1; if (index == graph->edges[i][0]) { index2 = graph->edges[i][1]; } else if (index == graph->edges[i][1]) { index2 = graph->edges[i][0]; } if (index2 > 0) { if (grown[index2] == 1) { char cmd[500]; sprintf(filepath2, "%s/stitch/%03d_%03d_pos.txt", Get_String_Arg("input"), index2, index); sprintf(cmd, "%s/stitchstack %s/stack/%03d.xml %s/stack/%03d.xml -o %s", Get_String_Arg("-b"), Get_String_Arg("input"), index2, Get_String_Arg("input"), index, filepath2); fprintf(fp, "%s\n", cmd); count++; fprintf(pfp[count%5], "%s\n", cmd); /* if (!fexist(filepath2)) { system(cmd); } */ grown[index] = 1; break; } } } } fclose(fp); for (i = 0; i < 5; i++) { fprintf(pfp[i], "touch %s/stitch/stitch_%d_done\n", Get_String_Arg("input"), i); fclose(pfp[i]); } return 0; } sprintf(filepath1, "%s/stitch/stitch_all.sh", Get_String_Arg("input")); fp = GUARDED_FOPEN(filepath1, "r"); //#define MAX_TILE_INDEX 153 int tile_number = Get_Int_Arg("-tile_number"); int max_tile_index = tile_number + 1; char *line = NULL; String_Workspace *sw = New_String_Workspace(); int id[2]; char filepath[100]; int offset[max_tile_index][3]; int relative_offset[max_tile_index][3]; int array[max_tile_index]; for (i = 0; i < max_tile_index; i++) { array[i] = -1; offset[i][0] = 0; offset[i][1] = 0; offset[i][2] = 0; relative_offset[i][0] = 0; relative_offset[i][1] = 0; relative_offset[i][2] = 0; } while ((line = Read_Line(fp, sw)) != NULL) { char *remain = strsplit(line, ' ', 1); if (String_Ends_With(line, "stitchstack")) { String_To_Integer_Array(remain, id, &n); id[0] = id[1]; id[1] = id[3]; array[id[1]] = id[0]; sprintf(filepath, "%s/stitch/%03d_%03d_pos.txt", Get_String_Arg("input"), id[0], id[1]); if (!fexist(filepath)) { fprintf(stderr, "file %s does not exist\n", filepath); return 1; } FILE *fp2 = GUARDED_FOPEN(filepath, "r"); line = Read_Line(fp2, sw); line = Read_Line(fp2, sw); int tmpoffset[8]; String_To_Integer_Array(line, tmpoffset, &n); relative_offset[id[1]][0] = tmpoffset[2]; relative_offset[id[1]][1] = tmpoffset[3]; relative_offset[id[1]][2] = tmpoffset[4]; fclose(fp2); } } for (i = 1; i < max_tile_index; i++) { BOOL is_excluded = FALSE; int k; for (k = 0; k < nexc; k++) { if (i == excluded[k]) { is_excluded = TRUE; break; } } /*if ((i == 104) || (i == 116) || (i == 60) || (i == 152)) {*/ if (is_excluded) { printf("%d: (0, 0, 10000)\n", i); } else { int index = i; while (index >= 0) { offset[i][0] += relative_offset[index][0]; offset[i][1] += relative_offset[index][1]; offset[i][2] += relative_offset[index][2]; index = array[index]; } printf("%d: (%d, %d, %d)\n", i, offset[i][0], offset[i][1], offset[i][2]); } } fclose(fp); return 0; }
/* * trace_neuron - trace neuron from given seeds * * trace_neuron [!wtr] seed_file -Dsave_dir * -r: write intermediate results * */ int main(int argc, char* argv[]) { static char *Spec[] = { "[!wtr] [-canvas <string>] [-mask <string>] [-res <string>] [-minr <int>]", "-minlen <double>", " <image:string> -S<string> -D<string>", NULL}; Process_Arguments(argc, argv, Spec, 1); char *dir = Get_String_Arg("-D"); char file_path[100]; sprintf(file_path, "%s/%s", dir, Get_String_Arg("-S")); printf("%s\n", file_path); Geo3d_Scalar_Field *seed = Read_Geo3d_Scalar_Field(file_path); int idx; sprintf(file_path, "%s/%s.bn", dir, "max_r"); double max_r; int tmp; if (fexist(file_path)) { darray_read2(file_path, &max_r, &tmp); } else { max_r = darray_max(seed->values, seed->size, &idx); } printf("%g\n", max_r); max_r *= 1.5; /* sprintf(file_path, "%s/%s", dir, "soma0.bn"); if (!fexist(file_path)) { max_r *= 2.0; } */ Set_Neuroseg_Max_Radius(max_r); Stack *signal = Read_Stack(Get_String_Arg("image")); dim_type dim[3]; dim[0] = signal->width; dim[1] = signal->height; dim[2] = signal->depth; /* IMatrix *chord = Make_IMatrix(dim, 3); Stack *code = Make_Stack(GREY16, signal->width, signal->height, signal->depth); */ Rgb_Color color; Set_Color(&color, 255, 0, 0); Stack *canvas = NULL; char trace_file_path[100]; sprintf(trace_file_path, "%s/%s", dir, Get_String_Arg("-canvas")); if (fexist(trace_file_path) == 1) { canvas = Read_Stack((char *) trace_file_path); } else { canvas = Copy_Stack(signal); Stretch_Stack_Value_Q(canvas, 0.999); Translate_Stack(canvas, COLOR, 1); } Stack *traced = NULL; char trace_mask_path[100]; sprintf(trace_mask_path, "%s/%s", dir, Get_String_Arg("-mask")); if (fexist(trace_mask_path) == 1) { traced = Read_Stack((char *) trace_mask_path); } else { traced = Make_Stack(GREY, signal->width, signal->height, signal->depth); One_Stack(traced); } //Object_3d *obj = NULL; int seed_offset = -1; Neurochain *chain = NULL; double z_scale = 1.0; if (Is_Arg_Matched("-res")) { sprintf(file_path, "%s", Get_String_Arg("-res")); if (fexist(file_path)) { double res[3]; int length; darray_read2(file_path, res, &length); if (res[0] != res[1]) { perror("Different X-Y resolutions."); TZ_ERROR(ERROR_DATA_VALUE); } z_scale = res[0] / res[2]; } } //sprintf(file_path, "%s/%s", dir, Get_String_Arg("-M")); //Stack *stack = Read_Stack(file_path); tic(); FILE *fp = NULL; char chain_file_path[100]; char vrml_file_path[100]; double min_chain_length = 25.0; if (Is_Arg_Matched("-minlen")) { min_chain_length = Get_Double_Arg("-minlen"); } int *indices = iarray_malloc(seed->size); double *values = darray_malloc(seed->size); int i; Local_Neuroseg *locseg = (Local_Neuroseg *) malloc(seed->size * sizeof(Local_Neuroseg)); int index = 0; for (i = 0; i < seed->size; i++) { printf("-----------------------------> seed: %d / %d\n", i, seed->size); indices[i] = i; index = i; int x = (int) seed->points[index][0]; int y = (int) seed->points[index][1]; int z = (int) seed->points[index][2]; double width = seed->values[index]; chain = New_Neurochain(); seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height, signal->depth); if (width < 3.0) { width += 0.5; } Set_Neuroseg(&(locseg[i].seg), width, width, 12.0, 0.0, 0.0, 0.0); double cpos[3]; cpos[0] = x; cpos[1] = y; cpos[2] = z; cpos[2] *= z_scale; Set_Neuroseg_Position(&(locseg[i]), cpos, NEUROSEG_CENTER); Stack_Fit_Score fs; fs.n = 1; fs.options[0] = 1; values[i] = Local_Neuroseg_Orientation_Search_C(&(locseg[i]), signal, z_scale, &fs); } darray_qsort(values, indices, seed->size); /* for (i = 0; i < seed->size; i++) { indices[i] = i; } darraycpy(values, seed->values, 0, seed->size); darray_qsort(values, indices, seed->size); */ int counter = 0; // for (i = seed->size - 1; i >= seed->size - 231; i--) { for (i = seed->size - 1; i >= 0; i--) { index = indices[i]; printf("-----------------------------> seed: %d / %d\n", i, seed->size); sprintf(chain_file_path, "%s/chain%d.bn", dir, index); sprintf(vrml_file_path, "%s/chain%d.wrl", dir, index); if (fexist(chain_file_path) == 1) { chain = Read_Neurochain(chain_file_path); if (Neurochain_Geolen(chain) >= min_chain_length) { Write_Neurochain_Vrml(vrml_file_path, chain); Neurochain_Label(canvas, chain, z_scale); Neurochain_Erase_E(traced, chain, z_scale, 0, Neurochain_Length(chain, FORWARD), 1.5, 0.0); } Free_Neurochain(chain); printf("chain exists\n"); continue; } int x = (int) seed->points[index][0]; int y = (int) seed->points[index][1]; int z = (int) seed->points[index][2]; if (*STACK_PIXEL_8(traced, x, y, z, 0) == 0) { printf("traced \n"); continue; } double width = seed->values[index]; if (width > max_r) { printf("too thick\n"); continue; } if (Is_Arg_Matched("-minr")) { int max_level = (int) (width + 0.5); if (max_level <= Get_Int_Arg("-minr")) { printf("too thin\n"); continue; } } /* seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height, signal->depth); */ chain = New_Neurochain(); /* Stack_Level_Code_Constraint(stack, code, chord->array, &seed_offset, 1, max_level + 1); Voxel_t v; v[0] = x; v[1] = y; v[2] = z; Stack *tmp_stack = Copy_Stack(stack); obj = Stack_Grow_Object_Constraint(tmp_stack, 1, v, chord, code, max_level); Free_Stack(tmp_stack); Print_Object_3d_Info(obj); double vec[3]; Object_3d_Orientation_Zscale(obj, vec, MAJOR_AXIS, z_scale); double theta, psi; Geo3d_Vector obj_vec; Set_Geo3d_Vector(&obj_vec, vec[0], vec[1], vec[2]); Geo3d_Vector_Orientation(&obj_vec, &theta, &psi); */ /* if (width < 3.0) { width += 0.5; } Set_Neuroseg(&(chain->locseg.seg), width, width, 12.0, 0.0, 0.0, 0.0); double cpos[3]; cpos[0] = x; cpos[1] = y; cpos[2] = z; cpos[2] *= z_scale; //Set_Neuroseg_Position(&(chain->locseg), cpos, NEUROSEG_BOTTOM); Set_Neuroseg_Position(&(chain->locseg), cpos, NEUROSEG_CENTER); Stack_Fit_Score fs; fs.n = 1; fs.options[0] = 1; Local_Neuroseg_Orientation_Search_C(&(chain->locseg), signal, z_scale, &fs); //fs.options[0] = 1; */ Copy_Local_Neuroseg(&(chain->locseg), &(locseg[index])); Neurochain *chain_head = chain; if (Initialize_Tracing(signal, chain, NULL, z_scale) >= MIN_SCORE) { if ((Neuroseg_Hit_Traced(&(chain->locseg), traced, z_scale) == FALSE) && (chain->locseg.seg.r1 < max_r) && (chain->locseg.seg.r2 < max_r)) { //Initialize_Tracing(signal, chain, NULL, z_scale); chain = Trace_Neuron2(signal, chain, BOTH, traced, z_scale, 500); //Neurochain *chain_head = Neurochain_Head(chain); chain_head = Neurochain_Remove_Overlap_Segs(chain); chain_head = Neurochain_Remove_Turn_Ends(chain_head, 0.5); /* if (i == seed->size - 231) { Print_Neurochain(chain_head); } */ fp = fopen(chain_file_path, "w"); Neurochain_Fwrite(chain_head, fp); fclose(fp); if (Neurochain_Geolen(chain_head) >= min_chain_length) { Write_Neurochain_Vrml(vrml_file_path, chain_head); Neurochain_Erase_E(traced, chain_head, z_scale, 0, Neurochain_Length(chain_head, FORWARD), 1.5, 0.0); Neurochain_Label(canvas, chain_head, z_scale); counter += Neurochain_Length(chain_head, FORWARD); if (counter > 500) { if (Is_Arg_Matched("-r")) { Write_Stack((char *) trace_mask_path, traced); } if (Is_Arg_Matched("-r")) { Write_Stack((char *) trace_file_path, canvas); } counter = 0; } } } } Free_Neurochain(chain_head); //Kill_Object_3d(obj); } Write_Stack((char *) trace_file_path, canvas); if (Is_Arg_Matched("-r")) { Write_Stack((char *) trace_mask_path, traced); } Kill_Geo3d_Scalar_Field(seed); printf("Time passed: %lld\n", toc()); return 0; }
int main(int argc, char* argv[]) { if (Show_Version(argc, argv, "1.00") == 1) { return 0; } static char *Spec[] = { " <image:string> -s <string> -o <string> [-e <string>] [-fo <int>] " "[-z <double> | -res <string>] [-field <int>] [-min_score <double>]", NULL}; Process_Arguments(argc, argv, Spec, 1); Geo3d_Scalar_Field *seed = Read_Geo3d_Scalar_Field(Get_String_Arg("-s")); size_t idx; double max_r = darray_max(seed->values, seed->size, &idx); max_r *= 1.5; //Set_Neuroseg_Max_Radius(max_r); Stack *signal = Read_Stack_U(Get_String_Arg("image")); dim_type dim[3]; dim[0] = signal->width; dim[1] = signal->height; dim[2] = signal->depth; Rgb_Color color; Set_Color(&color, 255, 0, 0); int seed_offset = -1; double z_scale = 1.0; if (Is_Arg_Matched("-res")) { if (fexist(Get_String_Arg("-res"))) { double res[3]; int length; darray_read2(Get_String_Arg("-res"), res, &length); if (res[0] != res[1]) { perror("Different X-Y resolutions."); TZ_ERROR(ERROR_DATA_VALUE); } z_scale = res[0] / res[2] * 2.0; } } if (Is_Arg_Matched("-z")) { z_scale = Get_Double_Arg("-z"); } printf("z scale: %g\n", z_scale); tic(); double *values = darray_malloc(seed->size); int i; Local_Neuroseg *locseg = (Local_Neuroseg *) malloc(seed->size * sizeof(Local_Neuroseg)); int index = 0; //int ncol = LOCAL_NEUROSEG_NPARAM + 1 + 23; //double *features = darray_malloc(seed->size * ncol); //double *tmpfeats = features; Stack *seed_mask = Make_Stack(GREY, signal->width, signal->height, signal->depth); Zero_Stack(seed_mask); Locseg_Fit_Workspace *fws = New_Locseg_Fit_Workspace(); if (Is_Arg_Matched("-field")) { fws->sws->field_func = Neuroseg_Slice_Field_Func(Get_Int_Arg("-field")); } fws->sws->fs.n = 2; fws->sws->fs.options[0] = STACK_FIT_DOT; fws->sws->fs.options[1] = STACK_FIT_CORRCOEF; if (Is_Arg_Matched("-fo")) { fws->sws->fs.options[1] = Get_Int_Arg("-fo"); } for (i = 0; i < seed->size; i++) { printf("-----------------------------> seed: %d / %d\n", i, seed->size); index = i; int x = (int) seed->points[index][0]; int y = (int) seed->points[index][1]; int z = (int) seed->points[index][2]; double width = seed->values[index]; seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height, signal->depth); if (width < 3.0) { width += 0.5; } Set_Neuroseg(&(locseg[i].seg), width, 0.0, NEUROSEG_DEFAULT_H, 0.0, 0.0, 0.0, 0.0, 1.0); double cpos[3]; cpos[0] = x; cpos[1] = y; cpos[2] = z; cpos[2] /= z_scale; Set_Neuroseg_Position(&(locseg[i]), cpos, NEUROSEG_CENTER); if (seed_mask->array[seed_offset] > 0) { printf("labeled\n"); values[i] = 0.0; continue; } //Local_Neuroseg_Optimize(locseg + i, signal, z_scale, 0); Local_Neuroseg_Optimize_W(locseg + i, signal, z_scale, 0, fws); values[i] = fws->sws->fs.scores[1]; /* Stack_Fit_Score fs; fs.n = 1; fs.options[0] = 1; values[i] = Local_Neuroseg_Score(locseg + i, signal, z_scale, &fs); */ //values[i] = Local_Neuroseg_Score_W(locseg + i, signal, z_scale, sws); printf("%g\n", values[i]); double min_score = LOCAL_NEUROSEG_MIN_CORRCOEF; if (Is_Arg_Matched("-min_score")) { min_score = Get_Double_Arg("-min_score"); } if (values[i] > min_score) { Local_Neuroseg_Label_G(locseg + i, seed_mask, -1, 2, z_scale); } else { Local_Neuroseg_Label_G(locseg + i, seed_mask, -1, 1, z_scale); } /* tmpfeats += Local_Neuroseg_Param_Array(locseg + i, z_scale, tmpfeats); tmpfeats += Local_Neuroseg_Stack_Feature(locseg + i, signal, z_scale, tmpfeats); */ } if (Is_Arg_Matched("-e")) { Write_Stack(Get_String_Arg("-e"), seed_mask); } Write_Local_Neuroseg_Array(Get_String_Arg("-o"), locseg, seed->size); char file_path[MAX_PATH_LENGTH]; sprintf(file_path, "%s_score", Get_String_Arg("-o")); darray_write(file_path, values, seed->size); //sprintf(file_path, "%s_feat", Get_String_Arg("-o")); //darray_write(file_path, features, seed->size * ncol); Kill_Geo3d_Scalar_Field(seed); printf("Time passed: %lld\n", toc()); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string> -o <string>", "[-count <int>] [-dist <int>] [-minobj <int>]", NULL}; Process_Arguments(argc, argv, Spec, 1); Stack *input = Read_Stack(Get_String_Arg("input")); int nregion = Stack_Max(input, NULL); int nvoxel = Stack_Voxel_Number(input); int i; Stack *stack = Make_Stack(GREY, Stack_Width(input), Stack_Height(input), Stack_Depth(input)); Stack *out = Make_Stack(GREY, Stack_Width(input), Stack_Height(input), Stack_Depth(input)); Zero_Stack(out); int nobj = 0; for (i = 1; i <= nregion; i++) { int j; int count = 0; for (j = 0; j < nvoxel; j++) { stack->array[j] = (input->array[j] == i); } Stack *out3 = NULL; int maxcount = 100000; if (Is_Arg_Matched("-count")) { maxcount = Get_Int_Arg("-count"); } if (count > maxcount) { out3 = Copy_Stack(stack); Stack_Addc_M(out3, nobj); nobj++; } else { Stack *distmap = Stack_Bwdist_L_U16P(stack, NULL, 0); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Copy_Stack(distmap); int mindist = 10; if (Is_Arg_Matched("-dist")) { mindist = Get_Int_Arg("-dist"); } Stack_Threshold_Binarize(ws->mask, mindist); Translate_Stack(ws->mask, GREY, 1); int minobj = 100; if (Is_Arg_Matched("-minobj")) { minobj = Get_Int_Arg("-minobj"); } Object_3d_List *objs = Stack_Find_Object(ws->mask, 1, minobj); Zero_Stack(ws->mask); Stack_Draw_Objects_Bw(ws->mask, objs, -255); ws->min_level = 1; ws->start_level = 65535; out3 = Stack_Watershed(distmap, ws); Stack_Addc_M(out3, nobj); nobj += Object_3d_List_Length(objs); Kill_Stack(distmap); Kill_Stack_Watershed_Workspace(ws); Kill_Object_3d_List(objs); } Stack_Add(out, out3, out); Kill_Stack(out3); } printf("number of regions: %d\n", nobj); Write_Stack(Get_String_Arg("-o"), out); char cmd[500]; sprintf(cmd, "touch %s_done", Get_String_Arg("-o")); system(cmd); return 0; }
int main(int argc, char *argv[]) { if (Show_Version(argc, argv, "1.0") == 1) { return 0; } static char *Spec[] = { "[-R<string> -T<string> -M<string>] -D<string> [-minlen <double>]", "[-root <double> <double> <double>] [-trans <double> <double> <double>]", "[-rtlist <string>] [-sup_root] [-dist <double>]", "[-C<string>] [-I<string>] [-z <double>] -o <string> [-b] [-res <string>]", "[-screen] [-sp] [-intp] [-sl] [-rb] [-rz] [-rs] [-ct] [-al <double>]", "[-screenz <double>] [-force_merge <double>] [-ct_break <double>]", "[-jumpz <double>] [-single_break]", NULL}; Print_Arguments(argc, argv); Process_Arguments(argc, argv, Spec, 1); char *dir = Get_String_Arg("-D"); Stack_Document *stack_doc = NULL; if (Is_Arg_Matched("-I")) { if (!fexist(Get_String_Arg("-I"))) { PRINT_EXCEPTION("File does not exist", ""); fprintf(stderr, "%s cannot be found.\n", Get_String_Arg("-I")); return 1; } if (fhasext(Get_String_Arg("-I"), "xml")) { stack_doc = Xml_Read_Stack_Document(Get_String_Arg("-I")); } } /* Get number of chains */ int chain_number2 = dir_fnum_p(dir, "^chain.*\\.tb"); if (chain_number2 == 0) { printf("No tube found.\n"); printf("Quit reconstruction.\n"); return 1; } int i; int *chain_map = iarray_malloc(chain_number2); int chain_number; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd(dir, "chain.*\\.tb", &chain_number, chain_map); if (Is_Arg_Matched("-screenz")) { Locseg_Chain_Array_Screen_Z(chain_array, chain_number, Get_Double_Arg("-screenz")); } if (Is_Arg_Matched("-single_break")) { int i; for (i = 0; i < chain_number; i++) { if (Locseg_Chain_Length(chain_array[i]) == 1) { /* break the segment into two parts */ Locseg_Chain_Break_Node(chain_array[i], 0, 0.5); } } } if (Is_Arg_Matched("-ct_break")) { int tmp_chain_number; Locseg_Chain **tmp_chain_array = Locseg_Chain_Array_Break_Jump(chain_array, chain_number, Get_Double_Arg("-ct_break"), &tmp_chain_number); kill_locseg_chain_array(chain_array, chain_number); chain_array = tmp_chain_array; chain_number = tmp_chain_number; } Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); if (Is_Arg_Matched("-res")) { FILE *fp = fopen(Get_String_Arg("-res"), "r"); if (fp != NULL) { if (darray_fscanf(fp, ctw->resolution, 3) != 3) { fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res")); ctw->resolution[0] = 1.0; ctw->resolution[1] = 1.0; ctw->resolution[2] = 1.0; } else { ctw->unit = 'u'; } fclose(fp); } else { fprintf(stderr, "Failed to load %s. The file may not exist.\n", Get_String_Arg("-res")); } } else if (stack_doc != NULL) { ctw->resolution[0] = stack_doc->resolution[0]; ctw->resolution[1] = stack_doc->resolution[1]; ctw->resolution[2] = stack_doc->resolution[2]; } if (Is_Arg_Matched("-force_merge")) { Connection_Test_Workspace *ws = New_Connection_Test_Workspace(); ws->dist_thre = Get_Double_Arg("-force_merge"); ws->interpolate = FALSE; ws->resolution[2] = ctw->resolution[2] / ctw->resolution[0]; for (i = 0; i < chain_number; i++) { //Locseg_Chain_Correct_Ends(chain_array[i]); } Locseg_Chain_Array_Force_Merge(chain_array, chain_number, ws); Kill_Connection_Test_Workspace(ws); } chain_number2 = 0; Neuron_Component *chain_array2; GUARDED_MALLOC_ARRAY(chain_array2, chain_number, Neuron_Component); for (i = 0; i < chain_number; i++) { if (Locseg_Chain_Is_Empty(chain_array[i]) == FALSE) { chain_map[chain_number2] = chain_map[i]; Set_Neuron_Component(chain_array2+(chain_number2++), NEUROCOMP_TYPE_LOCSEG_CHAIN, chain_array[i]); } else { printf("chain_%d is empty.\n", chain_map[i]); } } /* Dir_Locseg_Chain_Nc(dir, "^chain.*\\.tb", &chain_number2, chain_map); */ Stack *signal = NULL; //Stack *canvas = NULL; if (Is_Arg_Matched("-I")) { signal = Read_Stack_U(Get_String_Arg("-I")); //canvas = Translate_Stack(signal, COLOR, 0); } else { if (Is_Arg_Matched("-screen")) { perror("The -screen option requires -I option to be supplied.\n"); return 1; } } /* Minimal tube length. */ double minlen = 25.0; if (Is_Arg_Matched("-minlen")) { minlen = Get_Double_Arg("-minlen"); } chain_number = 0; //int i; if (signal != NULL) { ctw->mask = Make_Stack(GREY, signal->width, signal->height, signal->depth); One_Stack(ctw->mask); } FILE *result_file = fopen(full_path(dir, Get_String_Arg("-o")), "w"); double z_scale = 1.0; if (Is_Arg_Matched("-z")) { z_scale = Get_Double_Arg("-z"); } /* Array to store corrected chains */ Neuron_Component *chain_array_c = Make_Neuron_Component_Array(chain_number2); int screen = 0; double average_intensity = 0.0; if (Is_Arg_Matched("-screen")) { int good_chain_number = 0; int bad_chain_number = 0; for (i = 0; i < chain_number2; i++) { Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i); average_intensity += Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL); if ((Locseg_Chain_Geolen(chain) > 55) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.6)) { good_chain_number++; } else { bad_chain_number++; } } printf("good %d bad %d\n", good_chain_number, bad_chain_number); if (good_chain_number + bad_chain_number > 50) { if (bad_chain_number > good_chain_number) { screen = 1; } } else { screen = 3; /* if (bad_chain_number > good_chain_number * 2) { screen = 2; } */ } } average_intensity /= chain_number2; /* build chain map */ for (i = 0; i < chain_number2; i++) { Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i); BOOL good = FALSE; switch (screen) { case 1: case 2: if ((Locseg_Chain_Geolen(chain) > 100) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.6)) { good = TRUE; } else { if (Locseg_Chain_Geolen(chain) < 100) { if ((Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.5) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL) > average_intensity)) { good = TRUE; } } } break; case 3: if ((Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.50) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL) > average_intensity)) { good = TRUE; } break; default: good = TRUE; } if (good == TRUE) { if (Locseg_Chain_Geolen(chain) < minlen) { good = FALSE; } } if (good == TRUE) { Locseg_Chain *tmpchain = chain; if (signal != NULL) { //Locseg_Chain_Trace_Np(signal, 1.0, tmpchain, tw); Locseg_Chain_Erase(chain, ctw->mask, 1.0); } fprintf(result_file, "%d %d\n", chain_number, chain_map[i]); chain_map[chain_number] = chain_map[i]; if (z_scale != 1.0) { Locseg_Chain_Scale_Z(chain, z_scale); } Set_Neuron_Component(chain_array_c + chain_number, NEUROCOMP_TYPE_LOCSEG_CHAIN, tmpchain); chain_number++; } else { #ifdef _DEBUG_ printf("chain%d is excluded.\n", i); /* char tmpfile[500]; sprintf(tmpfile, "../data/diadem_c1/bad_chain/chain%d.tb", i); Write_Locseg_Chain(tmpfile, chain); */ #endif } } z_scale = 1.0; fprintf(result_file, "#\n"); //Int_Arraylist *hit_spots = Int_Arraylist_New(0, chain_number); /* reconstruct neuron */ if (Is_Arg_Matched("-res")) { FILE *fp = fopen(Get_String_Arg("-res"), "r"); if (fp != NULL) { if (darray_fscanf(fp, ctw->resolution, 3) != 3) { fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res")); ctw->resolution[0] = 1.0; ctw->resolution[1] = 1.0; ctw->resolution[2] = 1.0; } else { ctw->unit = 'u'; } fclose(fp); } else { fprintf(stderr, "Failed to load %s. The file may not exist.\n", Get_String_Arg("-res")); } } else if (stack_doc != NULL) { ctw->resolution[0] = stack_doc->resolution[0]; ctw->resolution[1] = stack_doc->resolution[1]; ctw->resolution[2] = stack_doc->resolution[2]; } if (!Is_Arg_Matched("-sp")) { ctw->sp_test = FALSE; if (ctw->sp_test == FALSE) { ctw->dist_thre = NEUROSEG_DEFAULT_H / 2.0; } } else { ctw->dist_thre = NEUROSEG_DEFAULT_H * 1.5; } if (Is_Arg_Matched("-dist")) { ctw->dist_thre = Get_Double_Arg("-dist"); } if (!Is_Arg_Matched("-intp")) { ctw->interpolate = FALSE; } //ctw->dist_thre = 100.0; double *tube_offset = NULL; if (Is_Arg_Matched("-trans")) { tube_offset = darray_malloc(3); tube_offset[0] = Get_Double_Arg("-trans", 1); tube_offset[1] = Get_Double_Arg("-trans", 2); tube_offset[2] = Get_Double_Arg("-trans", 3); } else { if (stack_doc != NULL) { tube_offset = darray_malloc(3); tube_offset[0] = stack_doc->offset[0]; tube_offset[1] = stack_doc->offset[1]; tube_offset[2] = stack_doc->offset[2]; } } Neuron_Structure *ns = New_Neuron_Structure(); ns->comp = chain_array_c; ns->graph = New_Graph(); ns->graph->nvertex = chain_number; if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { if (Is_Arg_Matched("-trans")) { roots[i][0] = d[i*3] - tube_offset[0]; roots[i][1] = d[i*3 + 1] - tube_offset[1]; roots[i][2] = d[i*3 + 2] - tube_offset[2]; } else { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; } } Neuron_Structure_Break_Root(ns, roots, n); Neuron_Structure_Load_Root(ns, roots, n); } } Locseg_Chain_Comp_Neurostruct_W(ns, signal, z_scale, ctw); if (tube_offset != NULL) { for (i = 0; i < chain_number; i++) { Locseg_Chain_Translate(NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i), tube_offset); } } /* Neuron_Structure *ns = Locseg_Chain_Comp_Neurostruct(chain_array, chain_number, signal, z_scale, ctw); */ FILE *tube_fp = fopen(full_path(dir, "tube.swc"), "w"); int start_id = 1; for (i = 0; i < chain_number; i++) { int node_type = i % 10; int n = Locseg_Chain_Swc_Fprint_T(tube_fp, NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i), node_type, start_id, -1, DL_FORWARD, 1.0, NULL); start_id += n; } fclose(tube_fp); //Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc")); /* Graph *testgraph = New_Graph(0, 0, FALSE); Int_Arraylist *cidx = Make_Int_Arraylist(0, 2); Int_Arraylist *sidx = Make_Int_Arraylist(0, 2); Locseg_Chain_Network_Simlify(&net, testgraph, cidx, sidx); */ /* Find branch points */ //Locseg_Chain *branches = Locseg_Chain_Network_Find_Branch(ns); //Graph *graph = Locseg_Chain_Graph(chain_array, chain_number, hit_spots); //Graph *graph = ns->graph; if (Is_Arg_Matched("-sup_root")) { if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; /* if (tube_offset != NULL) { roots[i][0] += tube_offset[0]; roots[i][1] += tube_offset[1]; roots[i][2] += tube_offset[2]; } */ } neuron_structure_suppress(ns, roots, n); free(roots); } } } Process_Neuron_Structure(ns); Print_Neuron_Structure(ns); #ifdef _DEBUG_ for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) { printf("chain_%d (%d) -- chain_%d (%d) ", chain_map[ns->graph->edges[i][0]], ns->graph->edges[i][0], chain_map[ns->graph->edges[i][1]], ns->graph->edges[i][1]); Print_Neurocomp_Conn(ns->conn + i); } #endif if (Is_Arg_Matched("-ct")) { Neuron_Structure_Crossover_Test(ns, ctw->resolution[0] / ctw->resolution[2]); } if (Is_Arg_Matched("-al")) { Neuron_Structure_Adjust_Link(ns, Get_Double_Arg("-al")); } Neuron_Structure_To_Tree(ns); Neuron_Structure_Remove_Negative_Conn(ns); #ifdef _DEBUG_ printf("\nTree:\n"); for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) { printf("chain_%d (%d) -- chain_%d (%d) ", chain_map[ns->graph->edges[i][0]], ns->graph->edges[i][0], chain_map[ns->graph->edges[i][1]], ns->graph->edges[i][1]); Print_Neurocomp_Conn(ns->conn + i); } #endif /* printf("\ncross over changed: \n"); Print_Neuron_Structure(ns); */ #ifdef _DEBUG_2 ns->graph->nedge = 0; Neuron_Structure_To_Swc_File(ns, "../data/test.swc"); return 1; #endif //Print_Neuron_Structure(ns); Neuron_Structure* ns2= NULL; if (Is_Arg_Matched("-intp")) { ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); } else { ns2 = Neuron_Structure_Locseg_Chain_To_Circle(ns); } /* Neuron_Structure* ns2= Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); */ Graph_To_Dot_File(ns2->graph, full_path(dir, "graph_d.dot")); //Neuron_Structure_Main_Graph(ns2); Neuron_Structure_To_Tree(ns2); double root[3]; if (Is_Arg_Matched("-root")) { root[0] = Get_Double_Arg("-root", 1); root[1] = Get_Double_Arg("-root", 2); root[2] = Get_Double_Arg("-root", 3); } Swc_Tree *tree = NULL; if (Is_Arg_Matched("-root")) { /* int root_index = Neuron_Structure_Find_Root_Circle(ns2, root); Graph_Workspace *gw2 = New_Graph_Workspace(); Graph_Clean_Root(ns2->graph, root_index, gw2); Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"), z_scale, root); */ tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, root); if (Swc_Tree_Node_Is_Virtual(tree->root) == TRUE) { tree->root->first_child->next_sibling = NULL; } Swc_Tree_Clean_Root(tree); } else { /* Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"), z_scale, NULL); */ tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, NULL); } ns->graph->nedge = 0; //Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc")); if (Is_Arg_Matched("-rb")) { //Swc_Tree_Tune_Branch(tree); Swc_Tree_Tune_Fork(tree); } if (Is_Arg_Matched("-sl")) { Swc_Tree_Leaf_Shrink(tree); } if (Is_Arg_Matched("-rz")) { Swc_Tree_Remove_Zigzag(tree); } if (Is_Arg_Matched("-rs")) { Swc_Tree_Remove_Spur(tree); } Swc_Tree_Resort_Id(tree); Write_Swc_Tree(full_path(dir, "graph_d.swc"), tree); if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; /* if (tube_offset != NULL) { roots[i][0] += tube_offset[0]; roots[i][1] += tube_offset[1]; roots[i][2] += tube_offset[2]; } */ Swc_Tree *subtree = Swc_Tree_Pull_R(tree, roots[i]); char filename[MAX_PATH_LENGTH]; if (subtree->root != NULL) { //Swc_Tree_Clean_Root(subtree); Swc_Tree_Clean_Root(subtree); Swc_Tree_Node_Set_Pos(subtree->root, roots[i]); if (Is_Arg_Matched("-jumpz")) { //swc_tree_remove_zjump(subtree, Get_Double_Arg("-jumpz")); } Swc_Tree_Resort_Id(subtree); sprintf(filename, "graph%d.swc", i + 1); Write_Swc_Tree(full_path(dir, filename), subtree); } } } } printf("%d chains\n", chain_number); return 0; }
int main(int argc, char* argv[]) { int n_rows, count; Measurements *table; int face_x, face_y; Process_Arguments( argc, argv, Spec, 0); if( Is_Arg_Matched("-h") | Is_Arg_Matched("--help") ) { Print_Argument_Usage(stdout,0); printf("----------------------------------------- \n" " Classify test 3 (autotraj - no threshold) \n" "------------------------------------------ \n" " \n" " For frames where the expected number of whiskers are found, \n" " label the whiskers according to their order on the face. \n" "\n" " <source> Filename with Measurements table.\n" " <dest> Filename to which labelled Measurements will be saved.\n" " This can be the same as <source>.\n" " <face>\n" " <x> <y> These are used for determining the order of whisker segments along \n" " the face. This requires an approximate position for the center of \n" " the face and can be specified in pixel coordinates with <x> and <y>.\n" " If the face is located along the edge of the frame then specify \n" " that edge with 'left', 'right', 'top' or 'bottom'. \n" " -n <int> (Optional) Expect this number of whiskers. \n" " If this isn't specified, or if this is set to a number less than 1 \n" " then the number of whiskers is automatically determined. \n" "-- \n"); return 0; } table = Measurements_Table_From_Filename ( Get_String_Arg("source"), NULL, &n_rows ); if(!table) error("Couldn't read %s\n",Get_String_Arg("source")); Sort_Measurements_Table_Time(table,n_rows); if( Is_Arg_Matched("face") ) { int maxx,maxy; Measurements_Table_Pixel_Support( table, n_rows, &maxx, &maxy ); Helper_Get_Face_Point( Get_String_Arg("face"), maxx, maxy, &face_x, &face_y); } else { face_x = Get_Int_Arg("x"); face_y = Get_Int_Arg("y"); } #ifdef DEBUG_CLASSIFY_3 debug(" Face Position: ( %3d, %3d )\n", face_x, face_y); #endif // Initialize Measurements_Table_Label_By_Threshold ( table, n_rows, 0, // length column 0, // threshold 1);// require greater than threshold // // Estimate whisker count if neccessary // if( !Is_Arg_Matched("-n") || ( (count = Get_Int_Arg("-n"))<2 ) ) { int n_good_frames; n_good_frames = Measurements_Table_Best_Frame_Count_By_State( table, n_rows, 1, &count ); #ifdef DEBUG_CLASSIFY_3 debug( " Frames with count: %d\n" ,n_good_frames ); #endif } #ifdef DEBUG_CLASSIFY_3 debug(" Target count: %d\n" ,count ); #endif #ifdef DEBUG_CLASSIFY_3 { Measurements *row = table + n_rows; //Assert all state==1 while(row-- > table) assert(row->state == 1); } #endif Measurements_Table_Set_Constant_Face_Position ( table, n_rows, face_x, face_y); Measurements_Table_Set_Follicle_Position_Indices ( table, n_rows, 4, 5 ); Measurements_Table_Label_By_Order(table, n_rows, count ); //resorts Measurements_Table_To_Filename( Get_String_Arg("dest"), NULL, table, n_rows ); Free_Measurements_Table(table); return 0; }