Stack* Read_Part_Raw_Stack(const char* stackfilename, int left, int right, int up, int down, int zup, int zdown, int channel) { FILE *fp = Guarded_Fopen(stackfilename, "r", "read part of stack"); fseek(fp, 25L, SEEK_SET); //raw_image_stack_by_hpeng size_t numread, sizepixel = 0; size_t sizex = 0; size_t sizey = 0; size_t sizez = 0; size_t sizec = 0; numread = fread(&sizepixel, 2, 1, fp); numread = fread(&sizex, 2, 1, fp); numread = fread(&sizey, 2, 1, fp); numread = fread(&sizez, 2, 1, fp); numread = fread(&sizec, 2, 1, fp); Stack *stack; if (sizepixel == 0 || sizex == 0 || sizey == 0 || sizez == 0 || sizec == 0) { fseek(fp, 25L, SEEK_SET); //raw_image_stack_by_hpeng numread = fread(&sizepixel, 2, 1, fp); numread = fread(&sizex, 4, 1, fp); numread = fread(&sizey, 4, 1, fp); numread = fread(&sizez, 4, 1, fp); numread = fread(&sizec, 4, 1, fp); printf("x:%zd y:%zd z:%zd c:%zd sizepixel:%zd\n", sizex, sizey, sizez, sizec, sizepixel); printf("%d %d %d %d %d %d\n", left, right, up, down, zup,zdown); size_t stride_x = sizepixel; size_t stride_y = sizepixel*sizex; size_t stride_z = sizepixel*sizex*sizey; size_t stride_c = sizepixel*sizex*sizey*sizez; stack = Make_Stack(sizepixel, right-left+1, down-up+1, zdown-zup+1); size_t i,j; for (i=zup; i<=zdown; i++) { for (j=up; j<=down; j++) { size_t offset = 35+8+(channel-1)*stride_c+i*stride_z+j*stride_y+left*stride_x; fseek(fp, offset, SEEK_SET); size_t desoffset = (i-zup)*sizepixel*stack->height*stack->width+(j-up)*sizepixel*stack->width; numread = fread(stack->array+desoffset, sizepixel, stack->width, fp); } } } else { printf("x:%zd y:%zd z:%zd c:%zd sizepixel:%zd\n", sizex, sizey, sizez, sizec, sizepixel); printf("%d %d %d %d %d %d\n", left, right, up, down, zup,zdown); size_t stride_x = sizepixel; size_t stride_y = sizepixel*sizex; size_t stride_z = sizepixel*sizex*sizey; size_t stride_c = sizepixel*sizex*sizey*sizez; stack = Make_Stack(sizepixel, right-left+1, down-up+1, zdown-zup+1); size_t i,j; for (i=zup; i<=zdown; i++) { for (j=up; j<=down; j++) { size_t offset = 35+(channel-1)*stride_c+i*stride_z+j*stride_y+left*stride_x; fseek(fp, offset, SEEK_SET); size_t desoffset = (i-zup)*sizepixel*stack->height*stack->width+(j-up)*sizepixel*stack->width; numread = fread(stack->array+desoffset, sizepixel, stack->width, fp); } } } fclose(fp); return stack; }
/* Object_To_Stack_Bw(): Turn an object to a stack. * * Input: obj - the input object; * value - value of the object pixels; * offset - offset of the object, which could be NULL if the caller does * not need the information returned. * * Return: a stack with GREY kind, which contains the input object. */ Stack* Object_To_Stack_Bw(const Object_3d *obj, uint8 value, int *offset) { int corners[6]; Object_3d_Range(obj, corners); if (offset != NULL) { int i; for (i = 0; i < 3; i++) { offset[i] = corners[i]; } } Object_3d *tmpobj = Copy_Object_3d(obj); Object_3d_Translate(tmpobj, -corners[0], -corners[1], -corners[2]); int width, height, depth; width = corners[3] - corners[0] + 1; height = corners[4] - corners[1] + 1; depth = corners[5] - corners[2] + 1; Stack *stack = Make_Stack(GREY, width, height, depth); Zero_Stack(stack); Stack_Draw_Object_Bw(stack, tmpobj, value); Kill_Object_3d(tmpobj); return stack; }
static Struct_Element* se_expand(const Struct_Element *se) { int corner[3]; int size[3]; se_boundbox(se, corner, size); Stack *stack = Make_Stack(GREY, size[0] * 2 - 1, size[1] * 2 - 1, size[2] * 2 - 1); int center[3]; int i, j, k; for (i = 0; i < 3; i++) { center[i] = size[i] - 1; } int offset[3]; for (j = 0; j < se->size; j++) { for (i = 0; i < se->size; i++) { for (k = 0; k < 3; k++) { offset[k] = se->offset[i][k] - se->offset[j][k] + center[k]; } Set_Stack_Pixel(stack, offset[0], offset[1], offset[2], 0, 1); } } return Stack_To_Se(stack, center, 1); }
Stack *transpose_copy_uint8( Stack *s ) /* not optimized */ { Stack *out; int x,y,z; if( s->kind != GREY8 ) { error( "Only GREY8 images currently supported.\n" ); goto error; } out = Make_Stack( s->kind, s->height, s->width, s->depth); for( x=0; x< (s->width); x++) for( y=0; y< (s->height); y++) for( z=0; z< (s->depth); z++) *STACK_PIXEL_8( out,y,x,z,0 ) = *STACK_PIXEL_8( s,x,y,z,0 ); return out; error: return (NULL); }
/* Stack_Level_Code(): Build level code for a stack. * * Note: The caller is responsible for clearing the returned pointer. No aliasing * is allowed between the input pointers. * * Args: stack - input stack. * code - output coded sack. A new stack will be created if it is NULL. * link - An array for storing intermediate results. It must be NULL or * have the length of the number of pixels. * seed - starting pixel. * * Return: code stack. The intensity of a pixel is its level from the seed. */ Stack* Stack_Level_Code(Stack *stack, Stack *code, int *link, const int *seed, int nseed) { assert(stack != NULL); if (stack->kind != GREY) { TZ_ERROR(ERROR_DATA_TYPE); } /* if (stack->array[seed[0]] == 0) { TZ_WARN(ERROR_OTHER); TRACE("The seed is in the background."); //return NULL; } */ init_imginfo(stack->width, stack->height, stack->depth); int link_owner = FALSE; if (link == NULL) { link = (int*)Guarded_Malloc(sizeof(int) * cnpixel, "Stack_Level_Code"); link_owner = TRUE; } if (code == NULL) { code = Make_Stack(GREY16, stack->width, stack->height, stack->depth); } uint16 *code_array = (uint16 *) code->array; int neighbor[26]; level_code(stack->array, code_array, link, stack->width, stack->height, stack->depth, seed, nseed, neighbor, 0); if (link_owner == TRUE) { free(link); } return code; }
int main(int argc, char* argv[]) { Range params[3] = { {0.0, 1.0, 0.1}, {0.5, 4.5, 0.5}, {-M_PI/4.0, M_PI/4.0, M_PI/72.0} }; Array *bank = Build_Harmonic_Line_Detectors( params[0], params[1], params[2], 7, 2*7+3); { float *p,*d,sum=0.0; d = (float*) bank->data; p = d + bank->strides_px[0]; while( p-- > d ) sum += ( *p - round(*p) )*10.0;; printf("sum: %g\n",sum); if( sum > 0.01 ) printf("Mean is not zero: The image is probably too small to support the detector\n"); } { Stack stk, *lbl, *t; float *d; int i; d = (float*) bank->data; stk.kind = 4; stk.width = bank->shape[0]; stk.height = bank->shape[1]; stk.depth = bank->strides_px[0] / bank->strides_px[3]; stk.array = (uint8*) bank->data; lbl = Make_Stack(stk.kind, stk.width, stk.height, stk.depth); { int j,labels[NLABELS] = {2,3/*,5,7*/}; d = (float*) bank->data; i = bank->strides_px[0]; while( i-- ) { float v = d[i]; int l = lround(v); int cnt = 0; ( (float*) stk.array )[i] = (v-l)*10.0; ( (float*) lbl->array )[i] = 0; for(j=0;j<NLABELS;j++) if( l > 0.0 ) if( ((int)l) % labels[j] == 0 ) { ( (float*) lbl->array )[i] += (j+1); cnt++; } if(cnt) ( (float*) lbl->array )[i] /= cnt; } } Scale_Stack_To_Range( &stk, 0, 0, 255 ); Scale_Stack_To_Range( lbl, 0, 0, 255 ); t = Translate_Stack( &stk, GREY8 , 0 ); Free_Stack(t); Write_Stack( "evaltest5_weights.tif", t ); t = Translate_Stack( lbl, GREY8 , 0 ); Write_Stack( "evaltest5_labels.tif", t ); Free_Stack(t); Free_Stack(lbl); } Free_Array( bank ); 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 Trace_Evaluate_Seed(const Geo3d_Scalar_Field *seed, const Stack *signal, double z_scale, Trace_Evaluate_Seed_Workspace *ws) { OBJECT_SAFE_FREE(ws->score, free); ws->score = darray_malloc(seed->size); int i; OBJECT_SAFE_FREE(ws->locseg, free); ws->locseg = (Local_Neuroseg *) malloc(seed->size * sizeof(Local_Neuroseg)); ws->nseed = seed->size; int index = 0; if (ws->base_mask == NULL) { ws->base_mask = Make_Stack(GREY, signal->width, signal->height, signal->depth); Zero_Stack(ws->base_mask); } 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]; if (ws->zshift) { stack_adjust_zpos(signal, x, y, &z); if (ws->trace_mask != NULL) { if (Stack_Pixel(ws->trace_mask, x, y, z, 0) > 0.0) { printf("traced**\n"); ws->score[i] = 0.0; continue; } } } double width = seed->values[index]; int seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height, signal->depth); if (width < 3.0) { width += 0.5; } Set_Neuroseg(&(ws->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(&(ws->locseg[i]), cpos, NEUROSEG_CENTER); if (ws->base_mask->array[seed_offset] > 0) { printf("labeled\n"); ws->score[i] = 0.0; continue; } { /* for faster evaluation*/ Local_Neuroseg *locseg = ws->locseg + i; Stack_Fit_Score fs; fs.n = 1; fs.options[0] = STACK_FIT_CORRCOEF; Locseg_Fit_Workspace *fw = (Locseg_Fit_Workspace*) ws->fws; int k; for (k = 0; k < fw->pos_adjust; k++) { Local_Neuroseg_Position_Adjust(locseg, signal, z_scale); } Local_Neuroseg_Orientation_Search_C(locseg, signal, z_scale, &fs); if (ws->fit_option <= 1) { for (k = 0; k < 3; k++) { Local_Neuroseg_Position_Adjust(locseg, signal, z_scale); } } double bpos[3]; double tpos[3]; Local_Neuroseg_Bottom(locseg, bpos); Local_Neuroseg_Center(locseg, cpos); Local_Neuroseg_Top(locseg, tpos); if (ws->trace_mask != NULL) { if ((Stack_Pixel(ws->trace_mask, bpos[0], bpos[1], bpos[2], 0) > 0) && (Stack_Pixel(ws->trace_mask, cpos[0], cpos[1], cpos[2], 0) > 0) && (Stack_Pixel(ws->trace_mask, tpos[0], tpos[1], tpos[2], 0) > 0)) { printf("traced*\n"); ws->score[i] = 0.0; continue; } } if ((ws->fit_option == 1) || (ws->fit_option == 2)) { Local_Neuroseg_R_Scale_Search(locseg, signal, z_scale, 1.0, 10.0, 1.0, 0.5, 5.0, 0.5, NULL); } Fit_Local_Neuroseg_W(locseg, signal, z_scale, fw); } if (ws->trace_mask != NULL) { if (Local_Neuroseg_Hit_Mask(ws->locseg + i, ws->trace_mask, z_scale) > 0) { printf("traced\n"); ws->score[i] = 0.0; continue; } } //ws->score[i] = Local_Neuroseg_Score(ws->locseg + i, signal, z_scale, &fs); ws->score[i] = ws->fws->sws->fs.scores[1]; printf("%g\n", ws->score[i]); if (Local_Neuroseg_Good_Score(ws->locseg + i, ws->score[i], ws->min_score) == TRUE) { Local_Neuroseg_Label_G(ws->locseg + i, ws->base_mask, -1, 2, z_scale); } else { Local_Neuroseg_Label_G(ws->locseg + i, ws->base_mask, -1, 1, z_scale); } } }
Stack* Read_Png(const char *file_path) { Stack *stack = NULL; #if defined(HAVE_LIBPNG) png_structp png_ptr; png_infop info_ptr; unsigned int sig_read = 0; png_uint_32 width, height; int bit_depth, color_type, interlace_type; FILE *fp; if ((fp = fopen(file_path, "rb")) == NULL) { return NULL; } png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { fclose(fp); return NULL; } info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { fclose(fp); png_destroy_read_struct(&png_ptr, NULL, NULL); return NULL; } png_init_io(png_ptr, fp); png_set_sig_bytes(png_ptr, sig_read); int png_transforms = PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_SWAP_ENDIAN; png_read_png(png_ptr, info_ptr, png_transforms, NULL); /* png_read_info(png_ptr, info_ptr); switch(bit_depth) { } */ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); int kind = GREY; switch (color_type) { case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB_ALPHA: if (bit_depth != 8) { kind = 0; } else { kind = COLOR; } break; case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_PALETTE: kind = (bit_depth + 7) / 8; break; default: kind = 0; } if (kind != 0) { stack = Make_Stack(kind, width, height, 1); png_bytep *row_pointers = png_get_rows(png_ptr, info_ptr); //(png_bytep*) malloc(sizeof(png_bytep) * height); int i; for (i = 0; i < height; i++) { memcpy(stack->array + i * kind * width, row_pointers[i], kind * width); //row_pointers[i] = stack->array + i * kind * width; } //png_set_rows(png_ptr, info_ptr, row_pointers); //free(row_pointers); } # ifdef _DEBUG_2 printf("%d, %d, %d, %d\n", width, height, bit_depth, color_type); Write_Stack("../data/test.tif", stack); # endif fclose(fp); png_destroy_read_struct(&png_ptr, &info_ptr, NULL); #endif return stack; }
int main(int argc, char *argv[]) { char puncta_swc_path[] = "/home/feng/otherSource/hand2.swc"; char puncta_meanshifted_swc_path[] = "/home/feng/otherSource/hand_meanshifted.swc"; char trace_result_path[] = "/home/feng/otherSource/015.trace/traced/"; char masked_swc_path[] = "/home/feng/otherSource/masked_hand.swc"; char masked_meanshifted_swc_path[] = "/home/feng/otherSource/masked_hand_meanshifted.swc"; char puncta_stack_path[] = "/home/feng/otherSource/C1-slice09_L5_Sum.tif"; int n; Locseg_Chain* chains = Dir_Locseg_Chain_N(trace_result_path, "^chain[[:digit:]]*\\.tb", &n, NULL); printf("found %d tb file\n", n); int i=0; Locseg_Label_Workspace* ws = New_Locseg_Label_Workspace(); Stack *mask = Make_Stack(GREY, 1024, 1024, 128); Zero_Stack(mask); double z_scale = 1; double pixelperumxy = 9.66; double pixelperumz = 2; double maskextendbyum = 2.5; double maskextendbypixel = maskextendbyum * pixelperumxy; for (i=0; i<n; i++) { Default_Locseg_Label_Workspace(ws); ws->option = 1; ws->sdiff = maskextendbypixel; ws->value = 255; Locseg_Chain_Label_W(&(chains[i]), mask, z_scale, 0, Locseg_Chain_Length(&(chains[i])), ws); } Write_Stack("/home/feng/otherSource/maskstack.tif", mask); Swc_Node *punctas = Read_Swc_File(puncta_swc_path, &n); printf("found %d puncta\n", n); FILE *fp = fopen(masked_swc_path, "w"); for (i=0; i<n; i++) { // if (*(STACK_PIXEL_8(mask, iround(punctas[i].x), iround(punctas[i].y), iround(punctas[i].z), 0)) == 255) { // Swc_Node_Fprint(fp, &(punctas[i])); // } if (Stack_Neighbor_Mean(mask, 26, iround(punctas[i].x), iround(punctas[i].y), iround(punctas[i].z)) > 0) { Swc_Node_Fprint(fp, &(punctas[i])); } } fclose(fp); fp = fopen(puncta_meanshifted_swc_path, "w"); Stack *puncta_stack = Read_Stack(puncta_stack_path); for (i=0; i<n; i++) { Geo3d_Ball *gb = New_Geo3d_Ball(); gb->center[0] = punctas[i].x; gb->center[1] = punctas[i].y; gb->center[2] = punctas[i].z; gb->r = 3; Geo3d_Ball_Mean_Shift(gb, puncta_stack, 1, 0.5); punctas[i].x = gb->center[0]; punctas[i].y = gb->center[1]; punctas[i].z = gb->center[2]; Swc_Node_Fprint(fp, punctas+i); Delete_Geo3d_Ball(gb); } fclose(fp); Kill_Stack(puncta_stack); fp = fopen(masked_meanshifted_swc_path, "w"); for (i=0; i<n; i++) { if (Stack_Neighbor_Mean(mask, 26, iround(punctas[i].x), iround(punctas[i].y), iround(punctas[i].z)) > 0) { Swc_Node_Fprint(fp, &(punctas[i])); } } fclose(fp); return 0; }
int main() { #if 0 char *filepath = "../data/fly_neuron_n2/graph_d.swc"; Neuron_Structure *ns = Neuron_Structure_From_Swc_File(filepath); Neuron_Component_Arraylist *comp_array = Neuron_Structure_Branch_Point(ns); filepath = "../data/fly_neuron_n2.tif"; Stack *stack = Read_Stack(filepath); Translate_Stack(stack, COLOR, 1); int i; Stack_Draw_Workspace *ws = New_Stack_Draw_Workspace(); for (i = 0; i < comp_array->length; i++) { Neuron_Component_Draw_Stack(comp_array->array + i, stack, ws); } Kill_Stack_Draw_Workspace(ws); Write_Stack("../data/test.tif", stack); #endif #if 0 Stack *stack = NULL; Locseg_Chain *chain1 = Read_Locseg_Chain("../data/fly_neuron_n3/chain0.tb"); Locseg_Chain *chain2 = Read_Locseg_Chain("../data/fly_neuron_n3/chain10.tb"); Connection_Test_Workspace *ws = New_Connection_Test_Workspace(); Connection_Test_Workspace_Read_Resolution(ws, "../data/fly_neuron_n1.res"); Neurocomp_Conn conn; conn.mode = NEUROCOMP_CONN_HL; Locseg_Chain_Connection_Test(chain1, chain2, stack, 1.0, &conn, ws); Print_Neurocomp_Conn(&conn); #endif #if 0 Locseg_Chain **chain = (Locseg_Chain**) malloc(sizeof(Locseg_Chain*) * 3); chain[0] = Read_Locseg_Chain("../data/mouse_single_org/chain4.tb"); chain[1] = Read_Locseg_Chain("../data/mouse_single_org/chain19.tb"); chain[2] = Read_Locseg_Chain("../data/mouse_single_org/chain64.tb"); Stack *signal = Read_Stack("../data/mouse_single_org.tif"); Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); FILE *fp = fopen("../data/mouse_single_org.res", "r"); darray_fscanf(fp, ctw->resolution, 3); Neuron_Component *chain_array = Make_Neuron_Component_Array(3); int i; for (i = 0; i < 3; i++) { Set_Neuron_Component(chain_array + i, NEUROCOMP_TYPE_LOCSEG_CHAIN, chain[i]); } Neuron_Structure *ns = Locseg_Chain_Comp_Neurostruct(chain_array, 3, signal, 1.0, ctw); Graph *graph = ns->graph; Process_Neuron_Structure(ns); Print_Neuron_Structure(ns); Neuron_Structure_Crossover_Test(ns, 0.5375); printf("\ncross over changed: \n"); Print_Neuron_Structure(ns); #endif #if 0 Neuron_Structure *ns = Make_Neuron_Structure(5); Set_Neuron_Component(ns->comp, NEUROCOMP_TYPE_GEO3D_CIRCLE, New_Geo3d_Circle()); Set_Neuron_Component(ns->comp + 1, NEUROCOMP_TYPE_GEO3D_CIRCLE, New_Geo3d_Circle()); Set_Neuron_Component(ns->comp + 2, NEUROCOMP_TYPE_GEO3D_CIRCLE, New_Geo3d_Circle()); Set_Neuron_Component(ns->comp + 3, NEUROCOMP_TYPE_GEO3D_CIRCLE, New_Geo3d_Circle()); Set_Neuron_Component(ns->comp + 4, NEUROCOMP_TYPE_GEO3D_CIRCLE, New_Geo3d_Circle()); NEUROCOMP_GEO3D_CIRCLE(ns->comp)->radius = 1.5; NEUROCOMP_GEO3D_CIRCLE(ns->comp + 1)->radius = 2.5; NEUROCOMP_GEO3D_CIRCLE(ns->comp + 2)->radius = 3.5; NEUROCOMP_GEO3D_CIRCLE(ns->comp + 3)->radius = 4.5; NEUROCOMP_GEO3D_CIRCLE(ns->comp + 4)->radius = 5.5; ns->graph = Make_Graph(5, 4, 0); //Graph_Add_Edge(ns->graph, 0, 1); Graph_Add_Edge(ns->graph, 1, 3); Graph_Add_Edge(ns->graph, 1, 4); Graph_Add_Edge(ns->graph, 0, 2); Graph_Set_Directed(ns->graph, TRUE); Print_Graph(ns->graph); Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns, 1.0, NULL); Print_Swc_Tree(tree); Swc_Tree_To_Dot_File(tree, "../data/test2.dot"); #endif #if 0 int n; Neuron_Component *chain_array = Dir_Locseg_Chain_Nc("../data/fly_neuron_n22", "^chain.*\\.tb", &n, NULL); Neuron_Structure *ns = Locseg_Chain_Comp_Neurostruct(chain_array, n, NULL, 1.0, NULL); Process_Neuron_Structure(ns); Neuron_Structure* ns2= Neuron_Structure_Locseg_Chain_To_Circle(ns); Neuron_Structure_To_Tree(ns2); Graph_To_Dot_File(ns2->graph, "../data/test.dot"); Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, NULL); Swc_Tree_Remove_Zigzag(tree); //Swc_Tree_Tune_Fork(tree); //Print_Swc_Tree(tree); Write_Swc_Tree("../data/test.swc", tree); #endif #if 0 Graph *graph = Neuron_Structure_Import_Xml_Graph("../data/mouse_single_org/trueconn2.xml"); Graph_Normalize_Edge(graph); Graph_Remove_Duplicated_Edge(graph); Graph *graph2 = Neuron_Structure_Import_Xml_Graph("../data/mouse_single_org/conn.xml"); Graph_Normalize_Edge(graph2); Graph_Remove_Duplicated_Edge(graph2); Graph_Workspace *gw = New_Graph_Workspace(); int n = Graph_Edge_Count(graph, graph2->edges, graph2->nedge, gw); printf("fp: %d\n", graph2->nedge - n); printf("tp: %d\n", n); printf("fn: %d\n", graph->nedge - n); double p = (double) n / graph2->nedge; double r = (double) n / graph->nedge; printf("precision: %g\n", p); printf("recall: %g\n", r); printf("F-measure: %g\n", 2.0 * (p * r) / (p + r)); #endif #if 0 Neuron_Structure *ns = Make_Neuron_Structure(2); Local_Neuroseg *locseg = New_Local_Neuroseg(); Locseg_Chain *chain1 = New_Locseg_Chain(); Locseg_Chain_Add(chain1, locseg, NULL, DL_TAIL); Set_Neuron_Component(ns->comp, NEUROCOMP_TYPE_LOCSEG_CHAIN, chain1); Locseg_Chain *chain2 = New_Locseg_Chain(); locseg = New_Local_Neuroseg(); double bottom[3] = {10, 10, 5}; double top[3] = {5, 5, 5}; Local_Neuroseg_Set_Bottom_Top(locseg, bottom, top); Locseg_Chain_Add(chain2, locseg, NULL, DL_TAIL); Set_Neuron_Component(ns->comp + 1, NEUROCOMP_TYPE_LOCSEG_CHAIN, chain2); Neurocomp_Conn *conn = New_Neurocomp_Conn(); Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); Locseg_Chain_Connection_Test(chain2, chain1, NULL, 1.0, conn, ctw); Neuron_Structure_Add_Conn(ns, 1, 0, conn); Print_Neuron_Structure(ns); Neuron_Structure *ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); Neuron_Structure_To_Swc_File(ns2, "../data/test.swc"); #endif #if 0 int n; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd("../data/diadem_a1_part3", "^chain.*\\.tb", &n, NULL); /* Locseg_Chain **chain_array = Locseg_Chain_Import_List("../data/diadem_a1_part2/good_tube.txt", &n); */ //n = 100; /* Locseg_Chain **chain_array = (Locseg_Chain**) malloc(sizeof(Locseg_Chain*) * 2); n = 2; chain_array[0] = Read_Locseg_Chain("../data/diadem_a1_part2/chain58.tb"); chain_array[1] = Read_Locseg_Chain("../data/diadem_a1_part2/chain154.tb"); */ Stack *stack = Read_Stack("../data/diadem_a1_part3.tif"); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); Zero_Stack(mask); Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = Stack_Voxel_Number(stack); sgw->resolution[0] = 0.0375 * 2.0; sgw->resolution[1] = 0.0375 * 2.0; sgw->resolution[2] = 0.33; Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_S; Stack_Sp_Grow_Infer_Parameter(sgw, stack); Neuron_Structure *ns = Locseg_Chain_Sp_Grow_Reconstruct(chain_array, n, stack, 1.0, sgw); Print_Neuron_Structure(ns); Graph_To_Dot_File(ns->graph, "../data/test.dot"); //Neuron_Structure_To_Swc_File(ns, "../data/test.swc"); Neuron_Structure *ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); //double root[3] = {31, 430, 0}; double root[3] = {1221, 449, 8.5}; Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, root); Swc_Tree_Clean_Root(tree); Swc_Tree_Resort_Id(tree); Write_Swc_Tree("../data/test.swc", tree); #endif #if 0 int n; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd("../data/diadem_e1", "^chain.*\\.tb", &n, NULL); //n = 100; /* Locseg_Chain **chain_array = (Locseg_Chain**) malloc(sizeof(Locseg_Chain*) * 2); n = 2; chain_array[0] = Read_Locseg_Chain("../data/diadem_a1_part2/chain58.tb"); chain_array[1] = Read_Locseg_Chain("../data/diadem_a1_part2/chain154.tb"); */ Stack *stack = Read_Stack("../data/diadem_e1.tif"); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); Zero_Stack(mask); Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = Stack_Voxel_Number(stack); sgw->resolution[0] = 0.3296485; sgw->resolution[1] = 0.3296485; sgw->resolution[2] = 1.0; Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_S; Stack_Sp_Grow_Infer_Parameter(sgw, stack); Neuron_Structure *ns = Locseg_Chain_Sp_Grow_Reconstruct(chain_array, n, stack, 1.0, sgw); Print_Neuron_Structure(ns); //Neuron_Structure_To_Swc_File(ns, "../data/test.swc"); Neuron_Structure *ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); Graph_To_Dot_File(ns2->graph, "../data/test.dot"); double root[3] = {31, 430, 0}; //double root[3] = {4882, 1797, 19}; Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, root); //Swc_Tree_Clean_Root(tree); Swc_Tree_Resort_Id(tree); Write_Swc_Tree("../data/test2.swc", tree); #endif #if 0 int n; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd("../data/benchmark/stack_graph/fork", "^chain.*\\.tb", &n, NULL); Stack *stack = Read_Stack("../data/benchmark/stack_graph/fork/fork.tif"); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); Zero_Stack(mask); Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = Stack_Voxel_Number(stack); Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_S; Stack_Sp_Grow_Infer_Parameter(sgw, stack); Neuron_Structure *ns = Locseg_Chain_Sp_Grow_Reconstruct(chain_array, n, stack, 1.0, sgw); Neuron_Structure *ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, NULL); //Swc_Tree_Clean_Root(tree); Swc_Tree_Resort_Id(tree); Write_Swc_Tree("../data/test.swc", tree); #endif #if 0 int n = 3; Locseg_Chain **chain_array = (Locseg_Chain**) malloc(sizeof(Locseg_Chain) * n); chain_array[0] = Read_Locseg_Chain("/Users/zhaot/Work/neurolabi/data/benchmark/stack_graph/fork/chain0.tb"); chain_array[1] = Read_Locseg_Chain("/Users/zhaot/Work/neurolabi/data/benchmark/stack_graph/fork/chain1.tb"); chain_array[2] = New_Locseg_Chain(); printf("%d\n", Locseg_Chain_Is_Empty(chain_array[2])); Stack *stack = Read_Stack("../data/benchmark/stack_graph/fork/fork.tif"); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); Zero_Stack(mask); Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = Stack_Voxel_Number(stack); Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_S; Stack_Sp_Grow_Infer_Parameter(sgw, stack); Neuron_Structure *ns = Locseg_Chain_Sp_Grow_Reconstruct(chain_array, n, stack, 1.0, sgw); Neuron_Structure *ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, NULL); //Swc_Tree_Clean_Root(tree); Swc_Tree_Remove_Zigzag(tree); Swc_Tree_Resort_Id(tree); Write_Swc_Tree("../data/test2.swc", tree); #endif #if 0 Neuron_Structure *ns = New_Neuron_Structure(); ns->graph = New_Graph(); Graph_Add_Edge(ns->graph, 0, 1); Graph_Add_Edge(ns->graph, 0, 2); Graph_Add_Edge(ns->graph, 2, 3); Graph_Add_Edge(ns->graph, 2, 4); Graph_Add_Edge(ns->graph, 4, 5); Graph_Add_Edge(ns->graph, 5, 6); ns->conn = (Neurocomp_Conn*) malloc(sizeof(Neurocomp_Conn) * ns->graph->nedge); ns->conn[0].info[0] = 0; ns->conn[0].info[1] = 0; ns->conn[0].cost = 0.0; ns->conn[0].mode = NEUROCOMP_CONN_LINK; ns->conn[1].info[0] = 1; ns->conn[1].info[1] = 1; ns->conn[1].cost = 0.0; ns->conn[1].mode = NEUROCOMP_CONN_LINK; ns->conn[2].info[0] = 0; ns->conn[2].info[1] = 0; ns->conn[2].cost = 0.0; ns->conn[2].mode = NEUROCOMP_CONN_LINK; ns->conn[3].info[0] = 1; ns->conn[3].info[1] = 0; ns->conn[3].cost = 1.0; ns->conn[3].mode = NEUROCOMP_CONN_HL; ns->conn[4].info[0] = 0; ns->conn[4].info[1] = 1; ns->conn[4].cost = 0.0; ns->conn[4].mode = NEUROCOMP_CONN_LINK; ns->conn[5].info[0] = 1; ns->conn[5].info[1] = 1; ns->conn[5].cost = 1.0; ns->conn[5].mode = NEUROCOMP_CONN_LINK; Neuron_Structure_Merge_Locseg_Chain(ns); #endif #if 0 Neuron_Structure *ns = New_Neuron_Structure(); ns->graph = New_Graph(); ns->comp = Dir_Locseg_Chain_Nc("../data/diadem_e3", "^chain.*\\.tb", &(ns->graph->nvertex), NULL); Graph_Add_Edge(ns->graph, 0, 1); Graph_Add_Edge(ns->graph, 0, 2); Graph_Add_Edge(ns->graph, 2, 3); Graph_Add_Edge(ns->graph, 3, 4); Graph_Add_Edge(ns->graph, 4, 5); ns->conn = (Neurocomp_Conn*) malloc(sizeof(Neurocomp_Conn) * ns->graph->nedge); ns->conn[0].info[0] = 0; ns->conn[0].info[1] = 0; ns->conn[0].cost = 0.0; ns->conn[0].mode = NEUROCOMP_CONN_LINK; ns->conn[1].info[0] = 0; ns->conn[1].info[1] = 0; ns->conn[1].cost = 0.0; ns->conn[1].mode = NEUROCOMP_CONN_LINK; ns->conn[2].info[0] = 0; ns->conn[2].info[1] = 0; ns->conn[2].cost = 1.0; ns->conn[2].mode = NEUROCOMP_CONN_LINK; ns->conn[3].info[0] = 0; ns->conn[3].info[1] = 0; ns->conn[3].cost = 2.0; ns->conn[3].mode = NEUROCOMP_CONN_LINK; ns->conn[4].info[0] = 0; ns->conn[4].info[1] = 0; ns->conn[4].cost = 0.0; ns->conn[4].mode = NEUROCOMP_CONN_LINK; int i; for (i = 0; i < ns->graph->nvertex; i++) { printf("%d ", Locseg_Chain_Length(NEUROCOMP_LOCSEG_CHAIN(ns->comp+i))); } printf("\n"); Neuron_Structure_Merge_Locseg_Chain(ns); for (i = 0; i < ns->graph->nvertex; i++) { printf("%d ", Locseg_Chain_Length(NEUROCOMP_LOCSEG_CHAIN(ns->comp+i))); } printf("\n"); #endif #if 0 int n; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd("../data/diadem_e1", "^chain.*\\.tb", &n, NULL); Stack *stack = Read_Stack("../data/diadem_e1.tif"); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); Zero_Stack(mask); Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = Stack_Voxel_Number(stack); sgw->resolution[0] = 0.3296485; sgw->resolution[1] = 0.3296485; sgw->resolution[2] = 1.0; Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_S; Stack_Sp_Grow_Infer_Parameter(sgw, stack); Neuron_Structure *ns = Locseg_Chain_Sp_Grow_Reconstruct(chain_array, n, stack, 1.0, sgw); Neuron_Structure_Merge_Locseg_Chain(ns); int i; char filepath[100]; for (i = 0; i < ns->graph->nvertex; i++) { Locseg_Chain_Regularize(NEUROCOMP_LOCSEG_CHAIN(ns->comp+i)); if (Locseg_Chain_Is_Empty(NEUROCOMP_LOCSEG_CHAIN(ns->comp+i)) == FALSE) { sprintf(filepath, "../data/tmp/chain%d.tb", i); Write_Locseg_Chain(filepath, NEUROCOMP_LOCSEG_CHAIN(ns->comp+i)); } } #endif #if 0 Stack *stack = Read_Stack("../data/benchmark/fork2/fork2.tif"); Neuron_Structure *ns = New_Neuron_Structure(); ns->graph = New_Graph(); ns->comp = Dir_Locseg_Chain_Nc("../data/benchmark/fork2/tubes", "^chain.*\\.tb", &(ns->graph->nvertex), NULL); coordinate_3d_t roots[3]; roots[0][0] = 51; roots[0][1] = 23; roots[0][2] = 60; roots[1][0] = 51; roots[1][1] = 23; roots[1][2] = 40; roots[2][0] = 25; roots[2][1] = 76; roots[2][2] = 60; Neuron_Structure_Break_Root(ns, roots, 3); Neuron_Structure_Load_Root(ns, roots, 3); Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); ctw->dist_thre = 100.0; ctw->sp_test = FALSE; Locseg_Chain_Comp_Neurostruct_W(ns, stack, 1.0, ctw); Process_Neuron_Structure(ns); Neuron_Structure_To_Tree(ns); /* Neuron_Structure_Remove_Conn(ns, 0, 2); Neuron_Structure_Remove_Conn(ns, 2, 0); */ Neuron_Structure_Remove_Negative_Conn(ns); Neuron_Structure* ns2= NULL; ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); Neuron_Structure_To_Tree(ns2); Swc_Tree *tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, 1.0, NULL); Swc_Tree_Resort_Id(tree); Write_Swc_Tree("../data/test3.swc", tree); #endif #if 1 Stack *stack = NULL; Locseg_Chain *chain1 = Read_Locseg_Chain("../data/benchmark/diadem/diadem_e1/chain22.tb"); Locseg_Chain *chain2 = Read_Locseg_Chain("../data/benchmark/diadem/diadem_e1/chain0.tb"); Connection_Test_Workspace *ws = New_Connection_Test_Workspace(); Connection_Test_Workspace_Read_Resolution(ws, "../data/diadem_e3.res"); Neurocomp_Conn conn; conn.mode = NEUROCOMP_CONN_HL; Locseg_Chain_Connection_Test(chain1, chain2, stack, 1.0, &conn, ws); Print_Neurocomp_Conn(&conn); #endif return 0; }
int main(int argc, char *argv[]) { Stack *stack = Make_Stack(GREY, 3, 3, 3); int i; for (i = 0; i < Stack_Voxel_Number(stack); i++) { stack->array[i] = i; } Print_Stack(stack); printf("%g\n", Stack_Point_Sampling(stack, 1.1, 1.5, 1.0)); printf("%g\n", Stack_Point_Sampling(stack, 1.1, 1.0, 1.5)); printf("%g\n", Stack_Point_Sampling(stack, 1.1, 1.0, 1.0)); printf("%g\n", Stack_Point_Sampling(stack, 1.0, 1.5, 1.3)); printf("%g\n", Stack_Point_Sampling(stack, 1.0, 1.5, 1.0)); printf("%g\n", Stack_Point_Sampling(stack, 1.0, 1.0, 1.3)); printf("%g\n", Stack_Point_Sampling(stack, 1.0, 1.5, 1.0)); DMatrix *dm; dim_type dim[3]; dim[0] = 10; dim[1] = 4; dim[2] = 5; dm = Make_DMatrix(dim, 3); int j, k; int offset = 0; double x, y, z; dim[0] = matrix_size(dm->dim, dm->ndim); dim[1] = 3; DMatrix *points = Make_DMatrix(dim, 2); for (k = 0; k < dm->dim[2]; k++) { z = (double) (k ) * (stack->depth - 1) / (dm->dim[2] - 1); for (j = 0; j < dm->dim[1]; j++) { y = (double) (j ) * (stack->height - 1) / (dm->dim[1] - 1); for (i = 0; i < dm->dim[0]; i++) { x = (double) (i ) * (stack->width - 1) / (dm->dim[0] - 1); points->array[offset++] = x; points->array[offset++] = y; points->array[offset++] = z; } } } tic(); for (j = 0; j < 100; j++) { Stack_Points_Sampling(stack, points->array, points->dim[0], dm->array); } printf("%llu\n", toc()); DMatrix_Print(dm); Kill_Stack(stack); stack = Scale_Double_Stack(dm->array, dm->dim[0], dm->dim[1], dm->dim[2], GREY); Write_Stack("../data/test.tif", stack); Kill_Stack(stack); Kill_DMatrix(dm); Kill_DMatrix(points); return 0; }
Stack* Stack_Blend_Label_Field(const Stack *stack, const Stack *label, double alpha, const uint8_t *color_map, int color_number, Stack *out) { TZ_ASSERT(stack->kind == GREY, "Unsupported kind"); TZ_ASSERT(label->kind == GREY || label->kind == GREY16, "Unsupported kind"); TZ_ASSERT(Stack_Same_Size(stack, label), "Unmatched size"); if (alpha < 0.0) { TZ_WARN(ERROR_DATA_VALUE); alpha = 0.0; } if (alpha > 1.0) { TZ_WARN(ERROR_DATA_VALUE); alpha = 1.0; } if (out == NULL) { out = Make_Stack(COLOR, stack->width, stack->height, stack->depth); } TZ_ASSERT(out->kind == COLOR, "Unsupported kind"); color_t *out_array = (color_t*) out->array; if (color_map == NULL) { color_map = Jet_Colormap; color_number = Jet_Color_Number; } size_t voxel_number = Stack_Voxel_Number(stack); size_t offset; Image_Array ima; ima.array = label->array; for (offset = 0; offset < voxel_number; ++offset) { int label_value; if (label->kind == GREY) { label_value = ima.array8[offset]; } else { label_value = ima.array16[offset]; } int gray_value = stack->array[offset]; if (label_value > 0) { label_value = (label_value - 1) % color_number; int k; for (k = 0; k < 3; ++k) { int value = iround((1.0 - alpha) * gray_value + alpha * color_map[label_value * 3 + k]); if (value < 0) { value = 0; } else if (value > 255) { value = 255; } out_array[offset][k] = value; } } else { int k; for (k = 0; k < 3; ++k) { out_array[offset][k] = gray_value; } } #ifdef _DEBUG_2 if (out_array[offset][0] == 0 && out_array[offset][1] == 0 && out_array[offset][2] == 0) { printf("debug here\n"); } #endif } return out; }
int main(int argc, char *argv[]) { #if 0 Stack *stack = Read_Stack("../data/fly_neuron.tif"); Stretch_Stack_Value_Q(stack, 0.99); Translate_Stack(stack, GREY, 1); Write_Stack("../data/test.tif", stack); Kill_Stack(stack); #endif #if 0 int idx1, idx2, width, height; idx1 = 33332; idx2 = 65535; width = 111; height = 112; printf("%g\n", Stack_Util_Voxel_Distance(idx1, idx2, width, height)); int x1, y1, z1, x2, y2, z2; Stack_Util_Coord(idx1, width, height, &x1, &y1, &z1); Stack_Util_Coord(idx2, width, height, &x2, &y2, &z2); printf("%d, %d, %d\n", x1 - x2, y1 - y2, z1 - z2); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron.tif"); //Translate_Stack(stack, GREY16, 1); Image *image = Proj_Stack_Zmax(stack); Write_Image("../data/test.tif", image); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron_a1_org.tif"); //stack = Crop_Stack(stack, 256, 256, 0, 512, 512, 170, NULL); int i; Stack stack2; stack2.width = stack->width; stack2.height = stack->height; stack2.kind = stack->kind; stack2.depth = 1; for (i = 0; i < stack->depth; i++) { stack2.array = stack->array + i * stack->width * stack->height; //Stack *locmax = Stack_Locmax_Region(&stack2, 8); Stack *locmax = Stack_Local_Max(&stack2, NULL, STACK_LOCMAX_SINGLE); int *hist = Stack_Hist_M(&stack2, locmax); int low, high; Int_Histogram_Range(hist, &low, &high); int thre = Int_Histogram_Triangle_Threshold(hist, low, high); printf("Threshold: %d\n", thre); Stack_Threshold_Binarize(&stack2, thre); Kill_Stack(locmax); free(hist); } //Stack_Bc_Autoadjust(result); /* Translate_Stack(stack, COLOR, 1); Stack_Blend_Mc(stack, result, 0.1); */ Write_Stack("../data/test.tif", stack); #endif #if 1 Stack *stack = Read_Stack("../data/fly_neuron_crop.tif"); Filter_3d *filter = Gaussian_Filter_3d(1.0, 1.0, 0.5); Stack *out = Filter_Stack(stack, filter); Kill_FMatrix(filter) Write_Stack("../data/test.tif", out); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron_a2_org.tif"); Stack *locmax = Stack_Locmax_Region(stack, 18); Stack *mask = Read_Stack("../data/fly_neuron_a2_org/threshold_s.tif"); //Stack_And(locmax, mask, locmax); Object_3d_List *objs = Stack_Find_Object_N(locmax, NULL, 1, 0, 18); Zero_Stack(locmax); int objnum = 0; while (objs != NULL) { Object_3d *obj = objs->data; Voxel_t center; Object_3d_Central_Voxel(obj, center); Set_Stack_Pixel(locmax, center[0], center[1], center[2], 0, 1); objs = objs->next; objnum++; } Write_Stack("../data/fly_neuron_a2_org/locmax.tif", locmax); printf("objnum: %d\n", objnum); U8Matrix mat; mat.ndim = 3; mat.dim[0] = stack->width; mat.dim[1] = stack->height; mat.dim[2] = stack->depth; mat.array = locmax->array; dim_type bdim[3]; bdim[0] = 7; bdim[1] = 7; bdim[2] = 5; U8Matrix *mat2 = U8Matrix_Blocksum(&mat, bdim, NULL); int offset[3]; offset[0] = bdim[0] / 2; offset[1] = bdim[1] / 2; offset[2] = bdim[2] / 2; Crop_U8Matrix(mat2, offset, mat.dim, &mat); Write_Stack("../data/fly_neuron_a2_org/locmax_sum.tif", locmax); Stack_Threshold_Binarize(locmax, 6); Stack *clear_stack = Stack_Majority_Filter_R(locmax, NULL, 26, 4); Struct_Element *se = Make_Cuboid_Se(3, 3, 3); Stack *dilate_stack = Stack_Dilate(clear_stack, NULL, se); Stack *fill_stack = Stack_Fill_Hole_N(dilate_stack, NULL, 1, 4, NULL); Kill_Stack(dilate_stack); Stack_Not(fill_stack, fill_stack); Stack_And(fill_stack, mask, mask); Write_Stack("../data/test.tif", mask); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron_t1.tif"); Stack *locmax = Stack_Locmax_Region(stack, 6); Stack_Label_Objects_Ns(locmax, NULL, 1, 2, 3, 6); int nvoxel = Stack_Voxel_Number(locmax); int i; int s[26]; for (i = 0; i < nvoxel; i++) { if (locmax->array[i] < 3) { locmax->array[i] = 0; } else { locmax->array[i] = 1; printf("%u\n", stack->array[i]); Stack_Neighbor_Sampling_I(stack, 6, i, -1, s); iarray_print2(s, 6, 1); } } //Stack *locmax = Stack_Local_Max(stack, NULL, STACK_LOCMAX_SINGLE); Write_Stack("../data/test.tif", locmax); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron_n1.tif"); Stack *stack2 = Flip_Stack_Y(stack, NULL); Flip_Stack_Y(stack2, stack2); if (!Stack_Identical(stack, stack2)) { printf("bug found\n"); } Write_Stack("../data/test.tif", stack); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/benchmark/L3_12bit.lsm", -1); Mc_Stack_Grey16_To_8(stack, 3); Write_Mc_Stack("../data/test.lsm", stack, "../data/benchmark/L3_12bit.lsm"); #endif #if 0 //Stack *stack = Read_Stack("../data/C2-Slice06_R1_GR1_B1_L18.tif"); Stack *stack = Read_Stack("../data/fly_neuron_n1/traced.tif"); Print_Stack_Info(stack); #endif #if 0 Mc_Stack *stack = Make_Mc_Stack(GREY, 1024, 1024, 1024, 5); /* stack.width = 1024; stack.height = 1024; stack.depth = 1024; stack.kind = GREY; stack.nchannel = 5; printf("%zd\n", ((size_t)stack.kind * stack.width * stack.height * stack.depth * stack.nchannel)); */ #endif #if 0 Stack *stack = Make_Stack(GREY, 1, 1, 1); printf("stack usage: %d\n", Stack_Usage()); uint8 *data = stack->array; stack->array = NULL; Kill_Stack(stack); stack = Read_Stack("../data/benchmark/line.tif"); free(data); printf("stack usage: %d\n", Stack_Usage()); #endif #if 0 Stack *stack = Read_Stack("../data/test.tif"); int *hist = Stack_Hist(stack); Print_Int_Histogram(hist); #endif #if 0 Stack *stack = Read_Stack("../data/benchmark/mouse_neuron_single/stack.tif"); Stack dst; dst.text = "\0"; dst.array = stack->array; Crop_Stack(stack, 0, 0, 0, stack->width - 100, stack->height - 100, stack->depth - 30, &dst); Write_Stack("../data/test.tif", &dst); #endif #if 0 Stack *stack = Make_Stack(GREY, 5, 5, 3); Zero_Stack(stack); Set_Stack_Pixel(stack, 2, 2, 1, 0, 1.0); Print_Stack_Value(stack); Stack *out = Stack_Running_Max(stack, 0, NULL); out = Stack_Running_Max(out, 1, out); out = Stack_Running_Max(out, 2, out); Print_Stack_Value(out); #endif #if 0 Stack *stack = Read_Stack("../data/benchmark/stack_graph/fork/fork.tif"); Stack *out = Stack_Running_Median(stack, 0, NULL); Stack_Running_Median(out, 1, out); //Stack_Running_Max(stack, 0, out); //Stack_Running_Max(out, 1, out); Write_Stack("../data/test.tif", out); Stack *out2 = Stack_Running_Median(stack, 0, NULL); Stack *out3 = Stack_Running_Median(out2, 1, NULL); if (Stack_Identical(out, out3)) { printf("Same in-place and out-place\n"); } #endif #if 0 Stack *stack = Read_Stack_U("../data/diadem_d1_147.xml"); printf("%d\n", Stack_Threshold_Quantile(stack, 0.9)); #endif #if 0 const char *filepath = "/Users/zhaot/Data/Julie/All_tiled_nsyb5_Sum.lsm"; char filename[100]; fname(filepath, filename); Mc_Stack *stack = Read_Mc_Stack(filepath, -1); Print_Mc_Stack_Info(stack); Mc_Stack *tmpstack = Make_Mc_Stack(stack->kind, stack->width, stack->height, stack->depth / 8, stack->nchannel); size_t channel_size = stack->kind * stack->width *stack->height * stack->depth; size_t channel_size2 = tmpstack->kind * tmpstack->width *tmpstack->height * tmpstack->depth; int i; int k; uint8_t *array = stack->array; for (k = 0; k < 8; k++) { int offset = 0; int offset2 = 0; for (i = 0; i < stack->nchannel; i++) { memcpy(tmpstack->array + offset2, array + offset, channel_size2); offset += channel_size; offset2 += channel_size2; } array += channel_size2; char outpath[500]; sprintf(outpath, "../data/test/%s_%03d.lsm", filename, k); Write_Mc_Stack(outpath, tmpstack, filepath); } #endif #if 0 Stack *stack = Index_Stack(GREY16, 5, 5, 1); Set_Stack_Pixel(stack, 1, 1, 0, 0, 0); Set_Stack_Pixel(stack, 1, 2, 0, 0, 0); Print_Stack_Value(stack); Stack *out = Stack_Neighbor_Median(stack, 8, NULL); Print_Stack_Value(out); #endif #if 0 Stack *stack = Make_Stack(GREY, 10, 10, 3); Zero_Stack(stack); Cuboid_I bound_box; Set_Stack_Pixel(stack, 1, 1, 1, 0, 1); Set_Stack_Pixel(stack, 1, 2, 1, 0, 1); Set_Stack_Pixel(stack, 3, 1, 2, 0, 1); Stack_Bound_Box(stack, &bound_box); Print_Cuboid_I(&bound_box); #endif #if 0 Stack_Document *doc = Xml_Read_Stack_Document("../data/test.xml"); File_List *list = (File_List*) doc->ci; Cuboid_I bound_box; Stack_Bound_Box_F(list, &bound_box); Print_Cuboid_I(&bound_box); #endif #if 0 Stack_Document *doc = Xml_Read_Stack_Document("../data/test.xml"); File_List *list = (File_List*) doc->ci; Print_File_List(list); Stack *stack = Read_Image_List_Bounded(list); Stack *out = stack; out = Stack_Region_Expand(stack, 8, 1, NULL); out = Downsample_Stack(out, 4, 4, 0); Write_Stack("../data/test.tif", out); #endif #if 0 Stack_Document *doc = Xml_Read_Stack_Document( "../data/ting_example_stack/test.xml"); File_List *list = (File_List*) doc->ci; Print_File_List(list); int i; for (i = 0; i < list->file_number; i++) { Stack *stack = Read_Stack_U(list->file_path[i]); Stack *ds = Downsample_Stack(stack, 39, 39, 0); char file_path[500]; sprintf(file_path, "../data/ting_example_stack/thumbnails/tb%05d.tif", i); Write_Stack(file_path, ds); Free_Stack(stack); } #endif #if 0 Stack *stack = Read_Stack("../data/test2.tif"); Stack_Threshold_Binarize(stack, 6); Objlabel_Workspace ow; STACK_OBJLABEL_OPEN_WORKSPACE(stack, (&ow)); Object_3d *obj = Stack_Find_Largest_Object_N(stack, ow.chord, 1, 26); //Print_Object_3d(obj); //printf("%llu\n", obj->size); double vec[3]; Object_3d_Orientation(obj, vec, MAJOR_AXIS); double center[3]; Object_3d_Centroid(obj, center); darray_print2(vec, 3, 1); double span[2] = {100000, -100000}; for (int i = 0; i < obj->size; i++) { double proj = Geo3d_Dot_Product(vec[0], vec[1], vec[2], (double) obj->voxels[i][0] - center[0], (double) obj->voxels[i][1] - center[1], (double) obj->voxels[i][2] - center[2]); if (proj < span[0]) { span[0] = proj; } if (proj > span[1]) { span[1] = proj; } } darray_print2(span, 2, 1); double vec2[3]; Object_3d_Orientation(obj, vec2, PLANE_NORMAL); darray_print2(vec2, 3, 1); double span2[2] = {100000, -100000}; for (int i = 0; i < obj->size; i++) { double proj = Geo3d_Dot_Product(vec2[0], vec2[1], vec2[2], (double) obj->voxels[i][0] - center[0], (double) obj->voxels[i][1] - center[1], (double) obj->voxels[i][2] - center[2]); if (proj < span2[0]) { span2[0] = proj; } if (proj > span2[1]) { span2[1] = proj; } } darray_print2(span2, 2, 1); double vec3[3]; Geo3d_Cross_Product(vec[0], vec[1], vec[2], vec2[0], vec2[1], vec2[2], vec3, vec3+1, vec3+2); double span3[2] = {100000, -100000}; int i; for (i = 0; i < obj->size; i++) { double proj = Geo3d_Dot_Product(vec3[0], vec3[1], vec3[2], (double) obj->voxels[i][0] - center[0], (double) obj->voxels[i][1] - center[1], (double) obj->voxels[i][2] - center[2]); if (proj < span3[0]) { span3[0] = proj; } if (proj > span3[1]) { span3[1] = proj; } } darray_print2(span3, 2, 1); coordinate_3d_t vertex[8]; for (i = 0; i < 8; i++) { Coordinate_3d_Copy(vertex[i], center); int j; for (j = 0; j < 3; j++) { vertex[i][j] += span[0] * vec[j] + span2[0] * vec2[j] + span3[0] * vec3[j]; } } for (i = 0; i < 3; i++) { vertex[1][i] += (span[1] - span[0]) * vec[i]; vertex[2][i] += (span2[1] - span2[0]) * vec2[i]; vertex[3][i] += (span3[1] - span3[0]) * vec3[i]; vertex[4][i] = vertex[1][i] + (span2[1] - span2[0]) * vec2[i]; vertex[5][i] = vertex[2][i] + (span3[1] - span3[0]) * vec3[i]; vertex[6][i] = vertex[3][i] + (span[1] - span[0]) * vec[i]; vertex[7][i] = vertex[5][i] + (span[1] - span[0]) * vec[i]; } FILE *fp = fopen("../data/test.swc", "w"); fprintf(fp, "%d %d %g %g %g %g %d\n", 1, 2, vertex[0][0], vertex[0][1], vertex[0][2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 2, 2, vertex[1][0], vertex[1][1], vertex[1][2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 3, 2, vertex[2][0], vertex[2][1], vertex[2][2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 4, 2, vertex[3][0], vertex[3][1], vertex[3][2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 5, 2, vertex[4][0], vertex[4][1], vertex[4][2], 3.0, 2); fprintf(fp, "%d %d %g %g %g %g %d\n", 6, 2, vertex[5][0], vertex[5][1], vertex[5][2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 7, 2, vertex[6][0], vertex[6][1], vertex[6][2], 3.0, 4); fprintf(fp, "%d %d %g %g %g %g %d\n", 8, 2, vertex[7][0], vertex[7][1], vertex[7][2], 3.0, 7); fprintf(fp, "%d %d %g %g %g %g %d\n", 9, 2, vertex[4][0], vertex[4][1], vertex[4][2], 3.0, 8); fprintf(fp, "%d %d %g %g %g %g %d\n", 10, 2, vertex[4][0], vertex[4][1], vertex[4][2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 11, 2, vertex[5][0], vertex[5][1], vertex[5][2], 3.0, 8); fprintf(fp, "%d %d %g %g %g %g %d\n", 12, 2, vertex[5][0], vertex[5][1], vertex[5][2], 3.0, 4); fprintf(fp, "%d %d %g %g %g %g %d\n", 13, 2, vertex[6][0], vertex[6][1], vertex[6][2], 3.0, 2); /* Geo3d_Scalar_Field *field = Make_Geo3d_Scalar_Field(6); field->points[0][0] = span[0] * vec[0] + center[0]; field->points[0][1] = span[0] * vec[1] + center[1]; field->points[0][2] = span[0] * vec[2] + center[2]; field->points[1][0] = span[1] * vec[0] + center[0]; field->points[1][1] = span[1] * vec[1] + center[1]; field->points[1][2] = span[1] * vec[2] + center[2]; field->points[2][0] = span2[0] * vec2[0] + center[0]; field->points[2][1] = span2[0] * vec2[1] + center[1]; field->points[2][2] = span2[0] * vec2[2] + center[2]; field->points[3][0] = span2[1] * vec2[0] + center[0]; field->points[3][1] = span2[1] * vec2[1] + center[1]; field->points[3][2] = span2[1] * vec2[2] + center[2]; field->points[4][0] = span3[0] * vec3[0] + center[0]; field->points[4][1] = span3[0] * vec3[1] + center[1]; field->points[4][2] = span3[0] * vec3[2] + center[2]; field->points[5][0] = span3[1] * vec3[0] + center[0]; field->points[5][1] = span3[1] * vec3[1] + center[1]; field->points[5][2] = span3[1] * vec3[2] + center[2]; coordinate_3d_t corner[2]; Geo3d_Scalar_Field_Boundbox(field, corner); darray_print2(corner[0], 3, 1); darray_print2(corner[1], 3, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 1, 2, corner[0][0], corner[0][1], corner[0][2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 2, 2, corner[1][0], corner[0][1], corner[0][2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 3, 2, corner[1][0], corner[1][1], corner[0][2], 3.0, 2); fprintf(fp, "%d %d %g %g %g %g %d\n", 4, 2, corner[0][0], corner[1][1], corner[0][2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 5, 2, corner[0][0], corner[0][1], corner[0][2], 3.0, 4); fprintf(fp, "%d %d %g %g %g %g %d\n", 6, 2, corner[0][0], corner[0][1], corner[1][2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 7, 2, corner[1][0], corner[0][1], corner[1][2], 3.0, 6); fprintf(fp, "%d %d %g %g %g %g %d\n", 8, 2, corner[1][0], corner[1][1], corner[1][2], 3.0, 7); fprintf(fp, "%d %d %g %g %g %g %d\n", 9, 2, corner[0][0], corner[1][1], corner[1][2], 3.0, 8); fprintf(fp, "%d %d %g %g %g %g %d\n", 10, 2, corner[0][0], corner[0][1], corner[1][2], 3.0, 9); fprintf(fp, "%d %d %g %g %g %g %d\n", 11, 2, corner[0][0], corner[0][1], corner[1][2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 12, 2, corner[1][0], corner[0][1], corner[1][2], 3.0, 2); fprintf(fp, "%d %d %g %g %g %g %d\n", 13, 2, corner[1][0], corner[1][1], corner[1][2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 14, 2, corner[0][0], corner[1][1], corner[1][2], 3.0, 4); */ /* fprintf(fp, "%d %d %g %g %g %g %d\n", 5, 2, corner[1][0], corner[1][1], corner[1][2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 6, 2, corner[0][0], corner[1][1], corner[1][2], 3.0, 6); fprintf(fp, "%d %d %g %g %g %g %d\n", 7, 2, corner[1][0], corner[0][1], corner[1][2], 3.0, 7); fprintf(fp, "%d %d %g %g %g %g %d\n", 8, 2, corner[1][0], corner[1][1], corner[0][2], 3.0, 7); fprintf(fp, "%d %d %g %g %g %g %d\n", 12, 2, corner[1][0], corner[1][1], corner[0][2], 3.0, 2); fprintf(fp, "%d %d %g %g %g %g %d\n", 9, 2, corner[1][0], corner[1][1], corner[1][2], 3.0, 6); fprintf(fp, "%d %d %g %g %g %g %d\n", 10, 2, corner[0][0], corner[1][1], corner[1][2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 11, 2, corner[1][0], corner[0][1], corner[1][2], 3.0, 4); fprintf(fp, "%d %d %g %g %g %g %d\n", 12, 2, corner[1][0], corner[1][1], corner[0][2], 3.0, -1); */ fprintf(fp, "%d %d %g %g %g %g %d\n", 21, 2, span[0] * vec[0] + center[0], span[0] * vec[1] + center[1], span[0] * vec[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 22, 2, span[1] * vec[0] + center[0], span[1] * vec[1] + center[1], span[1] * vec[2] + center[2], 3.0, 21); fprintf(fp, "%d %d %g %g %g %g %d\n", 23, 2, span2[0] * vec2[0] + center[0], span2[0] * vec2[1] + center[1], span2[0] * vec2[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 24, 2, span2[1] * vec2[0] + center[0], span2[1] * vec2[1] + center[1], span2[1] * vec2[2] + center[2], 3.0, 23); fprintf(fp, "%d %d %g %g %g %g %d\n", 25, 2, span3[0] * vec3[0] + center[0], span3[0] * vec3[1] + center[1], span3[0] * vec3[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 26, 2, span3[1] * vec3[0] + center[0], span3[1] * vec3[1] + center[1], span3[1] * vec3[2] + center[2], 3.0, 25); fclose(fp); //double corner[6]; /* FILE *fp = fopen("../data/test.swc", "w"); fprintf(fp, "%d %d %g %g %g %g %d\n", 1, 2, span[0] * vec[0] + center[0], span[0] * vec[1] + center[1], span[0] * vec[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 2, 2, span[1] * vec[0] + center[0], span[1] * vec[1] + center[1], span[1] * vec[2] + center[2], 3.0, 1); fprintf(fp, "%d %d %g %g %g %g %d\n", 3, 2, span2[0] * vec2[0] + center[0], span2[0] * vec2[1] + center[1], span2[0] * vec2[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 4, 2, span2[1] * vec2[0] + center[0], span2[1] * vec2[1] + center[1], span2[1] * vec2[2] + center[2], 3.0, 3); fprintf(fp, "%d %d %g %g %g %g %d\n", 5, 2, span3[0] * vec3[0] + center[0], span3[0] * vec3[1] + center[1], span3[0] * vec3[2] + center[2], 3.0, -1); fprintf(fp, "%d %d %g %g %g %g %d\n", 6, 2, span3[1] * vec3[0] + center[0], span3[1] * vec3[1] + center[1], span3[1] * vec3[2] + center[2], 3.0, 5); fclose(fp); */ //calculate corners //Draw the six line of the corners /* Stack *stack2 = Copy_Stack(stack); Zero_Stack(stack2); int i = 0; for (i = 0; i < obj->size; i++) { stack2->array[Stack_Util_Offset(obj->voxels[i][0], obj->voxels[i][1], obj->voxels[i][2], stack->width, stack->height, stack->depth)] = 1; } Write_Stack("../data/test.tif", stack2); */ #endif #if 0 Stack *stack = Read_Stack("../data/test2.tif"); Stack_Threshold_Binarize(stack, 6); Objlabel_Workspace ow; STACK_OBJLABEL_OPEN_WORKSPACE(stack, (&ow)); ow.conn = 26; ow.init_chord = TRUE; int obj_size = Stack_Label_Largest_Object_W(stack, 1, 2, &ow); Object_3d *obj = Make_Object_3d(obj_size, ow.conn); extract_object(ow.chord, ow.seed, obj); //Print_Object_3d(obj); /* STACK_OBJLABEL_CLOSE_WORKSPACE((&ow)); Objlabel_Workspace *ow = New_Objlabel_Workspace(); ow->conn = 26; ow->init_chord = TRUE; STACK_OBJLABEL_OPEN_WORKSPACE(stack, ow); Stack_Label_Largest_Object_W(stack, 1, 2, ow); */ Write_Stack("../data/test3.tif", stack); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/test2.tif", -1); Print_Mc_Stack_Info(stack); size_t offset; size_t voxelNumber = Mc_Stack_Voxel_Number(stack); uint8_t* arrayc[3] = {NULL, NULL, NULL}; arrayc[0] = stack->array; arrayc[1] = stack->array + voxelNumber; arrayc[2] = stack->array + voxelNumber * 2; for (offset = 0; offset < voxelNumber; ++offset) { if ((arrayc[0][offset] != 128) || (arrayc[1][offset] != 6) || (arrayc[2][offset] != 0)) { arrayc[0][offset] = 0; arrayc[1][offset] = 0; arrayc[2][offset] = 0; } } Write_Mc_Stack("../data/test.tif", stack, NULL); Kill_Mc_Stack(stack); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/flyem/TEM/slice_figure/segmentation/selected_body.tif", -1); Print_Mc_Stack_Info(stack); size_t offset; size_t voxelNumber = Mc_Stack_Voxel_Number(stack); Stack *mask = Make_Stack(GREY, stack->width, stack->height, stack->depth); uint8_t* arrayc[4] = {NULL, NULL, NULL, NULL}; int i; for (i = 0; i < 4; ++i) { arrayc[i] = stack->array + voxelNumber * i; } for (offset = 0; offset < voxelNumber; ++offset) { if ((arrayc[0][offset] > 0) || (arrayc[1][offset] > 0) || (arrayc[2][offset] > 0) || (arrayc[3][offset] > 0)) { mask->array[offset] = 1; } else { mask->array[offset] = 0; } } mask = Downsample_Stack_Max(mask, 7, 7, 0, NULL); Write_Stack("../data/test.tif", mask); #endif #if 0 Stack *stack = Read_Stack("../data/test2.tif"); size_t offset; size_t voxelNumber = Stack_Voxel_Number(stack); color_t *arrayc = (color_t*) stack->array; for (offset = 0; offset < voxelNumber; ++offset) { if ((arrayc[offset][0] != 128) || (arrayc[offset][1] != 6) || (arrayc[offset][2] != 0)) { arrayc[offset][0] = 0; arrayc[offset][1] = 0; arrayc[offset][2] = 0; } } Write_Stack("../data/test.tif", stack); #endif #if 0 Stack *stack = Read_Stack("../data/flyem/TEM/slice_figure/segmentation/selected_body_volume.tif"); Stack *out = Make_Stack(COLOR, stack->width, stack->height, stack->depth); Zero_Stack(out); Object_3d_List *objs = Stack_Find_Object_N(stack, NULL, 255, 0, 26); Print_Object_3d_List_Compact(objs); uint8_t color[] = {0, 200, 50, 200, 0, 0}; uint8_t *color2 = color; while (objs != NULL) { Object_3d *obj = objs->data; Stack_Draw_Object_C(out, obj, color2[0], color2[1], color2[2]); color2 += 3; objs = objs->next; break; } Write_Stack("../data/test.tif", out); #endif #if 0 //Stack *stack = Read_Stack("../data/benchmark/binary/2d/btrig2.tif"); Stack *stack = Make_Stack(GREY, 3, 3, 3); One_Stack(stack); //Zero_Stack(stack); //Set_Stack_Pixel(stack, 0, 1, 1, 1, 1); Set_Stack_Pixel(stack, 0, 1, 1, 1, 0); Set_Stack_Pixel(stack, 0, 1, 1, 0, 0); Set_Stack_Pixel(stack, 0, 0, 0, 0, 0); Set_Stack_Pixel(stack, 0, 0, 2, 0, 0); Set_Stack_Pixel(stack, 0, 2, 0, 0, 0); Set_Stack_Pixel(stack, 0, 2, 2, 0, 0); Set_Stack_Pixel(stack, 0, 0, 0, 2, 0); Set_Stack_Pixel(stack, 0, 0, 2, 2, 0); Set_Stack_Pixel(stack, 0, 2, 0, 2, 0); Set_Stack_Pixel(stack, 0, 2, 2, 2, 0); //Set_Stack_Pixel(stack, 0, 1, 1, 2, 0); Stack_Graph_Workspace *sgw = New_Stack_Graph_Workspace(); //Default_Stack_Graph_Workspace(sgw); sgw->signal_mask = stack; Graph *graph = Stack_Graph_W(stack, sgw); sgw->signal_mask = NULL; //Print_Graph(graph); //Graph_To_Dot_File(graph, "../data/test.dot"); if (Graph_Has_Hole(graph) == TRUE) { printf("The graph has a hole.\n"); } #endif #if 0 Stack *stack = Read_Stack("../data/flyem/skeletonization/session3/T1_207.tif"); size_t voxel_number = Stack_Voxel_Number(stack); size_t i; for (i = 0; i < voxel_number; ++i) { if (stack->array[i] == 1) { stack->array[i] = 255; } } Filter_3d *filter = Gaussian_Filter_3d(0.5, 0.5, 0.5); Stack *out = Filter_Stack(stack, filter); Write_Stack("../data/test2.tif", out); #endif #if 0 Stack *stack = Make_Stack(GREY, 3, 3, 3); Zero_Stack(stack); Cuboid_I cuboid; Cuboid_I_Set_S(&cuboid, 0, 0, 0, 4, 2, 3); Cuboid_I_Label_Stack(&cuboid, 1, stack); Print_Stack_Value(stack); #endif #if 0 Stack *stack = Make_Stack(GREY, 3, 3, 1); Zero_Stack(stack); Set_Stack_Pixel(stack, 1, 1, 0, 0, 1); Print_Stack_Value(stack); Stack *out = Downsample_Stack_Max(stack, 2, 2, 2, NULL); Print_Stack_Value(out); #endif #if 0 double t[3] = {1, 2 * 256 + 12, 255 * 256}; printf("%g\n", Stack_Voxel_Weight_C(t)); #endif #if 0 Stack *stack = Read_Stack_U("../data/vr/label.tif"); Stack_Binarize_Level(stack, 1); Stack_Label_Large_Objects_N(stack, NULL, 1, 2, 2000, 4); Stack_Threshold_Binarize(stack, 2); Write_Stack("../data/vr/label1.tif", stack); #endif #if 0 Stack *stack = Read_Stack_U("../data/vr/label.tif"); Stack_Binarize_Level(stack, 5); Stack_Label_Large_Objects_N(stack, NULL, 1, 2, 5000, 4); Stack_Threshold_Binarize(stack, 2); Write_Stack("../data/vr/label5.tif", stack); #endif #if 0 Stack *stack = Read_Stack_U("../data/vr/original.tif"); /* Make mask */ Stack *mask = Make_Stack(GREY, Stack_Width(stack), Stack_Height(stack), Stack_Depth(stack)); Zero_Stack(mask); Stack *overallLabel = Copy_Stack(mask); Stack *labelStack[5]; size_t voxelNumber = Stack_Voxel_Number(mask); size_t k; Struct_Element *se = Make_Disc_Se(5); int i; char filePath[100]; for (i = 0; i < 5; ++i) { sprintf(filePath, "../data/vr/label%d.tif", i + 1); labelStack[i] = Read_Stack_U(filePath); //labelStack[i] = Stack_Erode_Fast(labelStack[i], NULL, se); Stack_Or(mask, labelStack[i], mask); for (k = 0; k < voxelNumber; ++k) { if (labelStack[i]->array[k] == 1) { overallLabel->array[k] = i + 1; } } } for (k = 0; k < voxelNumber; ++k) { if (mask->array[k] == 1) { mask->array[k] = SP_GROW_SOURCE; } } Sp_Grow_Workspace *sgw = New_Sp_Grow_Workspace(); sgw->size = voxelNumber; Sp_Grow_Workspace_Set_Mask(sgw, mask->array); sgw->wf = Stack_Voxel_Weight_C; sgw->sp_option = 1; tic(); Int_Arraylist *path = Stack_Sp_Grow(stack, NULL, 0, NULL, 0, sgw); printf("time: %llu\n", toc()); Kill_Int_Arraylist(path); for (k = 0; k < voxelNumber; ++k) { if (mask->array[k] == 0) { int idx = (int) k; while (overallLabel->array[idx] == 0) { idx = sgw->path[idx]; } int label = overallLabel->array[idx]; idx = (int) k; while (overallLabel->array[idx] == 0) { overallLabel->array[idx] = label; idx = sgw->path[idx]; } } } for (k = 0; k < voxelNumber; ++k) { if (overallLabel->array[k] == 1 || overallLabel->array[k] == 5) { overallLabel->array[k] = 0; } } Write_Stack("../data/test.tif", overallLabel); Kill_Stack(stack); #endif return 0; }
int main(int argc, char* argv[]) { #if 0 Mc_Stack *mc_stack = Read_Mc_Stack("../data/benchmark/L3_12bit.lsm", -1); Stack *stack = Mc_Stack_To_Stack(mc_stack, COLOR, NULL); Write_Stack_U("../data/test.lsm", stack, "../data/benchmark/L3_12bit.lsm"); #endif #if 0 //Print_Lsm_Info("/Users/zhaot/Data/stitching_12bit/70208_2BcPhR_R1_GR1_B1_L001.lsm"); Mc_Stack *stack = Read_Mc_Stack("../data/benchmark/L3_12bit.lsm", -1); Print_Mc_Stack_Info(stack); Mc_Stack_Grey16_To_8(stack, 1); Write_Mc_Stack("../data/test.lsm", stack, "../data/benchmark/L3_12bit.lsm"); #endif #if 0 Read_Stack("/Users/zhaot/Data/slice15overlay/L05.tif"); #endif #if 0 /* char *filePath = "test"; if( strlen(filePath)>4 ) if( strcmp(filePath+strlen(filePath)-4,".tif")==0 || strcmp(filePath+strlen(filePath)-4,".TIF")==0 ) printf("%d\n", 1); printf("%d\n", 0); */ Is_Tiff("test"); //Write_Stack("/Users/zhaot/Work/neurolabi/data/test.tif", Read_Stack("/Users/zhaot/Data/slice15overlay/L03.tif")); Write_Stack("../data/test.tif", Read_Stack("../data/L05.tif")); #endif #if 0 Stack *stack = Read_Stack("../data/fly_neuron.tif"); Write_Stack("../data/test2.tif", stack); #endif #if 0 int big_endian; Tiff_Reader *tif = Open_Tiff_Reader("/Users/zhaot/Data/Stacks for stitching/Set 1 65C07/GL_100708_R1_GR1_B1_L013.lsm", &big_endian, 1); Tiff_Writer *tif2 = Open_Tiff_Writer("../data/test.tif", 0); Tiff_IFD *ifd = NULL; int depth = 0; while ((ifd = Read_Tiff_IFD(tif)) != NULL) { if (Convert_LSM_2_RGB(ifd, 0, 0) != NULL) { Write_Tiff_IFD(tif2, ifd); depth++; } Free_Tiff_IFD(ifd); } printf("%d\n", depth); //Kill_Tiff_IFD(ifd); Kill_Tiff_Reader(tif); Close_Tiff_Writer(tif2); Stack *stack = Read_Stack("../data/test.tif"); Write_Stack("../data/test.tif", stack); #endif #if 0 Tiff_Reader *reader; reader = Open_Tiff_Reader("../data/test.lsm",NULL,1); Tiff_IFD *ifd = Read_Tiff_IFD(reader); Print_Tiff_IFD(ifd, stdout); Kill_Tiff_Reader(reader); #endif #if 0 Stack *stack = Read_Lsm_Stack("/Users/zhaot/Data/stitch/Set 3 17F12/GL_100208_R1_GR1_B1_L07.lsm", -1); //Stack *stack = Read_Lsm_Stack("/Users/zhaot/Data/nathan/2p internal[497-545,565-649nm] 40x 2x12us 900nm 5pct cleared 1.lsm", 0); Tiff_IFD *ifd; { Tiff_Reader *reader; reader = Open_Tiff_Reader("/Users/zhaot/Data/stitch/Set 3 17F12/GL_100208_R1_GR1_B1_L08.lsm",NULL,1); while (lsm_thumbnail_flag(ifd = Read_Tiff_IFD(reader)) != 0) { //Advance_Tiff_Reader(reader); if (End_Of_Tiff(reader)) { ifd = NULL; TZ_ERROR(ERROR_IO_READ); break; } } } //Write_Stack("../data/test.tif", stack); Print_Tiff_IFD(ifd, stdout); if (stack != NULL) { Write_Lsm_Stack("../data/test.lsm", stack, ifd); } stack = Read_Lsm_Stack("../data/test.lsm", -1); Write_Stack("../data/test.tif", stack); #endif #if 0 Mc_Stack *mc_stack = Read_Mc_Stack("../data/test.tif", 1); Print_Mc_Stack_Info(mc_stack); Write_Mc_Stack("../data/test2.tif", mc_stack, NULL); Free_Mc_Stack(mc_stack); mc_stack = Read_Mc_Stack("../data/test2.tif", -1); Print_Mc_Stack_Info(mc_stack); printf("%d\n", Mc_Stack_Usage()); #endif #if 0 Stack *stack = Read_Lsm_Stack("../data/test.lsm", -1); Print_Stack_Info(stack); Write_Stack("../data/test.tif", stack); #endif #if 0 Fix_Lsm_File("../data/test/result1.lsm"); Print_Lsm_Info("../data/test/result1.lsm"); #endif #if 0 Stack *stack = Make_Stack(1, 5, 5, 5); int nvoxel = Stack_Voxel_Number(stack); int i; for (i = 0; i < nvoxel; i++) { stack->array[i] = i; } Write_Stack("../data/test.tif", stack); stack = Read_Stack("../data/test.tif"); Write_Stack("../data/test2.tif", stack); #endif #if 0 Stack *stack = Read_Stack(fullpath("../data/fly_neuron_n11/", "mask2.tif", NULL)); Print_Stack_Info(stack); #endif #if 0 //Print_Lsm_Info("/Users/zhaot/Data/stitch/Set 3 17F12/GL_100208_R1_GR1_B1_L07.lsm"); //FILE *fp = fopen("/Users/zhaot/Data/stitch/set1/GL_100708_R1_GR1_B1_L015.lsm", "r"); FILE *fp = fopen("../data/test.lsm", "r"); char endian[3]; endian[2] = '\0'; fread(endian, 1, 2, fp); printf("Endian: %s\n", endian); uint16_t magic; fread(&magic, 2, 1, fp); printf("Magic number: %u\n", magic); uint32_t ifd_offset; fread(&ifd_offset, 4, 1, fp); printf("1st IFD offset: %u\n", ifd_offset); fseek(fp, ifd_offset, SEEK_SET); uint16_t nifd; fread(&nifd, 2, 1, fp); printf("Number of IFD: %u\n", nifd); uint16_t ifd_label; fread(&ifd_label, 2, 1, fp); uint16_t i; for (i = 1; i < nifd; i++) { if (ifd_label == TIF_CZ_LSMINFO) { break; } fseek(fp, 10, SEEK_CUR); fread(&ifd_label, 2, 1, fp); } printf("IFD label: %u\n", ifd_label); uint16_t ifd_type; fread(&ifd_type, 2, 1, fp); printf("IFD type: %u\n", ifd_type); uint32_t ifd_length; fread(&ifd_length, 4, 1, fp); printf("IFD length: %u\n", ifd_length); fread(&ifd_offset, 4, 1, fp); printf("Lsm info offset: %u\n", ifd_offset); /* fseek(fp, ifd_offset + CZ_LSMINFO_DIMZ_OFFSET, SEEK_SET); int32_t dimz = 80; fwrite(&dimz, 4, 1, fp); printf("Number of slices: %d\n", dimz); */ int offset = 88; fseek(fp, ifd_offset, SEEK_SET); /* uint32_t value = 0; fwrite(&value, 4, 1, fp); fseek(fp, ifd_offset + offset, SEEK_SET); */ /* Fprint_File_Binary(fp, 24, stdout); fclose(fp); return 1; */ Cz_Lsminfo lsminfo; fread(&lsminfo, sizeof(Cz_Lsminfo), 1, fp); printf("%lu\n", sizeof(Cz_Lsminfo)); if (lsminfo.u32MagicNumber == 67127628) { printf("Version 1.5, 1.6 and 2.0\n"); } else if (lsminfo.u32MagicNumber == 50350412) { printf("Version 1.3\n"); } else { printf("Unknown version\n"); return 1; } printf("Structure size: %d\n", lsminfo.s32StructureSize); printf("Stack size: %d x %d x %d\n", lsminfo.s32DimensionX, lsminfo.s32DimensionY, lsminfo.s32DimensionZ); printf("Number of channels: %d\n", lsminfo.s32DimensionChannels); switch (lsminfo.s32DataType) { case 1: printf("8-bit unsigned integer.\n"); break; case 2: printf("12-bit unsigned integer.\n"); break; case 5: printf("32-bit float.\n"); break; case 0: printf("Different channels have different types.\n"); break; } printf("Thumbnail size: %d x %d\n", lsminfo.s32ThumbnailX, lsminfo.s32ThumbnailY); printf("Voxel size: %g x %g x %g um\n", lsminfo.f64VoxelSizeX * 1000000, lsminfo.f64VoxelSizeY * 1000000, lsminfo.f64VoxelSizeZ * 1000000); printf("Scan type: "); switch (lsminfo.u16ScanType) { case 0: printf("normal x-y-z-scan\n"); break; case 1: printf("Z-Scan\n"); break; case 2: printf("Line Scan\n"); break; case 3: printf("Time series x-y\n"); break; case 4: printf("Time series x-z\n"); break; case 5: printf("Time series - Mean of ROIS\n"); break; } if (lsminfo.u32OffsetVectorOverlay == 0) { printf("There is no vector overlay\n"); } else { printf("Vector overlay found\n"); } if (lsminfo.u32OffsetInputLut == 0) { printf("There is no input LUT\n"); } else { printf("Input LUT found\n"); } if (lsminfo.u32OffsetOutputLut == 0) { printf("There is no color palette\n"); } else { printf("Color palette found\n"); } if (lsminfo.u32OffsetChannelColors == 0) { printf("There is no channel color or channel name\n"); } else { printf("Channel colors and channel names fournd\n"); } if (lsminfo.f64TimeInterval == 0) { printf("There is no time interval\n"); } else { printf("Time interval: %lg sec\n", lsminfo.f64TimeInterval); } if (lsminfo.u32OffsetScanInformation == 0) { printf("There is no information about devide settings\n"); } else { printf("Scan information found. Offset: %u\n", lsminfo.u32OffsetScanInformation); /* Lsm_Scan_Info *info = (Lsm_Scan_Info*) (data + lsminfo.u32OffsetScanInformation + 20); printf("Information type: %u\n", info->u32Entry); printf("Data type: %u\n", info->u32Type); printf("Data size: %u\n", info->u32Size); */ /* uint8_t *byte = (uint8_t*) (data + lsminfo.u32OffsetScanInformation); printf("%u\n", byte[8]); */ } if (lsminfo.u32OffsetKsData == 0) { printf("There is no Zeiss Vision KS-3d data\n"); } else { printf("Zeiss Vision KS-3d data found. Offset: %u\n", lsminfo.u32OffsetKsData); } if (lsminfo.u32OffsetRoi == 0) { printf("There is no ROI\n"); } else { printf("ROI found\n"); } if (lsminfo.u32OffsetNextRecording == 0) { printf("There is no second image\n"); } else { printf("Second image found\n"); } fclose(fp); #endif #if 0 FILE *fp = fopen("/Users/zhaot/Data/stitch/set1/GL_100708_R1_GR1_B1_L014.lsm", "r+"); char endian[3]; endian[2] = '\0'; fread(endian, 1, 2, fp); printf("Endian: %s\n", endian); fpos_t pos; fgetpos(fp, &pos); printf("%d\n", pos); fseek(fp, 0, SEEK_SET); uint32_t x = 254; printf("%lu bytes written\n", fwrite(&x, sizeof(uint32_t), 1, fp)); fgetpos(fp, &pos); printf("%d\n", pos); Fprint_File_Binary(fp, 8, stdout); fclose(fp); #endif #if 0 Stack *stack = Read_Lsm_Stack("../data/GL_100208_R1_GR1_B1_L07.lsm", -1); Write_Stack_U("../data/test.lsm", stack, "../data/GL_100208_R1_GR1_B1_L07.lsm"); #endif #if 0 //Stack *stack = Read_Lsm_Stack("/Users/zhaot/Data/neurolineage/lsm/Twin-Spot_Gal4-GH146_nc_11-2.lsm", 0); Stack *stack = Read_Stack_U("../data/test2.tif"); Write_Stack_U("../data/test.tif", stack, NULL); #endif #if 0 Stack *stack = Read_Stack("../data/mouse_single_org/traced.tif"); Write_Stack("../data/test.tif", stack); #endif #if 0 /* test writing large stack */ Mc_Stack *stack = Make_Mc_Stack(GREY, 1024, 1024, 1024, 3); size_t n = (size_t) 1024 * 1024 * 1024 * 3; size_t i; for (i = 0; i < n; i++) { stack->array[i] = i % 255; } Write_Mc_Stack("../data/test.tif", stack, NULL); #endif #if 0 /* test reading large stack */ Mc_Stack *stack = Read_Mc_Stack("../data/test.tif", -1); Print_Mc_Stack_Info(stack); #endif #if 0 /* test writing a raw stack */ Mc_Stack *stack = Read_Mc_Stack("/Users/zhaot/Data/SynapseSpotted2_S124-3_1to59NF1Crop1_enhanced_Sample.tif", -1); //Print_Stack_Info(stack); Write_Mc_Stack("../data/test.raw", stack, NULL); #endif #if 0 /* test reading a raw stack */ /* Stack *stack = Read_Raw_Stack("/Users/zhaot/Data/jinny/slice15_overplaped.raw"); Print_Stack_Info(stack); Write_Stack("../data/test.tif", stack); */ Stack *stack = Read_Sc_Stack("/Users/zhaot/Data/jinny/proofread_slice15_3to11/detectedresults/slice15_3to11_crop01_detected_test.raw", 1); Print_Stack_Info(stack); Write_Stack("../data/test.tif", stack); #endif #if 0 Stack *stack = Read_Sc_Stack("/Users/zhaot/Data/jinny/drawMask/slice15_3to33_4_30_result.raw", 2); stack = Read_Stack_U("/Users/zhaot/Data/jinny/drawMask/slice15_3to33.raw"); #endif #if 0 Stack *stack = Read_Stack_U("/Users/zhaot/Work/neurolabi/data/diadem_d1_095.xml"); Print_Stack_Info(stack); #endif #if 0 Stack *stack = Read_Stack_U("/Users/zhaot/Work/neurolabi/data/diadem_d1_001.xml"); Print_Stack_Info(stack); Mc_Stack *mc_stack = Mc_Stack_Rewrap_Stack(stack); printf("%d\n", Stack_Usage()); printf("%d\n", Mc_Stack_Usage()); Print_Mc_Stack_Info(mc_stack); Write_Mc_Stack("../data/test.tif", mc_stack, NULL); Free_Mc_Stack(mc_stack); mc_stack = Read_Mc_Stack("/Users/zhaot/Work/neurolabi/data/diadem_d1_001.xml", -1); printf("%d\n", Mc_Stack_Usage()); #endif #if 0 int size[3]; Stack_Size_F("../data/benchmark/L3_12bit.lsm", size); iarray_print2(size, 3, 1); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("/Users/zhaot/Data/Julie/All_tiled_nsyb5_Sum.lsm", -1); Print_Mc_Stack_Info(stack); Write_Mc_Stack("../data/test.lsm", stack, "/Users/zhaot/Data/Julie/All_tiled_nsyb5_Sum.lsm"); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/test.lsm", -1); Print_Mc_Stack_Info(stack); #endif #if 0 Mc_Stack *stack = NULL; stack = Read_Mc_Stack("/Users/zhaot/Data/colorsep/16D01.1-14.lsm", 0); Write_Mc_Stack("/Users/zhaot/Data/colorsep/channel1.tif", stack, NULL); stack = Read_Mc_Stack("/Users/zhaot/Data/colorsep/16D01.1-14.lsm", 1); Write_Mc_Stack("/Users/zhaot/Data/colorsep/channel2.tif", stack, NULL); stack = Read_Mc_Stack("/Users/zhaot/Data/colorsep/16D01.1-14.lsm", 2); Write_Mc_Stack("/Users/zhaot/Data/colorsep/channel3.tif", stack, NULL); stack = Read_Mc_Stack("/Users/zhaot/Data/colorsep/16D01.1-14.lsm", 3); Write_Mc_Stack("/Users/zhaot/Data/colorsep/channel4.tif", stack, NULL); /* Write_Mc_Stack("../data/test.lsm", stack, "/Users/zhaot/Data/Julie/All_tiled_nsyb5_Sum.lsm"); */ #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("/Users/zhaot/Data/colorsep/16D01.1-14.lsm", -1); Print_Mc_Stack_Info(stack); Stack grey_stack = Mc_Stack_Channel(stack, 3); grey_stack.text = "\0"; Write_Stack("../data/test.tif", &grey_stack); #endif #if 0 printf("Channel number: %d\n", Lsm_Channel_Number("../data/12bit/70208_2BcPhR_R1_GR1_B1_L003.lsm")); printf("Image type:"); switch (Lsm_Pixel_Type("../data/12bit/70208_2BcPhR_R1_GR1_B1_L003.lsm")) { case GREY8: printf(" uint8\n"); break; case GREY16: printf(" uint16\n"); break; case FLOAT32: printf(" float32\n"); break; default: printf(" unknown\n"); } #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/brainbow/CA3.lsm", 0); Print_Mc_Stack_Info(stack); Write_Mc_Stack("../data/test.tif", stack, NULL); #endif #if 0 Stack *stack = Read_Stack_U("../data/test.xml"); Write_Stack("../data/test.tif", stack); #endif #if 0 int width, height, depth, kind; Tiff_Attribute("../data/stack8.tif", 0, &kind, &width, &height, &depth); printf("%d %d %d %d\n", width, height, depth, kind); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/neuronsep/Lee_Lab/13C01_BLM00090_D2.v3dpdb", 1); Print_Mc_Stack_Info(stack); Write_Mc_Stack("../data/test.tif", stack, NULL); #endif #if 0 //Mc_Stack *stack = Read_Mc_Stack("../data/benchmark/bfork_2d.tif", -1); //Mc_Stack *stack = Read_Mc_Stack("../data/neuronsep/Lee_Lab/13C01_BLM00090_D2.v3dpdb", 0); Mc_Stack *stack = Read_Mc_Stack("../data/neuronsep/stitched-1.v3dpdb", 0); //stack->depth = 1; Stack ch = Mc_Stack_Channel(stack, 0); printf("%g\n", Stack_Sum(&ch)); int *hist = Stack_Hist(&ch); Print_Int_Histogram(hist); Print_Mc_Stack_Info(stack); Write_Mc_Stack("../data/test.tif", stack, NULL); #endif #if 0 Mc_Stack *stack = Read_Mc_Stack("../data/neurosep/aljosha/stitched-1858872924438528098.v3draw", -1); Print_Mc_Stack_Info(stack); #endif #if 1 IMatrix *mat = IMatrix_Read("../data/test/session2/body_map/body_map00161.imat"); printf("%d: %d x %d x %d\n", (int) mat->ndim, mat->dim[0], mat->dim[1], mat->dim[2]); Stack *stack = Make_Stack(GREY, mat->dim[0], mat->dim[1], mat->dim[2]); size_t nvoxel = Stack_Voxel_Number(stack); for (size_t i = 0; i < nvoxel; ++i) { stack->array[i] = (mat->array[i]) >> 24; } Write_Stack("../data/test.tif", stack); #endif return 0; }
Int_Arraylist *Stack_Route(const Stack *stack, int start[], int end[], Stack_Graph_Workspace *sgw) { if (sgw->gw == NULL) { sgw->gw = New_Graph_Workspace(); } if (sgw->range == NULL) { double dist = Geo3d_Dist(start[0], start[1], start[2], end[0], end[1], end[2]); int margin[3]; int i = 0; for (i = 0; i < 3; ++i) { margin[i] = iround(dist - abs(end[i] - start[i] + 1)); if (margin[i] < 0) { margin[i] = 0; } } Stack_Graph_Workspace_Set_Range(sgw, start[0], end[0], start[1], end[1], start[2], end[2]); Stack_Graph_Workspace_Expand_Range(sgw, margin[0], margin[0], margin[1], margin[1], margin[2], margin[2]); Stack_Graph_Workspace_Validate_Range(sgw, stack->width, stack->height, stack->depth); } int swidth = sgw->range[1] - sgw->range[0] + 1; int sheight = sgw->range[3] - sgw->range[2] + 1; int sdepth = sgw->range[5] - sgw->range[4] + 1; int start_index = Stack_Util_Offset(start[0] - sgw->range[0], start[1] - sgw->range[2], start[2] - sgw->range[4], swidth, sheight, sdepth); int end_index = Stack_Util_Offset(end[0] - sgw->range[0], end[1] - sgw->range[2], end[2] - sgw->range[4], swidth, sheight, sdepth); if (start_index > end_index) { int tmp; SWAP2(start_index, end_index, tmp); } ASSERT(start_index >= 0, "Invalid starting index."); ASSERT(end_index >= 0, "Invalid ending index."); tic(); Graph *graph = Stack_Graph_W(stack, sgw); ptoc(); tic(); int *path = NULL; switch (sgw->sp_option) { case 0: path = Graph_Shortest_Path_E(graph, start_index, end_index, sgw->gw); break; case 1: { //printf("%g\n", sgw->intensity[start_index]); sgw->intensity[end_index] = 4012; sgw->intensity[start_index] = 4012; path = Graph_Shortest_Path_Maxmin(graph, start_index, end_index, sgw->intensity, sgw->gw); } break; } sgw->value = sgw->gw->dlist[end_index]; Kill_Graph(graph); if (isinf(sgw->value)) { return NULL; } #ifdef _DEBUG_2 { Graph_Update_Edge_Table(graph, sgw->gw); Stack *stack = Make_Stack(GREY, swidth, sheight, sdepth); Zero_Stack(stack); int nvoxel = (int) Stack_Voxel_Number(stack); int index = end_index; printf("%d -> %d\n", start_index, end_index); while (index >= 0) { if (index < nvoxel) { stack->array[index] = 255; } int x, y, z; Stack_Util_Coord(index, swidth, sheight, &x, &y, &z); printf("%d (%d, %d, %d), %g\n", index, x, y, z, sgw->gw->dlist[index]); index = path[index]; } Write_Stack("../data/test2.tif", stack); Kill_Stack(stack); } #endif Int_Arraylist *offset_path = Parse_Stack_Shortest_Path(path, start_index, end_index, stack->width, stack->height, sgw); int org_start = Stack_Util_Offset(start[0], start[1], start[2], stack->width, stack->height, stack->depth); if (org_start != offset_path->array[0]) { iarray_reverse(offset_path->array, offset_path->length); } int org_end = Stack_Util_Offset(end[0], end[1], end[2], stack->width, stack->height, stack->depth); //printf("%d, %d\n", org_end, offset_path->array[offset_path->length -]); ASSERT(org_start == offset_path->array[0], "Wrong path head."); if (org_end != offset_path->array[offset_path->length - 1]) { printf("debug here\n"); } ASSERT(org_end == offset_path->array[offset_path->length - 1], "Wrong path tail."); ptoc(); return offset_path; }
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() { /* Read stack */ Stack *stack = Read_Stack("../data/fly_neuron.tif"); double z_scale = 1.0; /* New a bifold segment */ Local_Bifold_Neuroseg *locbn = New_Local_Bifold_Neuroseg(); /* Set_Local_Bifold_Neuroseg(locbn, 2, 2, 2, 2, 30, 0.5, TZ_PI_2, TZ_PI_2, -TZ_PI_2, 0, 461, 296, 144); //fly_neuron.tif */ Set_Local_Bifold_Neuroseg(locbn, 2, 2, 2, 2, 40, 0.5, TZ_PI_2, TZ_PI_2, TZ_PI_2, TZ_PI_2, 290, 304, 112); //fly_neuron.tif /* Set_Local_Bifold_Neuroseg(locbn, 2, 2, 2, 2, 30, 0.5, TZ_PI_2, TZ_PI_2, -TZ_PI_2, 0, 320, 164, 148); //fly_neuron.tif */ /* Set_Local_Bifold_Neuroseg(locbn, 3, 3, 3, 3, 30, 0.5, TZ_PI_2, TZ_PI_2, -TZ_PI_2, 0, 262, 136, 141); //fly_neuron2.tif */ /* Set_Local_Bifold_Neuroseg(locbn, 3, 3, 3, 3, 30, 0.5, TZ_PI_2, TZ_PI_2, -TZ_PI_2, 0, 236, 396, 143); //fly_neuron2.tif */ /* fit */ int var_index[LOCAL_BIFOLD_NEUROSEG_NPARAM]; int nvar = Local_Bifold_Neuroseg_Var_Mask_To_Index (BIFOLD_NEUROSEG_VAR_MASK_R | BIFOLD_NEUROSEG_VAR_MASK_KNOT | BIFOLD_NEUROSEG_VAR_MASK_ORIENTATION2 | BIFOLD_NEUROSEG_VAR_MASK_ORIENTATION, NEUROPOS_VAR_MASK_NONE, var_index); Fit_Local_Bifold_Neuroseg(locbn, stack, var_index, nvar, z_scale, NULL); Print_Local_Bifold_Neuroseg(locbn); /* Generate field */ Geo3d_Scalar_Field *field = Local_Bifold_Neuroseg_Field(locbn, 1.0, NULL); Delete_Local_Bifold_Neuroseg(locbn); /* Draw it in a stack */ Stack *label = Make_Stack(FLOAT32, stack->width, stack->height, stack->depth); Zero_Stack(label); double coef[] = {0.1, 255.0}; double range[] = {0.0, 10000.0}; Geo3d_Scalar_Field_Draw_Stack(field, label, coef, range); /* Turn the stack to GREY type */ Translate_Stack(label, GREY, 1); /* Make canvas */ Translate_Stack(stack, COLOR, 1); /* Label the canvas */ Stack_Label_Color(stack, label, 5.0, 1.0, label); /* Save the stack */ Write_Stack("../data/test.tif", stack); /* clean up */ Kill_Geo3d_Scalar_Field(field); Kill_Stack(stack); Kill_Stack(label); return 0; }
int main(int argc, char *argv[]) { static char *Spec[] = {"<input:string> -o <string>", "[-count <int>] [-dist <int>] [-minobj <int>]", NULL}; Process_Arguments(argc, argv, Spec, 1); Stack *input = Read_Stack(Get_String_Arg("input")); int nregion = Stack_Max(input, NULL); int nvoxel = Stack_Voxel_Number(input); int i; Stack *stack = Make_Stack(GREY, Stack_Width(input), Stack_Height(input), Stack_Depth(input)); Stack *out = Make_Stack(GREY, Stack_Width(input), Stack_Height(input), Stack_Depth(input)); Zero_Stack(out); int nobj = 0; for (i = 1; i <= nregion; i++) { int j; int count = 0; for (j = 0; j < nvoxel; j++) { stack->array[j] = (input->array[j] == i); } Stack *out3 = NULL; int maxcount = 100000; if (Is_Arg_Matched("-count")) { maxcount = Get_Int_Arg("-count"); } if (count > maxcount) { out3 = Copy_Stack(stack); Stack_Addc_M(out3, nobj); nobj++; } else { Stack *distmap = Stack_Bwdist_L_U16P(stack, NULL, 0); Stack_Watershed_Workspace *ws = Make_Stack_Watershed_Workspace(stack); ws->mask = Copy_Stack(distmap); int mindist = 10; if (Is_Arg_Matched("-dist")) { mindist = Get_Int_Arg("-dist"); } Stack_Threshold_Binarize(ws->mask, mindist); Translate_Stack(ws->mask, GREY, 1); int minobj = 100; if (Is_Arg_Matched("-minobj")) { minobj = Get_Int_Arg("-minobj"); } Object_3d_List *objs = Stack_Find_Object(ws->mask, 1, minobj); Zero_Stack(ws->mask); Stack_Draw_Objects_Bw(ws->mask, objs, -255); ws->min_level = 1; ws->start_level = 65535; out3 = Stack_Watershed(distmap, ws); Stack_Addc_M(out3, nobj); nobj += Object_3d_List_Length(objs); Kill_Stack(distmap); Kill_Stack_Watershed_Workspace(ws); Kill_Object_3d_List(objs); } Stack_Add(out, out3, out); Kill_Stack(out3); } printf("number of regions: %d\n", nobj); Write_Stack(Get_String_Arg("-o"), out); char cmd[500]; sprintf(cmd, "touch %s_done", Get_String_Arg("-o")); system(cmd); return 0; }
int main(int argc, char* argv[]) { #if 0 Stack *stack = Read_Stack("../data/binimg.tif"); Set_Matlab_Path("/Applications/MATLAB74/bin/matlab"); Stack *dist = Stack_Bwdist(stack); Stack* seeds = Stack_Local_Max(dist, NULL, STACK_LOCMAX_ALTER1); Stack *out = Scale_Double_Stack((double *) dist->array, stack->width, stack->height, stack->depth, GREY); Translate_Stack(out, COLOR, 1); Rgb_Color color; Set_Color(&color, 255, 0, 0); Stack_Label_Bwc(out, seeds, color); Print_Stack_Info(dist); Write_Stack("../data/test.tif", out); #endif #if 0 Stack *stack = Read_Stack("../data/benchmark/sphere_bw.tif"); //Stack *stack = Read_Stack("../data/sphere_data.tif"); //Stack_Not(stack, stack); int i; /* uint8 *array = stack->array + 512 * 600; for (i = 1; i < 512; i++) { array[i] = 1; } */ //stack->depth = 50; /* long int *label = (long int *) malloc(sizeof(long int) * Stack_Voxel_Number(stack)); */ tic(); Stack *out = Stack_Bwdist_L_U16(stack, NULL, 0); uint16 *out_array = (uint16 *) out->array; printf("%llu\n", toc()); //int *hist = Stack_Hist(out); //Print_Int_Histogram(hist); Stack *out2 = Stack_Bwdist_L(stack, NULL, NULL); float *out2_array = (float *) out2->array; int n = Stack_Voxel_Number(out); int t = 0; int x, y, z; for (i = 0; i < n; i++) { uint16 d2 = (uint16) out2_array[i]; if (out_array[i] != d2){ int area = stack->width * stack->height; STACK_UTIL_COORD(i, stack->width, area, x, y, z); printf("(%d %d %d)", x, y, z); printf("%d %d %d\n", out_array[i], d2, stack->array[i]); t++; } } printf("%d error\n", t); # if 0 //Translate_Stack(out, GREY, 1); float *out_array = (float *) out->array; int i; int n = Stack_Voxel_Number(out); /* for (i = 0; i < n; i++) { out_array[i] = sqrt(out_array[i]); } Stack *out2 = Scale_Float_Stack((float *)out->array, out->width, out->height, out->depth, GREY); */ Stack *out2 = Make_Stack(GREY, out->width, out->height, out->depth); for (i = 0; i < n; i++) { out2->array[i] = (uint8) round(sqrt(out_array[i])); } Write_Stack("../data/test.tif", out2); # endif Write_Stack("../data/test.tif", out); Kill_Stack(out); Kill_Stack(out2); #endif #if 1 Stack *stack = Read_Stack("../data/system/29.tif"); Print_Stack_Info(stack); tic(); Stack *out = Stack_Bwdist_L_U16P(stack, NULL, 0); ptoc(); Stack *golden = Read_Stack("../data/system/29_dist2.tif"); printf("Checking result ...\n"); if (Stack_Identical(out, golden) == FALSE) { printf("Result unmatched.\n"); } else { printf("Good.\n"); } #endif 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; }
Stack* Stack_Boundary_Code(Stack *stack, Stack *code, Objlabel_Workspace *ow) { STACK_OBJLABEL_OPEN_WORKSPACE(stack, ow); int nvoxel = Stack_Voxel_Number(stack); int i; if (ow->init_chord == TRUE) { for (i = 0; i < nvoxel; i++) { ow->chord->array[i] = -1; } } if (code == NULL) { code = Make_Stack(GREY16, stack->width, stack->height, stack->depth); } Zero_Stack(code); int neighbor[26]; int is_in_bound[26]; int nbound; BOOL is_boundary = FALSE; Stack_Neighbor_Offset(ow->conn, stack->width, stack->height, neighbor); int prev_seed = -1; int offset = 0; int x, y, z; cwidth = stack->width - 1; cheight = stack->height - 1; cdepth = stack->depth - 1; uint16 *code_array = (uint16 *) code->array; for (z = 0; z < stack->depth; z++) { for (y = 0; y < stack->height; y++) { for (x = 0; x < stack->width; x++) { is_boundary = FALSE; if (stack->array[offset] == 1) { nbound = Stack_Neighbor_Bound_Test(ow->conn, cwidth, cheight, cdepth, x, y, z, is_in_bound); if (nbound < ow->conn) { is_boundary = TRUE; } else { for (i = 0; i < ow->conn; i++) { if (stack->array[offset + neighbor[i]] == 0) { is_boundary = TRUE; break; } } } } if (is_boundary == TRUE) { code_array[offset] = 1; ow->chord->array[offset] = prev_seed; prev_seed = offset; } offset++; } } } int entrance = prev_seed; int area = stack->width * stack->height; int c; int prev; int nb; int *link = ow->chord->array; /* generate level field */ while (entrance > 0) { c = entrance; prev = -1; do { if (code_array[c] == 1) { Stack_Util_Coord_A(c, stack->width, area, &x, &y, &z); nbound = Stack_Neighbor_Bound_Test(ow->conn, cwidth, cheight, cdepth, x, y, z, is_in_bound); if (nbound < ow->conn) { for (i = 0; i < ow->conn; i++) { if (is_in_bound[i]) { nb = c + neighbor[i]; if (stack->array[nb] && !code_array[nb]) { code_array[nb] = 2; link[nb] = prev; prev = nb; } } } } else { for (i = 0; i < nbound; i++) { nb = c + neighbor[i]; if (stack->array[nb] && !code_array[nb]) { code_array[nb] = 2; link[nb] = prev; prev = nb; } } } } else { for (i = 0; i < ow->conn; i++) { nb = c + neighbor[i]; if (stack->array[nb] && !code_array[nb]) { code_array[nb] = code_array[c] + 1; link[nb] = prev; prev = nb; } } } c = link[c]; } while (c >= 0); entrance = prev; } STACK_OBJLABEL_CLOSE_WORKSPACE(ow); return code; }
/* * 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; }