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[]) { 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; }
ParaSet::ParaSet (int argc, char * argv[], char * specifications []) { Process_Arguments(argc,argv,specifications,1); // ProjectionMethod::ParaSet parameter; if (Is_Arg_Matched("-r")) { // grid size radius = Get_Int_Arg("-r"); if (radius %2 != 0) { // the grid size has to be even to enable a subsequent refinement radius++; } } else { radius = 20; } if (Is_Arg_Matched("-d")) { // distance parameter distance = Get_Int_Arg("-d"); } else { distance = 2; } if (Is_Arg_Matched("-l")) { // number of cell layers layer = Get_Int_Arg("-l"); } else { layer = 1; } if (Is_Arg_Matched("-t")) { // threshold for brigth pixels threshold = Get_Int_Arg("-t"); } else { threshold = 50; } if (Is_Arg_Matched("-hmd")) { // export downsampled height map printHeightMap = true; } else { printHeightMap = false; } if (Is_Arg_Matched("-hmr")) { // export height map printRealHeightMap = true; } else { printRealHeightMap = false; } if (Is_Arg_Matched("-mi")) { // if the signal spreads several layers, then one can project the maximal intensities of the detected surface layers and its neighboring ones maxInterpolation = true; } else { maxInterpolation = false; } if (Is_Arg_Matched("-v")) { // verbose parameter verbose = true; } else { verbose = false; } };
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; }
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; }
/* * 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; }
ExtendedParaSet::ExtendedParaSet (int argc, char * argv[], char * specifications []) { Process_Arguments(argc,argv,specifications,1); if (Is_Arg_Matched("-r")) { // grid size radius = Get_Int_Arg("-r"); if (radius %2 != 0) { // the grid size has to be even to enable a subsequent refinement radius++; } } else { radius = 20; } if (Is_Arg_Matched("-d1")) { // distance parameter distance1 = Get_Int_Arg("-d1"); } else { distance1 = 0; } if (Is_Arg_Matched("-d2")) { // distance parameter distance2 = Get_Int_Arg("-d2"); } else { distance2 = 0; } if (Is_Arg_Matched("-t")) { // threshold for brigth pixels threshold = Get_Int_Arg("-t"); } else { threshold = 50; } if (Is_Arg_Matched("-hmd")) { // export downsampled height map printHeightMap = true; } else { printHeightMap = false; } if (Is_Arg_Matched("-hmr")) { // export height map printRealHeightMap = true; } else { printRealHeightMap = false; } if (Is_Arg_Matched("-v")) { // verbose parameter verbose = true; } else { verbose = false; } };
int main(int argc, char *argv[]) { static char *Spec[] = {"[-t]", NULL}; Process_Arguments(argc, argv, Spec, 1); #if 1 Mc_Stack *stack = Read_Mc_Stack("/Users/zhaot/Data/hanchuan/HP_091123_1_L1_Sum.lsm", -1); Mc_Stack *proj = Mc_Stack_Mip(stack); Write_Mc_Stack("../data/test.tif", proj, NULL); #endif return 0; }
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> -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[]) { 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[] = {"[-z <double>]", NULL}; Process_Arguments(argc, argv, Spec, 1); #if 0 Locseg_Chain *chain1 = Read_Locseg_Chain("../data/ct017/test5/chain2.bn"); Locseg_Chain *chain2 = Read_Locseg_Chain("../data/ct017/test5/chain1.bn"); if (Is_Arg_Matched("-z")) { double z_scale = Get_Double_Arg("-z"); Locseg_Chain_Scale_Z(chain1, z_scale); Locseg_Chain_Scale_Z(chain2, z_scale); } Neurocomp_Conn conn; Locseg_Chain_Connection_Test_P(chain1, chain2, &conn); Print_Neurocomp_Conn(&conn); double scale = 2.0; double offset = 5.0; Local_Neuroseg *locseg1; if (conn.info[0] == 0) { locseg1 = Locseg_Chain_Head_Seg(chain1); Local_Neuroseg_Stretch(locseg1, scale, offset, -1); } else { locseg1 = Locseg_Chain_Tail_Seg(chain1); Local_Neuroseg_Stretch(locseg1, scale, offset, 1); } Local_Neuroseg *locseg2 = Locseg_Chain_Peek_Seg_At(chain2, conn.info[1]); Local_Neuroseg_Stretch(locseg2, scale, offset, 0); printf("%g\n", Local_Neuroseg_Planar_Dist_L(locseg1, locseg2)); FILE *fp = fopen("../data/ct017/test5/test.swc", "w"); /* to avoid v3d bug */ Local_Neuroseg *tmp_locseg = Copy_Local_Neuroseg(locseg1); tmp_locseg->seg.r1 = 0.1; Local_Neuroseg_Swc_Fprint(fp, tmp_locseg, 0, -1); Local_Neuroseg_Swc_Fprint(fp, locseg1, 2, -1); Local_Neuroseg_Swc_Fprint(fp, locseg2, 4, -1); fclose(fp); Locseg_Chain_Connection_Test(chain1, chain2, NULL, 1.0, &conn, NULL); Print_Neurocomp_Conn(&conn); #endif #if 0 double z_scale = 0.5375; Locseg_Chain *chain[11]; char file_path[100]; int i, j; for (i = 0; i < 11; i++) { sprintf(file_path, "../data/mouse_single_org/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); Locseg_Chain_Scale_Z(chain[i], z_scale); } Neurocomp_Conn conn; for (i = 0; i < 11; i++) { for (j = 0; j < 11; j++) { if (i != j) { if (Locseg_Chain_Connection_Test_P(chain[i], chain[j], &conn) < 5.0) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 double z_scale = 0.5375; int n = 278; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/mouse_single_org/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); Locseg_Chain_Scale_Z(chain[i], z_scale); } Locseg_Chain *hook = chain[19]; Neurocomp_Conn conn; for (i = 0; i < n; i++) { if (i != 19) { if (Locseg_Chain_Connection_Test_P(hook, chain[i], &conn) < 5.0) { printf("19 -> %d \n", i); Print_Neurocomp_Conn(&conn); } } } #endif #if 0 double z_scale = 0.32; Locseg_Chain *chain[17]; char file_path[100]; int i, j; for (i = 0; i < 17; i++) { sprintf(file_path, "../data/fly_neuron_n1/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); Locseg_Chain_Scale_Z(chain[i], z_scale); } Neurocomp_Conn conn; for (i = 0; i < 17; i++) { for (j = 0; j < 17; j++) { if (i != j) { if (Locseg_Chain_Connection_Test_P(chain[i], chain[j], &conn) < 5.0) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 double z_scale = 0.1400; //double z_scale = 1.0; int n = 12; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/ct017/test6/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); Locseg_Chain_Scale_Z(chain[i], z_scale); } Neurocomp_Conn conn; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (i != j) { if (Locseg_Chain_Connection_Test_P(chain[i], chain[j], &conn) < 10.0) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 //double z_scale = 0.1400; double z_scale = 1.20; int n = 5; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/ct017/test7/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); Locseg_Chain_Scale_Z(chain[i], z_scale); } Neurocomp_Conn conn; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (i != j) { if (Locseg_Chain_Connection_Test_P(chain[i], chain[j], &conn) < 10.0) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 double z_scale = 1.20; //double z_scale = 1.0; Stack *stack = Read_Stack("../data/lobster_neuron_org.tif"); int n = 5; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/ct017/test7/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); //Locseg_Chain_Scale_Z(chain[i], z_scale); } Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); ctw->z_scale = z_scale; Neurocomp_Conn conn; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (i != j) { if (Locseg_Chain_Connection_Test(chain[i], chain[j], stack, 1.0, &conn, ctw)) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 Locseg_Chain *chain = Read_Locseg_Chain("../data/ct017/test6/chain7.bn"); Local_Neuroseg *locseg = Locseg_Chain_Tail_Seg(chain); Print_Local_Neuroseg(locseg); Stack *stack = Read_Stack("../data/mouse_neuron_sp2.tif"); double *profile = Local_Neuroseg_Height_Profile(locseg, stack, 1.0, 11, STACK_FIT_CORRCOEF, NULL); darray_write("../data/profile1.bn", profile, 11); #endif #if 0 Locseg_Chain *chain = Read_Locseg_Chain("../data/ct017/test6/chain7.bn"); Local_Neuroseg *locseg = Locseg_Chain_Tail_Seg(chain); Print_Local_Neuroseg(locseg); Stack *stack = Read_Stack("../data/mouse_neuron_sp2.tif"); int n; double record[11]; Locseg_Chain *chain2 = Local_Neuroseg_Push(locseg, stack, 1.0, STACK_FIT_OUTER_SIGNAL, record, &n); Print_Locseg_Chain(chain2); Write_Locseg_Chain("../data/test.tb", chain2); return 1; Locseg_Chain *chain3 = Read_Locseg_Chain("../data/ct017/test6/chain6.bn"); Locseg_Chain_Scale_Z(chain2, 0.14); Locseg_Chain_Scale_Z(chain3, 0.14); Neurocomp_Conn conn; Locseg_Chain_Connection_Test(chain2, chain3, NULL, 1.0, &conn, NULL); Print_Neurocomp_Conn(&conn); #endif #if 0 Locseg_Chain *chain = Read_Locseg_Chain("../data/ct017/test6/chain9.bn"); Local_Neuroseg *locseg = Locseg_Chain_Tail_Seg(chain); //Local_Neuroseg *locseg = Locseg_Chain_Head_Seg(chain); //Flip_Local_Neuroseg(locseg); Print_Local_Neuroseg(locseg); Stack *stack = Read_Stack("../data/mouse_neuron_sp2.tif"); int n; double record[11]; Locseg_Chain *chain2 = Local_Neuroseg_Push(locseg, stack, 1.0, STACK_FIT_OUTER_SIGNAL, record, &n); Print_Locseg_Chain(chain2); Write_Locseg_Chain("../data/test.bn", chain2); return 1; Locseg_Chain *chain3 = Read_Locseg_Chain("../data/ct017/test6/chain9.bn"); Locseg_Chain_Scale_Z(chain2, 0.14); Locseg_Chain_Scale_Z(chain3, 0.14); Neurocomp_Conn conn; Locseg_Chain_Connection_Test(chain3, chain2, stack, 1.0, &conn, NULL); Print_Neurocomp_Conn(&conn); #endif #if 0 double z_scale = 0.1400; //double z_scale = 1.0; Stack *stack = Read_Stack("../data/mouse_neuron_sp2.tif"); int n = 12; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/ct017/test6/chain%d.bn", i); chain[i] = Read_Locseg_Chain(file_path); //Locseg_Chain_Scale_Z(chain[i], z_scale); } Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); ctw->z_scale = 0.14; Neurocomp_Conn conn; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (i != j) { if (Locseg_Chain_Connection_Test(chain[i], chain[j], stack, 1.0, &conn, ctw)) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 //double z_scale = 0.32; //double z_scale = 1.0; Stack *stack = Read_Stack("../data/fly_neuron_n1.tif"); int n = 17; Locseg_Chain *chain[n]; char file_path[100]; int i, j; for (i = 0; i < n; i++) { sprintf(file_path, "../data/fly_neuron_n1/chain%d.tb", i); chain[i] = Read_Locseg_Chain(file_path); //Locseg_Chain_Scale_Z(chain[i], z_scale); } Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); ctw->resolution[0] = 0.32; ctw->resolution[1] = 0.32; ctw->resolution[2] = 1.0; Neurocomp_Conn conn; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (i != j) { if (Locseg_Chain_Connection_Test(chain[i], chain[j], stack, 1.0, &conn, ctw)) { printf("%d -> %d \n", i, j); Print_Neurocomp_Conn(&conn); } } } } #endif #if 0 Locseg_Chain *chain = Read_Locseg_Chain("../data/fly_neuron_n1/chain3.bn"); Local_Neuroseg *locseg = Locseg_Chain_Tail_Seg(chain); //Flip_Local_Neuroseg(locseg); Print_Local_Neuroseg(locseg); Stack *stack = Read_Stack("../data/fly_neuron_n1.tif"); int n; double record[11]; Locseg_Chain *chain2 = Local_Neuroseg_Push(locseg, stack, 1.0, STACK_FIT_CORRCOEF, record, &n); Print_Locseg_Chain(chain2); Write_Locseg_Chain("../data/test.bn", chain2); return 1; Locseg_Chain *chain3 = Read_Locseg_Chain("../data/fly_neuron_n1/chain0.bn"); Locseg_Chain_Scale_Z(chain2, 0.32); Locseg_Chain_Scale_Z(chain3, 0.32); Neurocomp_Conn conn; Locseg_Chain_Connection_Test(chain2, chain3, stack, 1.0, &conn, NULL); Print_Neurocomp_Conn(&conn); #endif 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[]) { 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[] = {"[-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[] = {"<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[]) { 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[]) { 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[]) { 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); }
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[]) { 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; }
void ZArgumentProcessor::processArguments( int argc, char **argv, const char **Spec) { Process_Arguments(argc, argv, const_cast<char**>(Spec), 1); }
int main(int argc, char *argv[]) { static char *Spec[] = {"[-t]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (Is_Arg_Matched("-t")) { coordinate_3d_t coord = {0, 0, 0}; /* Translate coordinates. */ Geo3d_Translate_Coordinate(coord, coord+1, coord+2, 1.0, 2.0, 3.0); if ((coord[0] != 1.0) || (coord[1] != 2.0) || (coord[2] != 3.0)) { Print_Coordinate_3d(coord); PRINT_EXCEPTION(":( Bug?", "Unexpected coordinate values."); return 1; } coordinate_3d_t coord2 = {0, 0, 0}; double dx, dy, dz; Geo3d_Coordinate_Offset(coord[0], coord[1], coord[2], coord2[0], coord2[1], coord2[2], &dx, &dy, &dz); if ((dx != -coord[0]) || (dy != -coord[1]) || (dz != -coord[2])) { PRINT_EXCEPTION(":( Bug?", "Unexpected offset values."); return 1; } Coordinate_3d_Copy(coord2, coord); /* Rotate coordinates. */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 0); if (fabs(Geo3d_Orgdist_Sqr(coord[0], coord[1], coord[2]) - Geo3d_Orgdist_Sqr(coord2[0], coord2[1], coord2[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } /* inverse rotation */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 1); if ((fabs(coord[0] - coord2[0]) > 0.01) || (fabs(coord[1] - coord2[1]) > 0.01) || (fabs(coord[2] - coord2[2]) > 0.01)){ PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } /* Normal vector of an orientation. This is a canonical representaion * of an orientation. */ Geo3d_Orientation_Normal(0.1, 0.5, coord, coord+1, coord+2); /* We can also turn the normal vector into orientation. */ double theta, psi; Geo3d_Normal_Orientation(coord[0], coord[1], coord[2], &theta, &psi); if (fabs(theta - 0.1) > 0.01 || fabs(Normalize_Radian(psi) - 0.5) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* If we rotate the vector back, we should get (0, 0, 1). */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 1); if ((fabs(coord[0]) > 0.01) || (fabs(coord[1]) > 0.01) || (fabs(coord[2] - 1.0) > 0.01)){ PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } Geo3d_Coord_Orientation(1, 0, 0, &theta, &psi); double in[3] = {0, 0, 1}; double out[3] = {0, 0, 0}; Rotate_XZ(in, out, 1, theta, psi, 0); if (fabs(out[0] - 1.0) > 0.01 || fabs(out[1]) > 0.01 || fabs(out[2]) > 0.01) { printf("%g, %g, %g\n", out[0], out[1], out[2]); printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* if (fabs(theta - TZ_PI_2) > 0.01 || fabs(Normalize_Radian(psi) - TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } */ Geo3d_Coord_Orientation(5, 0, 0, &theta, &psi); { double in[3] = {0, 0, 5}; double out[3] = {0, 0, 0}; Rotate_XZ(in, out, 1, theta, psi, 0); if (fabs(out[0] - 5.0) > 0.01 || fabs(out[1]) > 0.01 || fabs(out[2]) > 0.01) { printf("%g, %g, %g\n", out[0], out[1], out[2]); printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } } /* if (fabs(theta - TZ_PI_2) > 0.01 || fabs(Normalize_Radian(psi) - TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } */ /* Rotate the orientation. */ theta = TZ_PI_2; psi = TZ_PI; Geo3d_Rotate_Orientation(-TZ_PI, TZ_PI_2, &theta, &psi); if (fabs(theta + TZ_PI_2) > 0.01 || fabs(psi + TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* More extensive test on rotation */ Random_Seed(time(NULL) - getpid()); int i; for (i = 0; i < 100; i++) { double x = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double y = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double z = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double theta, psi; Geo3d_Coord_Orientation(x, y, z, &theta, &psi); double x2 = 0.0; double y2 = 0.0; double z2 = Geo3d_Orgdist(x, y, z); Geo3d_Rotate_Coordinate(&x2, &y2, &z2, theta, psi, 0); if (fabs(x - x2) > 0.01 || fabs(y - y2) > 0.01 || fabs(z - z2) > 0.01) { printf("%g, %g\n", theta, psi); printf("%g, %g, %g\n", x, y, z); printf("%g, %g, %g\n", x2, y2, z2); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } } /* Dot product. */ if (Geo3d_Dot_Product(1.0, 2.0, 3.0, 3.0, 2.0, 1.0) != 10.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } /* Cross product. */ Geo3d_Cross_Product(1.0, 2.0, 3.0, 3.0, 1.0, 2.0, coord, coord+1, coord+2); if (fabs(Geo3d_Dot_Product(1.0, 2.0, 3.0, coord[0], coord[1], coord[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } if (fabs(Geo3d_Dot_Product(3.0, 1.0, 2.0, coord[0], coord[1], coord[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } /* Distance calculations. */ if (Geo3d_Orgdist_Sqr(1.0, 2.0, 3.0) != 14.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (fabs(Geo3d_Orgdist(1.0, 2.0, 3.0) - sqrt(14.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (Geo3d_Dist(1.0, 2.0, 3.0, 1.0, 2.0, 3.0) != 0.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (Geo3d_Dist_Sqr(1.0, 2.0, 3.0, 0.0, 0.0, 0.0) != 14.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } /* Angle between two vectors. */ if (fabs(Geo3d_Angle2(1, 0, 0, 0, 0, 1) - TZ_PI_2) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } /* Distance between two lines */ coordinate_3d_t line1_start = {0, 0, 0}; coordinate_3d_t line1_end = {1, 0, 0}; coordinate_3d_t line2_start = {0, 1, 1}; coordinate_3d_t line2_end = {0, 2, 1}; double d = Geo3d_Line_Line_Dist(line1_start, line1_end, line2_start, line2_end); if (fabs(d - 1.0) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Distance between two line segments. */ double intersect1, intersect2; int cond; d = Geo3d_Lineseg_Lineseg_Dist(line1_start, line1_end, line2_start, line2_end, &intersect1, &intersect2, &cond); if (fabs(d - sqrt(2.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Distance between a point and a line segment. */ coord[0] = 0.5; coord[1] = 1.0; coord[2] = 1.0; d = Geo3d_Point_Lineseg_Dist(coord, line1_start, line1_end, &intersect1); if (fabs(d - sqrt(2.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Get a break point of a line segment. */ Geo3d_Lineseg_Break(line1_start, line1_end, 0.1, coord); if ((coord[0] != 0.1) || (coord[1] != 0.0) || (coord[2] != 0.0)) { PRINT_EXCEPTION(":( Bug?", "Unexpected break point."); return 1; } /* Orientations of a set of points */ /* Orientation of a covariance matrix */ /* 3D coordinates routines */ /* Unitize a point. */ Coordinate_3d_Unitize(coord); if (fabs(Coordinate_3d_Norm(coord) - 1.0) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected norm."); return 1; } Set_Coordinate_3d(coord, 0.0, 0.0, 0.0); /* origin point is not affected by unitization */ Coordinate_3d_Unitize(coord); if (Coordinate_3d_Norm(coord) != 0.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected norm."); return 1; } Set_Coordinate_3d(coord, 1.0, 2.0, 3.0); /* Square length */ if (Coordinate_3d_Length_Square(coord) != 14) { PRINT_EXCEPTION(":( Bug?", "Unexpected square length"); } /* Angle between two vectors */ coordinate_3d_t coord_a1 = { 1, 0, 0 }; coordinate_3d_t coord_a2 = { 0, 0, 1 }; if (fabs(Coordinate_3d_Angle2(coord_a1, coord_a2) - TZ_PI_2) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected angle"); } /* Scale coordinates */ Coordinate_3d_Scale(coord, 2.0); if ((coord[0] != 2.0) || (coord[1] != 4.0) || (coord[2] != 6.0)) { PRINT_EXCEPTION(":( Bug?", "Unexpected coordinate value."); return 1; } /* Normalizd dot product */ if (Coordinate_3d_Normalized_Dot(coord, coord2) > 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } Set_Coordinate_3d(coord, 1.0, 2.0, 3.0); Coordinate_3d_Copy(coord2, coord); Coordinate_3d_Scale(coord2, 2.0); coordinate_3d_t coord3; Coordinate_3d_Copy(coord3, coord); Coordinate_3d_Scale(coord3, 3.0); /* cos value of an angle formed by 3 points */ if (Coordinate_3d_Cos3(coord, coord2, coord3) != 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected cos value."); return 1; } /* cos value of an angle formed by 4 points */ coordinate_3d_t coord4; Coordinate_3d_Copy(coord4, coord); Coordinate_3d_Scale(coord4, 4.0); if (Coordinate_3d_Cos4(coord, coord2, coord3, coord4) != 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected cos value."); return 1; } printf(":) Testing passed.\n"); return 0; } #if 0 Geo3d_Vector v1 = {1.1, 0, 0}; Geo3d_Vector v2 = {5, 0, 0}; double theta1 = 3.83812; double psi1 = 3.53202; double theta2 = 0.72657; double psi2 = 3.61214; Geo3d_Orientation_Normal(theta1, psi1, &(v1.x), &(v1.y), &(v1.z)); Geo3d_Orientation_Normal(theta2, psi2, &(v2.x), &(v2.y), &(v2.z)); Print_Geo3d_Vector(&v1); Print_Geo3d_Vector(&v2); printf("%g\n", Geo3d_Vector_Dot(&v1, &v2)); printf("%g\n", Geo3d_Vector_Angle2(&v1, &v2)); double angle = Vector_Angle(-1.0, -1.0); theta1 = -3.0; psi1 = -5.0; double x, y, z; Geo3d_Orientation_Normal(theta1, psi1, &x, &y, &z); printf("%g, %g, %g\n", x, y, z); Geo3d_Normal_Orientation(x, y, z, &theta1, &psi1); printf("%g\n", angle * 180.0 / TZ_PI); printf("%g, %g\n", theta1, psi1); Geo3d_Orientation_Normal(theta1, psi1, &x, &y, &z); printf("%g, %g, %g\n", x, y, z); #endif #if 0 Geo3d_Scalar_Field *field = Read_Geo3d_Scalar_Field("../data/mouse_neuron/seeds.bn"); Print_Geo3d_Scalar_Field_Info(field); Stack *stack = Read_Stack("../data/mouse_neuron/mask.tif"); Geo3d_Scalar_Field_Draw_Stack(field, stack, NULL, NULL); Write_Stack("../data/test.tif", stack); #endif #if 0 double line_start[3] = {2.0, 3.0, 4.0}; double line_end[3] = {1.0, 1.0, 6.0}; double point[3] = {10.5, 20.5, 40.7}; double lamda; printf("%g\n", Geo3d_Point_Lineseg_Dist(point, line_start, line_end, &lamda)); double line_point[3]; double length = sqrt(Geo3d_Dist_Sqr(line_start[0], line_start[1], line_start[2], line_end[0], line_end[1], line_end[2])); line_point[0] = line_start[0] + lamda * (line_end[0] - line_start[0]); line_point[1] = line_start[1] + lamda * (line_end[1] - line_start[1]); line_point[2] = line_start[2] + lamda * (line_end[2] - line_start[2]); printf("%g\n", lamda); printf("%g\n", sqrt(Geo3d_Dist_Sqr(line_point[0], line_point[1], line_point[2], point[0], point[1], point[2]))); darray_sub(point, line_point, 3); darray_sub(line_end, line_point, 3); printf("%g\n", Geo3d_Dot_Product(point[0], point[1], point[2], line_end[0], line_end[1], line_end[2])); #endif #if 0 Geo3d_Scalar_Field *field = Read_Geo3d_Scalar_Field("../data/mouse_neuron3_org/seeds"); //Print_Geo3d_Scalar_Field(field); darray_write("../data/pts.bn", (double *)field->points, field->size * 3); darray_write("../data/ws.bn", field->values, field->size); coordinate_3d_t centroid; Geo3d_Scalar_Field_Centroid(field, centroid); Print_Coordinate_3d(centroid); double cov[9]; Geo3d_Scalar_Field_Cov(field, cov); darray_print2(cov, 3, 3); darray_write("../data/cov.bn", cov, 9); double vec[3]; Geo3d_Cov_Orientation(cov, vec); darray_print2(vec, 3, 1); #endif #if 0 double mu1, mu2; # if 0 /* parallel case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {1, 1, 10}; double line2_start[3] = {0, 1, 0}; double line2_end[3] = {1, 2, 10}; # endif # if 0 /* parallel case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {1, 1, 10}; double line2_start[3] = {-1, -1, -1}; double line2_end[3] = {-3, -3, -21}; # endif # if 0 /* i-i case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {3, 4, 5}; double line2_start[3] = {-1, 8, 9}; double line2_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line1_start[3] = {3, 4, 5}; double line1_end[3] = {3, 4, 5}; double line2_start[3] = {-1, 8, 9}; double line2_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line2_start[3] = {3, 4, 5}; double line2_end[3] = {3, 4, 5}; double line1_start[3] = {-1, 8, 9}; double line1_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line2_start[3] = {3, 4, 5}; double line2_end[3] = {3, 4, 5}; double line1_start[3] = {-1, 8, 9}; double line1_end[3] = {-1, 8, 9}; # endif # if 0 double line1_start[3] = {256.062, 328.674, 67.9029}; double line1_end[3] = {246.162, 330.078, 67.9896}; double line2_start[3] = {262.368, 336.609, 68.3076}; double line2_end[3] = {259.956, 326.944, 67.4325}; # endif int cond; double dist = Geo3d_Lineseg_Lineseg_Dist(line1_start, line1_end, line2_start, line2_end, &mu1, &mu2, &cond); printf("%d, %g\n", cond, dist); dist = Geo3d_Line_Line_Dist(line1_start, line1_end, line2_start, line2_end); printf("%g\n", dist); #endif #if 1 double *d = Unifrnd_Double_Array(12000000, NULL); double *d2 = Unifrnd_Double_Array(12000000, NULL); tic(); Rotate_XZ(d, d, 4000000, 0.1, 0.2, 1); printf("%llu\n", toc()); tic(); Rotate_XZ2(d, d, 4000000, 0.1, 0.2, 0); printf("%llu\n", toc()); #endif #if 0 double d[3] = {0.1, 0.2, 0.3}; Rotate_XZ(d, d, 1, 0.1, 0.2, 0); darray_print2(d, 3, 1); #endif #if 0 printf("%g\n", Ellipse_Point_Distance(5, 5, 3, 5)); #endif #if 0 Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; ellipse->orientation[0] = 1.0; Print_Geo3d_Ellipse(ellipse); FILE *fp = fopen("../data/test.swc", "w"); Swc_Node node; Geo3d_Ellipse_To_Swc_Node(ellipse, 1, -1, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); /* double pt[3] = {0.0, 0.0, 1.0}; printf("%g\n", Geo3d_Ellipse_Point_Distance(ellipse, pt)); */ Geo3d_Ellipse *ellipse2 = Copy_Geo3d_Ellipse(ellipse); ellipse2->center[0] += 10.0; ellipse2->orientation[0] = 2.0; ellipse2->radius += 3.0; Geo3d_Ellipse *ellipse3 = Geo3d_Ellipse_Interpolate(ellipse, ellipse2, 0.2, NULL); Geo3d_Ellipse_To_Swc_Node(ellipse3, 2, 1, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); Geo3d_Ellipse_To_Swc_Node(ellipse2, 3, 2, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); Print_Geo3d_Ellipse(ellipse3); fclose(fp); #endif #if 0 Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; FILE *fp = fopen("../data/test.swc", "w"); coordinate_3d_t *pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 1, -1, 1.0, 2); ellipse->orientation[0] = 1.0; pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 21, -1, 1.0, 3); ellipse->center[2] = 5.0; pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 41, -1, 1.0, 4); coordinate_3d_t vec[2]; Coordinate_3d_Copy(vec[0], ellipse->center); Geo3d_Ellipse_First_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 101, -1, 1.0, 5); Geo3d_Ellipse_Second_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 111, -1, 1.0, 6); Geo3d_Ellipse_Normal_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 121, -1, 1.0, 7); fclose(fp); #endif #if 0 Geo3d_Ellipse ep_array[10]; Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; Geo3d_Ellipse_Copy(ep_array, ellipse); FILE *fp = fopen("../data/test.swc", "w"); ellipse->orientation[0] += 0.5; ellipse->center[2] += 3.0; ellipse->center[0] += 1.0; Geo3d_Ellipse_Copy(ep_array + 1, ellipse); ellipse->center[2] += 3.0; Geo3d_Ellipse_Copy(ep_array + 2, ellipse); coordinate_3d_t *pts = Geo3d_Ellipse_Array_Sampling(ep_array, 3, 20, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 60, 1, -1, 1.0, 2); fclose(fp); #endif #if 0 printf("%g\n", Vector_Angle(1.0, 1.0) * 180 / TZ_PI); #endif #if 0 double theta, psi; coordinate_3d_t coord; coord[0] = 0.0822; coord[1] = 0.1515; coord[2] = 0.1369; Geo3d_Coord_Orientation(coord[0], coord[1], coord[2], &theta, &psi); printf("%g, %g\n", theta, psi); Geo3d_Orientation_Normal(theta, psi, coord, coord+1, coord+2); Print_Coordinate_3d(coord); #endif #if 0 double theta, psi; double x = -1; double y = 1.83697019872103e-16; double z = 3; Geo3d_Coord_Orientation(x, y, z, &theta, &psi); #endif #if 0 double theta = Vector_Angle2(0, 1, 1, 0, TRUE); printf("angle: %g\n", theta); theta = Vector_Angle2(0, 1, -1, 0, FALSE); printf("angle: %g\n", theta); theta = Vector_Angle2(-1, 0, -1, -1, TRUE); printf("angle: %g\n", theta); #endif 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[]) { 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; }
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; }
int main(int argc, char *argv[]) { static char *Spec[] = {"[-t]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (Is_Arg_Matched("-t")) { /* Example test */ Stack *stack = Make_Stack(GREY, 7, 7, 1); One_Stack(stack); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); /* set seeds */ Set_Stack_Pixel(ws->mask, 1, 1, 0, 0, 1.0); Set_Stack_Pixel(ws->mask, 1, 5, 0, 0, 2.0); Set_Stack_Pixel(ws->mask, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(ws->mask, 5, 1, 0, 0, 4.0); Set_Stack_Pixel(ws->mask, 5, 5, 0, 0, 5.0); /* set stack values */ Set_Stack_Pixel(stack, 1, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 1, 5, 0, 0, 3.0); Set_Stack_Pixel(stack, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 5, 0, 0, 3.0); Stack *out = Stack_Watershed(stack, ws); //Write_Stack("../data/test/watershed/golden/watershed1.tif", out); char *golden_file = "../data/test/watershed/golden/watershed1.tif"; if (fexist(golden_file)) { Stack *golden = Read_Stack(golden_file); if (Stack_Identical(out, golden) == FALSE) { Print_Stack_Value(stack); Print_Stack_Value(out); Print_Stack_Value(golden); PRINT_EXCEPTION("Bug?", "Conflict with golden."); return 1; } Kill_Stack(stack); Kill_Stack(out); Kill_Stack(golden); Kill_Stack_Watershed_Workspace(ws); } else { printf("%s cannot be found.\n", golden_file); } char *test_file = "../data/benchmark/rice_label.tif"; if (fexist(test_file)) { stack = Read_Stack_U(test_file); ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Copy_Stack(stack); ws->conn = 26; One_Stack(stack); out = Stack_Watershed(stack, ws); //Write_Stack("../data/test/watershed/golden/watershed2.tif", out); Stack *golden = Read_Stack("../data/test/watershed/golden/watershed2.tif"); if (Stack_Identical(out, golden) == FALSE) { PRINT_EXCEPTION("Bug?", "Conflict with golden."); return 1; } } else { printf("%s cannot be found.\n", test_file); } printf(":) Testing passed.\n"); return 0; } #if 0 /* Initialize */ Watershed_3d *watershed = New_Watershed_3d(); Watershed_3d_Workspace *ws = New_Watershed_3d_Workspace(); ws->conn = 26; /* Initialize stack */ Stack *stack = Read_Stack("../data/fly_neuron/dist.tif"); int nvoxel = Stack_Voxel_Number(stack); int i; uint16 *array16 = (uint16 *)stack->array; for (i = 0; i < nvoxel; i++) { array16[i] = 0xFFFF - array16[i]; } /* Add mask to ignore dark voxels */ ws->mask = Copy_Stack(stack); //Translate_Stack(stack, GREY, 1); //stack->array = stack->array + stack->width * stack->height * 100; //stack->depth = 1; // ws->mask = Copy_Stack(stack); //Stack_Binarize(ws->mask); // ws->mask = NULL; //Write_Stack("../data/dist.tif", stack); //Stack *stack2 = Copy_Stack(stack); # if 0 Build_3D_Watershed(stack, watershed, ws); Write_Stack("../data/test.tif", watershed->labels); # endif # if 0 Image_View iv = Image_View_Stack(stack2); Watershed_Test *watershed2 = Build_2D_Watershed_Test(&(iv.image), 0); Write_Image("../data/test2.tif", watershed2->labels); # endif #endif #if 0 Image *image = Read_Image("../data/Ring15.tif_Sub1200_Original_inv.tif"); Watershed_2D *ws = Build_2D_Watershed(image, 0); Image *result = Color_Watersheds(ws, image); Write_Image("../data/test.tif", result); Kill_Image(image); #endif #if 0 Stack *stack = Make_Stack(GREY, 7, 7, 1); One_Stack(stack); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); Set_Stack_Pixel(ws->mask, 1, 1, 0, 0, 1.0); Set_Stack_Pixel(ws->mask, 1, 5, 0, 0, 2.0); Set_Stack_Pixel(ws->mask, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(ws->mask, 5, 1, 0, 0, 4.0); Set_Stack_Pixel(ws->mask, 5, 5, 0, 0, 5.0); Set_Stack_Pixel(stack, 1, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 1, 5, 0, 0, 3.0); Set_Stack_Pixel(stack, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 5, 0, 0, 3.0); Stack *out = Stack_Watershed(stack, ws); Print_Stack_Value(out); #endif #if 0 Stack *stack = Make_Stack(GREY, 3, 3, 1); One_Stack(stack); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); Set_Stack_Pixel(ws->mask, 0, 0, 0, 0, 1.0); Set_Stack_Pixel(ws->mask, 2, 2, 0, 0, 2.0); Set_Stack_Pixel(stack, 0, 0, 0, 0, 5.0); Set_Stack_Pixel(stack, 2, 2, 0, 0, 3.0); Set_Stack_Pixel(stack, 0, 2, 0, 0, 2.0); //Set_Stack_Pixel(stack, 1, 1, 0, 0, 2.0); Set_Stack_Pixel(stack, 1, 2, 0, 0, 2.0); Set_Stack_Pixel(stack, 2, 0, 0, 0, 2.0); Set_Stack_Pixel(stack, 2, 1, 0, 0, 2.0); Print_Stack_Value(stack); ws->start_level = 6; Stack *out = Stack_Watershed(stack, ws); Print_Stack_Value(out); #endif #if 0 Stack *stack = Read_Stack_U("../data/benchmark/rice_label.tif"); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Copy_Stack(stack); ws->conn = 26; One_Stack(stack); tic(); Stack *out = Stack_Watershed(stack, ws); printf("%lld\n", toc()); Write_Stack("../data/test.tif", out); #endif #if 0 Stack *stack = Read_Stack_U("../data/diadem_d1_147.xml"); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); ws->conn = 26; const int *dx = Stack_Neighbor_X_Offset(ws->conn); const int *dy = Stack_Neighbor_X_Offset(ws->conn); const int *dz = Stack_Neighbor_X_Offset(ws->conn); int seed[3]; String_Workspace *sw = New_String_Workspace(); char *line = NULL; FILE *fp = fopen("../data/diadem_d1_root_z.txt", "r"); int k = 1; while ((line = Read_Line(fp, sw)) != NULL) { int n; String_To_Integer_Array(line, seed, &n); double maxv = -1; if (n == 3) { maxv = Get_Stack_Pixel(stack, seed[0], seed[1], seed[2], 0); printf("%g\n", maxv); int i; for (i = 0; i < ws->conn; i++) { if (maxv < Get_Stack_Pixel(stack, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0)) { maxv = Get_Stack_Pixel(stack, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0); } } //Set_Stack_Pixel(stack, seed[0], seed[1], seed[2], 0, maxv); Set_Stack_Pixel(ws->mask, seed[0], seed[1], seed[2], 0, k); for (i = 0; i < ws->conn; i++) { //Set_Stack_Pixel(stack, seed[0] + dx[i], seed[1] + dy[i], // seed[2] + dz[i], 0, maxv); Set_Stack_Pixel(ws->mask, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0, k); } k++; } } fclose(fp); Kill_String_Workspace(sw); /* Set_Stack_Pixel(ws->mask, 19, 605, 112, 0, 1.0); Set_Stack_Pixel(ws->mask, 28, 565, 112, 0, 1.0); */ Stack_Watershed_Infer_Parameter(stack, ws); tic(); Stack *out = Stack_Watershed(stack, ws); printf("%lld\n", toc()); Write_Stack("../data/diadem_d1_147_label.tif", out); static const uint8 Color_Map[][3] = { {0, 0, 0}, {0, 224, 64}, {32, 64, 128}, {64, 64, 0}, {64, 128, 64}, {96, 64, 128}, {64, 0, 0}, {128, 200, 64}, {160, 128, 128}, {192, 0, 0}, {192, 160, 64}, {224, 64, 128}, {224, 224, 192}}; Translate_Stack(out, COLOR, 1); size_t nvoxel = Stack_Voxel_Number(out); size_t i; color_t *arrayc = (color_t*) out->array; for (i = 0; i < nvoxel; i++) { arrayc[i][2] = Color_Map[arrayc[i][0]][2]; arrayc[i][1] = Color_Map[arrayc[i][0]][1]; arrayc[i][0] = Color_Map[arrayc[i][0]][0]; } Write_Stack("../data/diadem_d1_147_paint.tif", out); #endif #if 0 Stack *stack = Read_Stack_U("../data/diadem_d1_146.xml"); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); Stack *mask = Read_Stack("../data/test3.tif"); ws->mask = Crop_Stack(mask, 252, -937, 2, 1024, 1024, 63, NULL); ws->conn = 26; Stack_Watershed_Infer_Parameter(stack, ws); tic(); Stack *out = Stack_Watershed(stack, ws); printf("%lld\n", toc()); Write_Stack("../data/test2.tif", out); #endif #if 0 Stack *stack = Make_Stack(GREY, 7, 7, 1); One_Stack(stack); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); Set_Stack_Pixel(ws->mask, 1, 1, 0, 0, 1.0); Set_Stack_Pixel(ws->mask, 1, 5, 0, 0, 2.0); Set_Stack_Pixel(ws->mask, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(ws->mask, 5, 1, 0, 0, 4.0); Set_Stack_Pixel(ws->mask, 5, 5, 0, 0, 5.0); Set_Stack_Pixel(stack, 1, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 1, 5, 0, 0, 3.0); Set_Stack_Pixel(stack, 3, 3, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 1, 0, 0, 3.0); Set_Stack_Pixel(stack, 5, 5, 0, 0, 3.0); Stack *out = Stack_Watershed(stack, ws); Print_Stack_Value(out); Stack *out2 = Stack_Region_Border_Shrink(out, ws); Print_Stack_Value(out2); #endif #if 0 Stack *stack = Read_Stack("../data/diadem_d1_013_label.tif"); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); //ws->conn = 26; Stack *out = Stack_Region_Border_Shrink(stack, ws); Write_Stack("../data/test.tif", out); #endif #if 0 Stack *stack = Make_Stack(GREY, 1, 1, 19); One_Stack(stack); stack->array[3] = 5; stack->array[4] = 5; stack->array[7] = 5; stack->array[8] = 5; stack->array[10] = 4; stack->array[11] = 5; stack->array[12] = 5; stack->array[13] = 4; stack->array[16] = 5; stack->array[17] = 5; Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); Print_Stack_Value(stack); Stack_Watershed_Zgap_Barrier(stack, ws->mask); Print_Stack_Value(ws->mask); #endif #if 0 Stack *stack = Read_Stack("../data/diadem_d1_047_label.tif"); Stack_Binarize(stack); Stack *stack2 = Stack_Bwdist_L_U16(stack, NULL, 0); Write_Stack("../data/test.tif", stack2); #endif #if 0 char stack_path[100]; char mask_path[100]; strcpy(stack_path, "../data/diadem_d1_064.xml"); strcpy(mask_path, stack_path); strsplit(mask_path, '.', -1); sprintf(mask_path, "%s_label.tif", mask_path); if (!fexist(stack_path)) { fprintf(stderr, "Cannot find %s\n", stack_path); return 1; } printf("Processing %s\n", stack_path); Stack *stack = Read_Stack_U(stack_path); Stack *mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(mask); int conn = 26; const int *dx = Stack_Neighbor_X_Offset(conn); const int *dy = Stack_Neighbor_X_Offset(conn); const int *dz = Stack_Neighbor_X_Offset(conn); int seed[3]; String_Workspace *sw = New_String_Workspace(); char *line = NULL; FILE *fp = fopen("../data/064.seeds.txt", "r"); int k = 1; /* label seeds */ while ((line = Read_Line(fp, sw)) != NULL) { int n; String_To_Integer_Array(line, seed, &n); double maxv = -1; if (n == 3) { maxv = Get_Stack_Pixel(stack, seed[0], seed[1], seed[2], 0); int i; for (i = 0; i < conn; i++) { if (maxv < Get_Stack_Pixel(stack, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0)) { maxv = Get_Stack_Pixel(stack, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0); } } Set_Stack_Pixel(mask, seed[0], seed[1], seed[2], 0, k); for (i = 0; i < conn; i++) { Set_Stack_Pixel(mask, seed[0] + dx[i], seed[1] + dy[i], seed[2] + dz[i], 0, k); } k++; } } fclose(fp); Kill_String_Workspace(sw); Stack_Running_Median(stack, 0, stack); Stack_Running_Median(stack, 1, stack); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = mask; Filter_3d *filter = Gaussian_Filter_3d(2.0, 2.0, 1.5); Stack *filtered_stack = Filter_Stack(stack, filter); Stack_Watershed_Zgap_Barrier(filtered_stack, ws->mask); Stack_Running_Max(ws->mask, 0, ws->mask); Stack_Running_Max(ws->mask, 1, ws->mask); //Write_Stack("../data/test.tif", ws->mask); Kill_Stack(filtered_stack); filtered_stack = NULL; FMatrix *dm = Mexihat_3D1_F(2.0, NULL, 2); //FMatrix *dm = Mexihat_3D_F(2.0, NULL); FMatrix_Negative(dm); filtered_stack = Filter_Stack(stack, dm); Stack_Threshold_Common(filtered_stack, 0, 65535); Stack_Binarize(filtered_stack); Translate_Stack(filtered_stack, GREY, 1); { int i, j, k; int offset = 0; uint16 *array = (uint16*) stack->array; for (k = 0; k < stack->depth; k++) { for (j = 0; j < stack->height; j++) { for (i = 0; i < stack->width; i++) { if (filtered_stack != NULL) { if (filtered_stack->array[offset] == 1) { ws->mask->array[offset] = STACK_WATERSHED_BARRIER; } } array[offset++] += k * 2; } } } } Kill_Stack(filtered_stack); Stack_Watershed_Infer_Parameter(stack, ws); ws->conn = 6; double weights[26] = {0.5, 0.5, 1.0, 1.0, 0.2, 0.2, 0.75, 0.75, 0.75, 0.75, 0.35, 0.35, 0.35, 0.35, 0.6, 0.6, 0.6, 0.6, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45}; ws->weights = weights; ws->weights = NULL; if (ws->weights != NULL) { ws->min_level /= 3; } Stack_Running_Median(stack, 0, stack); Stack_Running_Median(stack, 1, stack); Stack *out = Stack_Watershed(stack, ws); strcpy(mask_path, stack_path); strsplit(mask_path, '.', -1); sprintf(mask_path, "%s_label.tif", mask_path); Write_Stack("../data/test.tif", out); #endif #if 0 Stack *stack = Read_Stack("../data/test/soma2.tif"); int thre = Stack_Find_Threshold_A(stack, THRESHOLD_LOCMAX_TRIANGLE); Filter_3d *filter = Gaussian_Filter_3d(1.0, 1.0, 0.5); Stack *out = Filter_Stack(stack, filter); stack = Copy_Stack(out); Stack_Threshold_Binarize(out, thre); Stack *out2 = Stack_Bwdist_L_U16P(out, NULL, 0); int nvoxel = Stack_Voxel_Number(out); uint16_t *dist_array = (uint16_t*) out2->array; int i; for (i = 0; i < nvoxel; i++) { dist_array[i] = sqrt(dist_array[i]); } Write_Stack("../data/labmeeting13/distp.tif", out2); #endif #if 0 //Stack *stack = Read_Stack("../data/test/soma2.tif"); Stack *stack = Read_Stack("/Users/zhaot/Data/jinny/slice7_2to34ds_soma_c2.tif"); int thre = Stack_Find_Threshold_A(stack, THRESHOLD_LOCMAX_TRIANGLE); Filter_3d *filter = Gaussian_Filter_3d(1.0, 1.0, 0.5); Stack *out = Filter_Stack(stack, filter); stack = Copy_Stack(out); Stack_Threshold_Binarize(out, thre); Stack *out2 = Stack_Bwdist_L_U16P(out, NULL, 0); /* out = Stack_Locmax_Region(out2, 26); */ Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(ws->mask); size_t nvoxel = Stack_Voxel_Number(stack); size_t offset; uint16_t *dist_array = (uint16_t*) out2->array; for (offset = 0; offset < nvoxel; offset++) { if (/*(out->array[offset] == 1) && */(dist_array[offset] > 1000)) { ws->mask->array[offset] = 1; } } //Objlabel_Workspace *ow = New_Objlabel_Workspace(); //Stack_Label_Large_Objects_W(ws->mask, 1, 2, 10, ow); //Stack_Label_Objects_N(ws->mask, NULL, 1, 2, 26); Object_3d_List *objs = Stack_Find_Object(ws->mask, 1, 100); Zero_Stack(ws->mask); Stack_Draw_Objects_Bw(ws->mask, objs, -255); printf("%g\n", Stack_Max(ws->mask, NULL)); /* Write_Stack("../data/test.tif", ws->mask); return 1; */ ws->min_level = thre; ws->start_level = 65535; Stack *out3 = Stack_Watershed(stack, ws); /* Write_Stack("../data/labmeeting13/watershed.tif", out3); return 1; */ for (offset = 0; offset < nvoxel; offset++) { if (dist_array[offset] < 300) { out3->array[offset] = 0; } } int nregion = Stack_Max(out3, NULL); Kill_Stack(out2); Stack *filtered = Copy_Stack(stack); Kill_Stack(stack); ws->conn = 8; stack = Stack_Region_Border_Shrink(out3, ws); out2 = Stack_Region_Expand(stack, 4, 30, NULL); for (offset = 0; offset < nvoxel; offset++) { if (out->array[offset] == 0) { out2->array[offset] = 0; } } Write_Stack("../data/test2.tif", out2); Kill_Stack(stack); //stack = Read_Stack("../data/test/soma2.tif"); stack = Read_Stack("/Users/zhaot/Data/jinny/slice7_2to34ds_soma_c2.tif"); Translate_Stack(stack, COLOR, 1); int i; double h = 0.0; double s = 1.0; for (i = 0; i < nregion; i++) { Stack_Label_Color_L(stack, out2, i+1, h+=0.35, s, filtered); /* Rgb_Color color; Set_Color_Jet(&color, i*3); Stack_Label_Level(stack, out2, i+1, color); */ } Write_Stack("../data/test.tif", stack); #endif #if 0 Stack *stack = Read_Stack("../data/leaktest/leak3.tif"); Stack *distmap = Stack_Bwdist_L_U16P(stack, NULL, 0); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Copy_Stack(distmap); Stack_Threshold_Binarize(ws->mask, 10); Translate_Stack(ws->mask, GREY, 1); Object_3d_List *objs = Stack_Find_Object(ws->mask, 1, 100); Zero_Stack(ws->mask); Stack_Draw_Objects_Bw(ws->mask, objs, -255); ws->min_level = 1; ws->start_level = 65535; Stack *out3 = Stack_Watershed(distmap, ws); Write_Stack("../data/test.tif", out3); #endif #if 0 Stack *stack = Read_Stack("../data/benchmark/two_disk.tif"); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->conn = 26; Stack *out = Stack_Watershed(stack, ws); Write_Stack("../data/test.tif", out); #endif return 0; }