// Normalize an exception. NUITKA_MAY_BE_UNUSED static inline void NORMALIZE_EXCEPTION( PyObject **exception_type, PyObject **exception_value, PyTracebackObject **exception_tb ) { #if _DEBUG_EXCEPTIONS PRINT_STRING("NORMALIZE_EXCEPTION:\n"); PRINT_EXCEPTION( *exception_type, *exception_value, (PyObject *)*exception_tb ); #endif if ( *exception_type != Py_None && *exception_type != NULL ) { PyErr_NormalizeException( exception_type, exception_value, (PyObject **)exception_tb ); } #if _DEBUG_EXCEPTIONS PRINT_STRING("normalized:\n"); PRINT_EXCEPTION( *exception_type, *exception_value, (PyObject *)*exception_tb ); #endif }
// Fetch the current error into object variables. NUITKA_MAY_BE_UNUSED static void FETCH_ERROR_OCCURRED( PyObject **exception_type, PyObject **exception_value, PyTracebackObject **exception_traceback) { PyThreadState *tstate = PyThreadState_GET(); *exception_type = tstate->curexc_type; *exception_value = tstate->curexc_value; *exception_traceback = (PyTracebackObject *)tstate->curexc_traceback; #if _DEBUG_EXCEPTIONS PRINT_STRING("FETCH_ERROR_OCCURRED:\n"); PRINT_EXCEPTION( tstate->curexc_type, tstate->curexc_value, tstate->curexc_traceback ); #endif tstate->curexc_type = NULL; tstate->curexc_value = NULL; tstate->curexc_traceback = NULL; }
// Preserve the current exception as the frame to restore. NUITKA_MAY_BE_UNUSED static inline void PRESERVE_FRAME_EXCEPTION( PyFrameObject *frame_object ) { // Setting exception for frame if not already done. if ( frame_object->f_exc_type == NULL ) { PyThreadState *thread_state = PyThreadState_GET(); if ( thread_state->exc_type != NULL && thread_state->exc_type != Py_None ) { #if _DEBUG_EXCEPTIONS PRINT_STRING("PRESERVE_FRAME_EXCEPTION: preserve thread exception\n"); #endif frame_object->f_exc_type = thread_state->exc_type; Py_INCREF( frame_object->f_exc_type ); frame_object->f_exc_value = thread_state->exc_value; Py_XINCREF( frame_object->f_exc_value ); frame_object->f_exc_traceback = thread_state->exc_traceback; Py_XINCREF( frame_object->f_exc_traceback ); } else { #if _DEBUG_EXCEPTIONS PRINT_STRING("PRESERVE_FRAME_EXCEPTION: no exception to preserve\n"); #endif frame_object->f_exc_type = Py_None; Py_INCREF( frame_object->f_exc_type ); frame_object->f_exc_value = NULL; frame_object->f_exc_traceback = NULL; } } #if _DEBUG_EXCEPTIONS else { PRINT_STRING("PRESERVE_FRAME_EXCEPTION: already preserving\n"); } PRINT_ITEM( (PyObject *)frame_object ); PRINT_NEW_LINE(); PRINT_EXCEPTION( frame_object->f_exc_type, frame_object->f_exc_value, frame_object->f_exc_traceback ); #endif }
NUITKA_MAY_BE_UNUSED static void RESTORE_ERROR_OCCURRED( PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_traceback ) { PyThreadState *tstate = PyThreadState_GET(); PyObject *old_exception_type = tstate->curexc_type; PyObject *old_exception_value = tstate->curexc_value; PyObject *old_exception_traceback = tstate->curexc_traceback; tstate->curexc_type = exception_type; tstate->curexc_value = exception_value; tstate->curexc_traceback = (PyObject *)exception_traceback; #if _DEBUG_EXCEPTIONS PRINT_STRING("RESTORE_ERROR_OCCURRED:\n"); PRINT_EXCEPTION( tstate->curexc_type, tstate->curexc_value, tstate->curexc_traceback ); #endif Py_XDECREF( old_exception_type ); Py_XDECREF( old_exception_value ); Py_XDECREF( old_exception_traceback ); }
void Stack_Draw_Point(Stack *stack, double x, double y, double z, double v, int mode) { if (stack == NULL) { TZ_ERROR(ERROR_POINTER_NULL); } if (Stack_Channel_Number(stack) != 1) { TZ_ERROR(ERROR_DATA_TYPE); } int is_finite = TRUE; double value; DEFINE_SCALAR_ARRAY_ALL(array, stack); int nvoxel = Stack_Voxel_Number(stack); switch(stack->kind) { case GREY: STACK_DRAW_POINT(array_grey, uint8, 0, 255, mode); break; case GREY16: STACK_DRAW_POINT(array_grey16, uint16, 0, 65535, mode); break; case FLOAT32: is_finite = FALSE; STACK_DRAW_POINT(array_float32, float32, 0, 0, mode); break; case FLOAT64: is_finite = FALSE; STACK_DRAW_POINT(array_float64, float64, 0, 0, mode); break; default: PRINT_EXCEPTION("Unsupported image kind", "Nothing is drawn."); break; } }
// Helper that sets the current thread exception, releasing the current one, for // use in this file only. NUITKA_MAY_BE_UNUSED inline void SET_CURRENT_EXCEPTION( PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb ) { PyThreadState *thread_state = PyThreadState_GET(); PyObject *old_type = thread_state->exc_type; PyObject *old_value = thread_state->exc_value; PyObject *old_tb = thread_state->exc_traceback; thread_state->exc_type = exception_type; thread_state->exc_value = exception_value; thread_state->exc_traceback = (PyObject *)exception_tb; #if _DEBUG_EXCEPTIONS PRINT_STRING("SET_CURRENT_EXCEPTION:\n"); PRINT_EXCEPTION( exception_type, exception_value, (PyObject *)exception_tb ); #endif Py_XDECREF( old_type ); Py_XDECREF( old_value ); Py_XDECREF( old_tb ); #if PYTHON_VERSION < 300 // Set sys attributes in the fastest possible way. PyObject *sys_dict = thread_state->interp->sysdict; CHECK_OBJECT( sys_dict ); PyDict_SetItem( sys_dict, const_str_plain_exc_type, exception_type ? exception_type : Py_None ); PyDict_SetItem( sys_dict, const_str_plain_exc_value, exception_value ? exception_value : Py_None ); PyDict_SetItem( sys_dict, const_str_plain_exc_traceback, exception_tb ? (PyObject *)exception_tb : Py_None ); if ( exception_type ) assert( Py_REFCNT( exception_type ) >= 2 ); if ( exception_value ) assert( Py_REFCNT( exception_value ) >= 2 ); if ( exception_tb ) assert( Py_REFCNT( exception_tb ) >= 2 ); #endif }
int main(int argc, char *argv[]) { if (Show_Version(argc, argv, "1.0") == 1) { return 0; } static char *Spec[] = { "[-R<string> -T<string> -M<string>] -D<string> [-minlen <double>]", "[-root <double> <double> <double>] [-trans <double> <double> <double>]", "[-rtlist <string>] [-sup_root] [-dist <double>]", "[-C<string>] [-I<string>] [-z <double>] -o <string> [-b] [-res <string>]", "[-screen] [-sp] [-intp] [-sl] [-rb] [-rz] [-rs] [-ct] [-al <double>]", "[-screenz <double>] [-force_merge <double>] [-ct_break <double>]", "[-jumpz <double>] [-single_break]", NULL}; Print_Arguments(argc, argv); Process_Arguments(argc, argv, Spec, 1); char *dir = Get_String_Arg("-D"); Stack_Document *stack_doc = NULL; if (Is_Arg_Matched("-I")) { if (!fexist(Get_String_Arg("-I"))) { PRINT_EXCEPTION("File does not exist", ""); fprintf(stderr, "%s cannot be found.\n", Get_String_Arg("-I")); return 1; } if (fhasext(Get_String_Arg("-I"), "xml")) { stack_doc = Xml_Read_Stack_Document(Get_String_Arg("-I")); } } /* Get number of chains */ int chain_number2 = dir_fnum_p(dir, "^chain.*\\.tb"); if (chain_number2 == 0) { printf("No tube found.\n"); printf("Quit reconstruction.\n"); return 1; } int i; int *chain_map = iarray_malloc(chain_number2); int chain_number; Locseg_Chain **chain_array = Dir_Locseg_Chain_Nd(dir, "chain.*\\.tb", &chain_number, chain_map); if (Is_Arg_Matched("-screenz")) { Locseg_Chain_Array_Screen_Z(chain_array, chain_number, Get_Double_Arg("-screenz")); } if (Is_Arg_Matched("-single_break")) { int i; for (i = 0; i < chain_number; i++) { if (Locseg_Chain_Length(chain_array[i]) == 1) { /* break the segment into two parts */ Locseg_Chain_Break_Node(chain_array[i], 0, 0.5); } } } if (Is_Arg_Matched("-ct_break")) { int tmp_chain_number; Locseg_Chain **tmp_chain_array = Locseg_Chain_Array_Break_Jump(chain_array, chain_number, Get_Double_Arg("-ct_break"), &tmp_chain_number); kill_locseg_chain_array(chain_array, chain_number); chain_array = tmp_chain_array; chain_number = tmp_chain_number; } Connection_Test_Workspace *ctw = New_Connection_Test_Workspace(); if (Is_Arg_Matched("-res")) { FILE *fp = fopen(Get_String_Arg("-res"), "r"); if (fp != NULL) { if (darray_fscanf(fp, ctw->resolution, 3) != 3) { fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res")); ctw->resolution[0] = 1.0; ctw->resolution[1] = 1.0; ctw->resolution[2] = 1.0; } else { ctw->unit = 'u'; } fclose(fp); } else { fprintf(stderr, "Failed to load %s. The file may not exist.\n", Get_String_Arg("-res")); } } else if (stack_doc != NULL) { ctw->resolution[0] = stack_doc->resolution[0]; ctw->resolution[1] = stack_doc->resolution[1]; ctw->resolution[2] = stack_doc->resolution[2]; } if (Is_Arg_Matched("-force_merge")) { Connection_Test_Workspace *ws = New_Connection_Test_Workspace(); ws->dist_thre = Get_Double_Arg("-force_merge"); ws->interpolate = FALSE; ws->resolution[2] = ctw->resolution[2] / ctw->resolution[0]; for (i = 0; i < chain_number; i++) { //Locseg_Chain_Correct_Ends(chain_array[i]); } Locseg_Chain_Array_Force_Merge(chain_array, chain_number, ws); Kill_Connection_Test_Workspace(ws); } chain_number2 = 0; Neuron_Component *chain_array2; GUARDED_MALLOC_ARRAY(chain_array2, chain_number, Neuron_Component); for (i = 0; i < chain_number; i++) { if (Locseg_Chain_Is_Empty(chain_array[i]) == FALSE) { chain_map[chain_number2] = chain_map[i]; Set_Neuron_Component(chain_array2+(chain_number2++), NEUROCOMP_TYPE_LOCSEG_CHAIN, chain_array[i]); } else { printf("chain_%d is empty.\n", chain_map[i]); } } /* Dir_Locseg_Chain_Nc(dir, "^chain.*\\.tb", &chain_number2, chain_map); */ Stack *signal = NULL; //Stack *canvas = NULL; if (Is_Arg_Matched("-I")) { signal = Read_Stack_U(Get_String_Arg("-I")); //canvas = Translate_Stack(signal, COLOR, 0); } else { if (Is_Arg_Matched("-screen")) { perror("The -screen option requires -I option to be supplied.\n"); return 1; } } /* Minimal tube length. */ double minlen = 25.0; if (Is_Arg_Matched("-minlen")) { minlen = Get_Double_Arg("-minlen"); } chain_number = 0; //int i; if (signal != NULL) { ctw->mask = Make_Stack(GREY, signal->width, signal->height, signal->depth); One_Stack(ctw->mask); } FILE *result_file = fopen(full_path(dir, Get_String_Arg("-o")), "w"); double z_scale = 1.0; if (Is_Arg_Matched("-z")) { z_scale = Get_Double_Arg("-z"); } /* Array to store corrected chains */ Neuron_Component *chain_array_c = Make_Neuron_Component_Array(chain_number2); int screen = 0; double average_intensity = 0.0; if (Is_Arg_Matched("-screen")) { int good_chain_number = 0; int bad_chain_number = 0; for (i = 0; i < chain_number2; i++) { Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i); average_intensity += Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL); if ((Locseg_Chain_Geolen(chain) > 55) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.6)) { good_chain_number++; } else { bad_chain_number++; } } printf("good %d bad %d\n", good_chain_number, bad_chain_number); if (good_chain_number + bad_chain_number > 50) { if (bad_chain_number > good_chain_number) { screen = 1; } } else { screen = 3; /* if (bad_chain_number > good_chain_number * 2) { screen = 2; } */ } } average_intensity /= chain_number2; /* build chain map */ for (i = 0; i < chain_number2; i++) { Locseg_Chain *chain = NEUROCOMP_LOCSEG_CHAIN(chain_array2 + i); BOOL good = FALSE; switch (screen) { case 1: case 2: if ((Locseg_Chain_Geolen(chain) > 100) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.6)) { good = TRUE; } else { if (Locseg_Chain_Geolen(chain) < 100) { if ((Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.5) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL) > average_intensity)) { good = TRUE; } } } break; case 3: if ((Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_CORRCOEF) > 0.50) || (Locseg_Chain_Average_Score(chain, signal, z_scale, STACK_FIT_MEAN_SIGNAL) > average_intensity)) { good = TRUE; } break; default: good = TRUE; } if (good == TRUE) { if (Locseg_Chain_Geolen(chain) < minlen) { good = FALSE; } } if (good == TRUE) { Locseg_Chain *tmpchain = chain; if (signal != NULL) { //Locseg_Chain_Trace_Np(signal, 1.0, tmpchain, tw); Locseg_Chain_Erase(chain, ctw->mask, 1.0); } fprintf(result_file, "%d %d\n", chain_number, chain_map[i]); chain_map[chain_number] = chain_map[i]; if (z_scale != 1.0) { Locseg_Chain_Scale_Z(chain, z_scale); } Set_Neuron_Component(chain_array_c + chain_number, NEUROCOMP_TYPE_LOCSEG_CHAIN, tmpchain); chain_number++; } else { #ifdef _DEBUG_ printf("chain%d is excluded.\n", i); /* char tmpfile[500]; sprintf(tmpfile, "../data/diadem_c1/bad_chain/chain%d.tb", i); Write_Locseg_Chain(tmpfile, chain); */ #endif } } z_scale = 1.0; fprintf(result_file, "#\n"); //Int_Arraylist *hit_spots = Int_Arraylist_New(0, chain_number); /* reconstruct neuron */ if (Is_Arg_Matched("-res")) { FILE *fp = fopen(Get_String_Arg("-res"), "r"); if (fp != NULL) { if (darray_fscanf(fp, ctw->resolution, 3) != 3) { fprintf(stderr, "Failed to load %s\n", Get_String_Arg("-res")); ctw->resolution[0] = 1.0; ctw->resolution[1] = 1.0; ctw->resolution[2] = 1.0; } else { ctw->unit = 'u'; } fclose(fp); } else { fprintf(stderr, "Failed to load %s. The file may not exist.\n", Get_String_Arg("-res")); } } else if (stack_doc != NULL) { ctw->resolution[0] = stack_doc->resolution[0]; ctw->resolution[1] = stack_doc->resolution[1]; ctw->resolution[2] = stack_doc->resolution[2]; } if (!Is_Arg_Matched("-sp")) { ctw->sp_test = FALSE; if (ctw->sp_test == FALSE) { ctw->dist_thre = NEUROSEG_DEFAULT_H / 2.0; } } else { ctw->dist_thre = NEUROSEG_DEFAULT_H * 1.5; } if (Is_Arg_Matched("-dist")) { ctw->dist_thre = Get_Double_Arg("-dist"); } if (!Is_Arg_Matched("-intp")) { ctw->interpolate = FALSE; } //ctw->dist_thre = 100.0; double *tube_offset = NULL; if (Is_Arg_Matched("-trans")) { tube_offset = darray_malloc(3); tube_offset[0] = Get_Double_Arg("-trans", 1); tube_offset[1] = Get_Double_Arg("-trans", 2); tube_offset[2] = Get_Double_Arg("-trans", 3); } else { if (stack_doc != NULL) { tube_offset = darray_malloc(3); tube_offset[0] = stack_doc->offset[0]; tube_offset[1] = stack_doc->offset[1]; tube_offset[2] = stack_doc->offset[2]; } } Neuron_Structure *ns = New_Neuron_Structure(); ns->comp = chain_array_c; ns->graph = New_Graph(); ns->graph->nvertex = chain_number; if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { if (Is_Arg_Matched("-trans")) { roots[i][0] = d[i*3] - tube_offset[0]; roots[i][1] = d[i*3 + 1] - tube_offset[1]; roots[i][2] = d[i*3 + 2] - tube_offset[2]; } else { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; } } Neuron_Structure_Break_Root(ns, roots, n); Neuron_Structure_Load_Root(ns, roots, n); } } Locseg_Chain_Comp_Neurostruct_W(ns, signal, z_scale, ctw); if (tube_offset != NULL) { for (i = 0; i < chain_number; i++) { Locseg_Chain_Translate(NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i), tube_offset); } } /* Neuron_Structure *ns = Locseg_Chain_Comp_Neurostruct(chain_array, chain_number, signal, z_scale, ctw); */ FILE *tube_fp = fopen(full_path(dir, "tube.swc"), "w"); int start_id = 1; for (i = 0; i < chain_number; i++) { int node_type = i % 10; int n = Locseg_Chain_Swc_Fprint_T(tube_fp, NEUROCOMP_LOCSEG_CHAIN(chain_array_c + i), node_type, start_id, -1, DL_FORWARD, 1.0, NULL); start_id += n; } fclose(tube_fp); //Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc")); /* Graph *testgraph = New_Graph(0, 0, FALSE); Int_Arraylist *cidx = Make_Int_Arraylist(0, 2); Int_Arraylist *sidx = Make_Int_Arraylist(0, 2); Locseg_Chain_Network_Simlify(&net, testgraph, cidx, sidx); */ /* Find branch points */ //Locseg_Chain *branches = Locseg_Chain_Network_Find_Branch(ns); //Graph *graph = Locseg_Chain_Graph(chain_array, chain_number, hit_spots); //Graph *graph = ns->graph; if (Is_Arg_Matched("-sup_root")) { if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; /* if (tube_offset != NULL) { roots[i][0] += tube_offset[0]; roots[i][1] += tube_offset[1]; roots[i][2] += tube_offset[2]; } */ } neuron_structure_suppress(ns, roots, n); free(roots); } } } Process_Neuron_Structure(ns); Print_Neuron_Structure(ns); #ifdef _DEBUG_ for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) { printf("chain_%d (%d) -- chain_%d (%d) ", chain_map[ns->graph->edges[i][0]], ns->graph->edges[i][0], chain_map[ns->graph->edges[i][1]], ns->graph->edges[i][1]); Print_Neurocomp_Conn(ns->conn + i); } #endif if (Is_Arg_Matched("-ct")) { Neuron_Structure_Crossover_Test(ns, ctw->resolution[0] / ctw->resolution[2]); } if (Is_Arg_Matched("-al")) { Neuron_Structure_Adjust_Link(ns, Get_Double_Arg("-al")); } Neuron_Structure_To_Tree(ns); Neuron_Structure_Remove_Negative_Conn(ns); #ifdef _DEBUG_ printf("\nTree:\n"); for (i = 0; i < NEURON_STRUCTURE_LINK_NUMBER(ns); i++) { printf("chain_%d (%d) -- chain_%d (%d) ", chain_map[ns->graph->edges[i][0]], ns->graph->edges[i][0], chain_map[ns->graph->edges[i][1]], ns->graph->edges[i][1]); Print_Neurocomp_Conn(ns->conn + i); } #endif /* printf("\ncross over changed: \n"); Print_Neuron_Structure(ns); */ #ifdef _DEBUG_2 ns->graph->nedge = 0; Neuron_Structure_To_Swc_File(ns, "../data/test.swc"); return 1; #endif //Print_Neuron_Structure(ns); Neuron_Structure* ns2= NULL; if (Is_Arg_Matched("-intp")) { ns2 = Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); } else { ns2 = Neuron_Structure_Locseg_Chain_To_Circle(ns); } /* Neuron_Structure* ns2= Neuron_Structure_Locseg_Chain_To_Circle_S(ns, 1.0, 1.0); */ Graph_To_Dot_File(ns2->graph, full_path(dir, "graph_d.dot")); //Neuron_Structure_Main_Graph(ns2); Neuron_Structure_To_Tree(ns2); double root[3]; if (Is_Arg_Matched("-root")) { root[0] = Get_Double_Arg("-root", 1); root[1] = Get_Double_Arg("-root", 2); root[2] = Get_Double_Arg("-root", 3); } Swc_Tree *tree = NULL; if (Is_Arg_Matched("-root")) { /* int root_index = Neuron_Structure_Find_Root_Circle(ns2, root); Graph_Workspace *gw2 = New_Graph_Workspace(); Graph_Clean_Root(ns2->graph, root_index, gw2); Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"), z_scale, root); */ tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, root); if (Swc_Tree_Node_Is_Virtual(tree->root) == TRUE) { tree->root->first_child->next_sibling = NULL; } Swc_Tree_Clean_Root(tree); } else { /* Neuron_Structure_To_Swc_File_Circle_Z(ns2, full_path(dir, "graph_d.swc"), z_scale, NULL); */ tree = Neuron_Structure_To_Swc_Tree_Circle_Z(ns2, z_scale, NULL); } ns->graph->nedge = 0; //Neuron_Structure_To_Swc_File(ns, full_path(dir, "tube.swc")); if (Is_Arg_Matched("-rb")) { //Swc_Tree_Tune_Branch(tree); Swc_Tree_Tune_Fork(tree); } if (Is_Arg_Matched("-sl")) { Swc_Tree_Leaf_Shrink(tree); } if (Is_Arg_Matched("-rz")) { Swc_Tree_Remove_Zigzag(tree); } if (Is_Arg_Matched("-rs")) { Swc_Tree_Remove_Spur(tree); } Swc_Tree_Resort_Id(tree); Write_Swc_Tree(full_path(dir, "graph_d.swc"), tree); if (Is_Arg_Matched("-rtlist")) { int m, n; double *d = darray_load_matrix(Get_String_Arg("-rtlist"), NULL, &m, &n); if (n > 0) { coordinate_3d_t *roots = GUARDED_MALLOC_ARRAY(roots, n, coordinate_3d_t); int i; for (i = 0; i < n; i++) { roots[i][0] = d[i*3]; roots[i][1] = d[i*3 + 1]; roots[i][2] = d[i*3 + 2]; /* if (tube_offset != NULL) { roots[i][0] += tube_offset[0]; roots[i][1] += tube_offset[1]; roots[i][2] += tube_offset[2]; } */ Swc_Tree *subtree = Swc_Tree_Pull_R(tree, roots[i]); char filename[MAX_PATH_LENGTH]; if (subtree->root != NULL) { //Swc_Tree_Clean_Root(subtree); Swc_Tree_Clean_Root(subtree); Swc_Tree_Node_Set_Pos(subtree->root, roots[i]); if (Is_Arg_Matched("-jumpz")) { //swc_tree_remove_zjump(subtree, Get_Double_Arg("-jumpz")); } Swc_Tree_Resort_Id(subtree); sprintf(filename, "graph%d.swc", i + 1); Write_Swc_Tree(full_path(dir, filename), subtree); } } } } printf("%d chains\n", chain_number); return 0; }
int main(int argc, char *argv[]) { 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; }
void Stack_Build_Seed_Graph(Stack *stack, int *seed, int nseed, uint8_t **connmat, Objlabel_Workspace *ow) { if (stack->kind != GREY16) { PRINT_EXCEPTION("Unsupported stack kind", "The stack must be GREY16"); return; } STACK_OBJLABEL_OPEN_WORKSPACE(stack, ow); int i, j, k; int nvoxel = Stack_Voxel_Number(stack); if (ow->init_chord == TRUE) { for (i = 0; i < nvoxel; i++) { ow->chord->array[i] = -1; } } uint16 *mask = (uint16 *) stack->array; const int conn = 26; /* each seed has a queue */ int *queue_head = iarray_malloc(nseed); /* queue_head malloced */ int *queue_tail = iarray_malloc(nseed); /* queue_head malloced */ int *queue_length = iarray_malloc(nseed); /* queue_length malloced */ /* At the beginning, each queue has one element, the corresponding seed */ iarraycpy(queue_head, seed, 0, nseed); iarraycpy(queue_tail, seed, 0, nseed); for (i = 0; i < nseed; i++) { queue_length[i] = 1; } int neighbor[26]; int bound[26]; int nbound; int cwidth = stack->width - 1; int cheight = stack->height - 1; int cdepth = stack->depth - 1; BOOL stop = FALSE; int x, y, z; Stack_Neighbor_Offset(conn, stack->width, stack->height, neighbor); #define STACK_SEED_GRAPH_UPDATE_QUEUE(test) \ for (k = 0; k < conn; k++) { \ if (test) { \ int checking_voxel = queue_head[i] + neighbor[k]; \ if ((mask[checking_voxel] > 0) && (mask[checking_voxel] != label)) { \ if (mask[checking_voxel] == 1) { \ ow->chord->array[queue_tail[i]] = checking_voxel; \ queue_tail[i] = checking_voxel; \ mask[checking_voxel] = label; \ queue_length[i]++; \ } else { \ if (mask[checking_voxel] > label) { \ connmat[i][mask[checking_voxel] - 2] = 1; \ } else { \ connmat[mask[checking_voxel] - 2][i] = 1; \ } \ } \ } \ } \ } while (stop == FALSE) { stop = TRUE; for (i = 0; i < nseed; i++) { if (queue_length[i] > 0) { int label = i + 2; for (j = 0; j < queue_length[i]; j++) { Stack_Util_Coord(queue_head[i], stack->width, stack->height, &x, &y, &z); nbound = Stack_Neighbor_Bound_Test(conn, cwidth, cheight, cdepth, x, y, z, bound); if (nbound == conn) { STACK_SEED_GRAPH_UPDATE_QUEUE(1); /* for (k = 0; k < conn; k++) { if (1) { int checking_voxel = queue_head[i] + neighbor[k]; if ((mask[checking_voxel] > 0) && (mask[checking_voxel] != label)) { if (mask[checking_voxel] == 1) { ow->chord->array[queue_tail[i]] = checking_voxel; queue_tail[i] = checking_voxel; mask[checking_voxel] = label; queue_length[i]++; } else { if (mask[checking_voxel] > label) { connmat[mask[checking_voxel] - 2][i] = 1; } else { connmat[i][mask[checking_voxel] - 2] = 1; } } } } } */ } else { STACK_SEED_GRAPH_UPDATE_QUEUE(bound[k]); } } queue_head[i] = ow->chord->array[queue_head[i]]; queue_length[i]--; stop = FALSE; } } } free(queue_head); /* queue_head freed */ free(queue_tail); /* queue_head freed */ free(queue_length); /* queue_length freed */ STACK_OBJLABEL_CLOSE_WORKSPACE(ow); }
/** * Stack_Build_Seed_Graph_Gg() allows users to build a seed graph using * approximate geodesdic distances. The workspace should be created by * Make_Objlabel_Workspace_Gg() and initialized by Init_Objlabel_Workspace_Gg() * if necessary. */ Graph* Stack_Build_Seed_Graph_Gg(Stack *stack, int *seed, int nseed, BOOL weighted, Objlabel_Workspace *ow) { if (stack->kind != GREY16) { PRINT_EXCEPTION("Unsupported stack kind", "The stack must be GREY16"); return NULL; } int i, j, k; uint16 *level = (uint16 *) ow->u; uint16 *mask = (uint16 *) stack->array; const int conn = 26; /* each seed has a queue */ int *queue_head = iarray_malloc(nseed); /* queue_head malloced */ int *queue_tail = iarray_malloc(nseed); /* queue_head malloced */ int *queue_length = iarray_malloc(nseed); /* queue_length malloced */ /* At the beginning, each queue has one element, the corresponding seed */ iarraycpy(queue_head, seed, 0, nseed); iarraycpy(queue_tail, seed, 0, nseed); for (i = 0; i < nseed; i++) { queue_length[i] = 1; } int neighbor[26]; int bound[26]; int nbound; int cwidth = stack->width - 1; int cheight = stack->height - 1; int cdepth = stack->depth - 1; BOOL stop = FALSE; int x, y, z; Stack_Neighbor_Offset(conn, stack->width, stack->height, neighbor); #define STACK_SEED_GRAPH_UPDATE_QUEUE_GG(test) \ for (k = 0; k < conn; k++) { \ if (test) { \ int checking_voxel = queue_head[i] + neighbor[k]; \ if ((mask[checking_voxel] > 0) && (mask[checking_voxel] != label)) { \ if (mask[checking_voxel] == 1) { \ ow->chord->array[queue_tail[i]] = checking_voxel; \ queue_tail[i] = checking_voxel; \ mask[checking_voxel] = label; \ level[checking_voxel] = level[queue_head[i]] + 1; \ queue_length[i]++; \ } else { \ int v1, v2, tmp; \ v1 = i; \ v2 = mask[checking_voxel] - 2; \ ASSERT(v1 != v2, "Bug in Stack_Build_Seed_Graph_G()"); \ if (v1 > v2) { \ SWAP2(v1, v2, tmp); \ } \ if (Graph_Edge_Index(v1, v2, gw) < 0) { \ if (weighted == TRUE) { \ /*double dist = Stack_Util_Voxel_Distance(seed[v1], seed[v2], stack->width, stack->height);*/ \ double dist = level[checking_voxel] + level[queue_head[i]]; \ Graph_Add_Weighted_Edge(graph, v1, v2, dist); \ } else { \ Graph_Add_Edge(graph, v1, v2); \ } \ Graph_Expand_Edge_Table(v1, v2, graph->nedge -1, gw); \ } \ } \ } \ } \ } Graph *graph = Make_Graph(nseed, nseed, weighted); Graph_Workspace *gw = New_Graph_Workspace(); while (stop == FALSE) { stop = TRUE; for (i = 0; i < nseed; i++) { if (queue_length[i] > 0) { int label = i + 2; for (j = 0; j < queue_length[i]; j++) { Stack_Util_Coord(queue_head[i], stack->width, stack->height, &x, &y, &z); nbound = Stack_Neighbor_Bound_Test(conn, cwidth, cheight, cdepth, x, y, z, bound); if (nbound == conn) { STACK_SEED_GRAPH_UPDATE_QUEUE_GG(1); } else { STACK_SEED_GRAPH_UPDATE_QUEUE_GG(bound[k]); } } queue_head[i] = ow->chord->array[queue_head[i]]; queue_length[i]--; stop = FALSE; } } } free(queue_head); /* queue_head freed */ free(queue_tail); /* queue_head freed */ free(queue_length); /* queue_length freed */ return graph; }
int main(int argc, char *argv[]) { static char *Spec[] = {"[-t]", NULL}; Process_Arguments(argc, argv, Spec, 1); if (Is_Arg_Matched("-t")) { coordinate_3d_t coord = {0, 0, 0}; /* Translate coordinates. */ Geo3d_Translate_Coordinate(coord, coord+1, coord+2, 1.0, 2.0, 3.0); if ((coord[0] != 1.0) || (coord[1] != 2.0) || (coord[2] != 3.0)) { Print_Coordinate_3d(coord); PRINT_EXCEPTION(":( Bug?", "Unexpected coordinate values."); return 1; } coordinate_3d_t coord2 = {0, 0, 0}; double dx, dy, dz; Geo3d_Coordinate_Offset(coord[0], coord[1], coord[2], coord2[0], coord2[1], coord2[2], &dx, &dy, &dz); if ((dx != -coord[0]) || (dy != -coord[1]) || (dz != -coord[2])) { PRINT_EXCEPTION(":( Bug?", "Unexpected offset values."); return 1; } Coordinate_3d_Copy(coord2, coord); /* Rotate coordinates. */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 0); if (fabs(Geo3d_Orgdist_Sqr(coord[0], coord[1], coord[2]) - Geo3d_Orgdist_Sqr(coord2[0], coord2[1], coord2[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } /* inverse rotation */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 1); if ((fabs(coord[0] - coord2[0]) > 0.01) || (fabs(coord[1] - coord2[1]) > 0.01) || (fabs(coord[2] - coord2[2]) > 0.01)){ PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } /* Normal vector of an orientation. This is a canonical representaion * of an orientation. */ Geo3d_Orientation_Normal(0.1, 0.5, coord, coord+1, coord+2); /* We can also turn the normal vector into orientation. */ double theta, psi; Geo3d_Normal_Orientation(coord[0], coord[1], coord[2], &theta, &psi); if (fabs(theta - 0.1) > 0.01 || fabs(Normalize_Radian(psi) - 0.5) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* If we rotate the vector back, we should get (0, 0, 1). */ Geo3d_Rotate_Coordinate(coord, coord+1, coord+2, 0.1, 0.5, 1); if ((fabs(coord[0]) > 0.01) || (fabs(coord[1]) > 0.01) || (fabs(coord[2] - 1.0) > 0.01)){ PRINT_EXCEPTION(":( Bug?", "Rotation failed."); return 1; } Geo3d_Coord_Orientation(1, 0, 0, &theta, &psi); double in[3] = {0, 0, 1}; double out[3] = {0, 0, 0}; Rotate_XZ(in, out, 1, theta, psi, 0); if (fabs(out[0] - 1.0) > 0.01 || fabs(out[1]) > 0.01 || fabs(out[2]) > 0.01) { printf("%g, %g, %g\n", out[0], out[1], out[2]); printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* if (fabs(theta - TZ_PI_2) > 0.01 || fabs(Normalize_Radian(psi) - TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } */ Geo3d_Coord_Orientation(5, 0, 0, &theta, &psi); { double in[3] = {0, 0, 5}; double out[3] = {0, 0, 0}; Rotate_XZ(in, out, 1, theta, psi, 0); if (fabs(out[0] - 5.0) > 0.01 || fabs(out[1]) > 0.01 || fabs(out[2]) > 0.01) { printf("%g, %g, %g\n", out[0], out[1], out[2]); printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } } /* if (fabs(theta - TZ_PI_2) > 0.01 || fabs(Normalize_Radian(psi) - TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } */ /* Rotate the orientation. */ theta = TZ_PI_2; psi = TZ_PI; Geo3d_Rotate_Orientation(-TZ_PI, TZ_PI_2, &theta, &psi); if (fabs(theta + TZ_PI_2) > 0.01 || fabs(psi + TZ_PI_2) > 0.01) { printf("%g, %g\n", theta, psi); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } /* More extensive test on rotation */ Random_Seed(time(NULL) - getpid()); int i; for (i = 0; i < 100; i++) { double x = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double y = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double z = Unifrnd() * (1 - Bernrnd(0.5) * 2.0); double theta, psi; Geo3d_Coord_Orientation(x, y, z, &theta, &psi); double x2 = 0.0; double y2 = 0.0; double z2 = Geo3d_Orgdist(x, y, z); Geo3d_Rotate_Coordinate(&x2, &y2, &z2, theta, psi, 0); if (fabs(x - x2) > 0.01 || fabs(y - y2) > 0.01 || fabs(z - z2) > 0.01) { printf("%g, %g\n", theta, psi); printf("%g, %g, %g\n", x, y, z); printf("%g, %g, %g\n", x2, y2, z2); PRINT_EXCEPTION(":( Bug?", "Unexpected orientation values."); return 1; } } /* Dot product. */ if (Geo3d_Dot_Product(1.0, 2.0, 3.0, 3.0, 2.0, 1.0) != 10.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } /* Cross product. */ Geo3d_Cross_Product(1.0, 2.0, 3.0, 3.0, 1.0, 2.0, coord, coord+1, coord+2); if (fabs(Geo3d_Dot_Product(1.0, 2.0, 3.0, coord[0], coord[1], coord[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } if (fabs(Geo3d_Dot_Product(3.0, 1.0, 2.0, coord[0], coord[1], coord[2])) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } /* Distance calculations. */ if (Geo3d_Orgdist_Sqr(1.0, 2.0, 3.0) != 14.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (fabs(Geo3d_Orgdist(1.0, 2.0, 3.0) - sqrt(14.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (Geo3d_Dist(1.0, 2.0, 3.0, 1.0, 2.0, 3.0) != 0.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } if (Geo3d_Dist_Sqr(1.0, 2.0, 3.0, 0.0, 0.0, 0.0) != 14.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } /* Angle between two vectors. */ if (fabs(Geo3d_Angle2(1, 0, 0, 0, 0, 1) - TZ_PI_2) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected value."); return 1; } /* Distance between two lines */ coordinate_3d_t line1_start = {0, 0, 0}; coordinate_3d_t line1_end = {1, 0, 0}; coordinate_3d_t line2_start = {0, 1, 1}; coordinate_3d_t line2_end = {0, 2, 1}; double d = Geo3d_Line_Line_Dist(line1_start, line1_end, line2_start, line2_end); if (fabs(d - 1.0) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Distance between two line segments. */ double intersect1, intersect2; int cond; d = Geo3d_Lineseg_Lineseg_Dist(line1_start, line1_end, line2_start, line2_end, &intersect1, &intersect2, &cond); if (fabs(d - sqrt(2.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Distance between a point and a line segment. */ coord[0] = 0.5; coord[1] = 1.0; coord[2] = 1.0; d = Geo3d_Point_Lineseg_Dist(coord, line1_start, line1_end, &intersect1); if (fabs(d - sqrt(2.0)) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected distance."); return 1; } /* Get a break point of a line segment. */ Geo3d_Lineseg_Break(line1_start, line1_end, 0.1, coord); if ((coord[0] != 0.1) || (coord[1] != 0.0) || (coord[2] != 0.0)) { PRINT_EXCEPTION(":( Bug?", "Unexpected break point."); return 1; } /* Orientations of a set of points */ /* Orientation of a covariance matrix */ /* 3D coordinates routines */ /* Unitize a point. */ Coordinate_3d_Unitize(coord); if (fabs(Coordinate_3d_Norm(coord) - 1.0) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected norm."); return 1; } Set_Coordinate_3d(coord, 0.0, 0.0, 0.0); /* origin point is not affected by unitization */ Coordinate_3d_Unitize(coord); if (Coordinate_3d_Norm(coord) != 0.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected norm."); return 1; } Set_Coordinate_3d(coord, 1.0, 2.0, 3.0); /* Square length */ if (Coordinate_3d_Length_Square(coord) != 14) { PRINT_EXCEPTION(":( Bug?", "Unexpected square length"); } /* Angle between two vectors */ coordinate_3d_t coord_a1 = { 1, 0, 0 }; coordinate_3d_t coord_a2 = { 0, 0, 1 }; if (fabs(Coordinate_3d_Angle2(coord_a1, coord_a2) - TZ_PI_2) > 0.01) { PRINT_EXCEPTION(":( Bug?", "Unexpected angle"); } /* Scale coordinates */ Coordinate_3d_Scale(coord, 2.0); if ((coord[0] != 2.0) || (coord[1] != 4.0) || (coord[2] != 6.0)) { PRINT_EXCEPTION(":( Bug?", "Unexpected coordinate value."); return 1; } /* Normalizd dot product */ if (Coordinate_3d_Normalized_Dot(coord, coord2) > 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected dot product."); return 1; } Set_Coordinate_3d(coord, 1.0, 2.0, 3.0); Coordinate_3d_Copy(coord2, coord); Coordinate_3d_Scale(coord2, 2.0); coordinate_3d_t coord3; Coordinate_3d_Copy(coord3, coord); Coordinate_3d_Scale(coord3, 3.0); /* cos value of an angle formed by 3 points */ if (Coordinate_3d_Cos3(coord, coord2, coord3) != 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected cos value."); return 1; } /* cos value of an angle formed by 4 points */ coordinate_3d_t coord4; Coordinate_3d_Copy(coord4, coord); Coordinate_3d_Scale(coord4, 4.0); if (Coordinate_3d_Cos4(coord, coord2, coord3, coord4) != 1.0) { PRINT_EXCEPTION(":( Bug?", "Unexpected cos value."); return 1; } printf(":) Testing passed.\n"); return 0; } #if 0 Geo3d_Vector v1 = {1.1, 0, 0}; Geo3d_Vector v2 = {5, 0, 0}; double theta1 = 3.83812; double psi1 = 3.53202; double theta2 = 0.72657; double psi2 = 3.61214; Geo3d_Orientation_Normal(theta1, psi1, &(v1.x), &(v1.y), &(v1.z)); Geo3d_Orientation_Normal(theta2, psi2, &(v2.x), &(v2.y), &(v2.z)); Print_Geo3d_Vector(&v1); Print_Geo3d_Vector(&v2); printf("%g\n", Geo3d_Vector_Dot(&v1, &v2)); printf("%g\n", Geo3d_Vector_Angle2(&v1, &v2)); double angle = Vector_Angle(-1.0, -1.0); theta1 = -3.0; psi1 = -5.0; double x, y, z; Geo3d_Orientation_Normal(theta1, psi1, &x, &y, &z); printf("%g, %g, %g\n", x, y, z); Geo3d_Normal_Orientation(x, y, z, &theta1, &psi1); printf("%g\n", angle * 180.0 / TZ_PI); printf("%g, %g\n", theta1, psi1); Geo3d_Orientation_Normal(theta1, psi1, &x, &y, &z); printf("%g, %g, %g\n", x, y, z); #endif #if 0 Geo3d_Scalar_Field *field = Read_Geo3d_Scalar_Field("../data/mouse_neuron/seeds.bn"); Print_Geo3d_Scalar_Field_Info(field); Stack *stack = Read_Stack("../data/mouse_neuron/mask.tif"); Geo3d_Scalar_Field_Draw_Stack(field, stack, NULL, NULL); Write_Stack("../data/test.tif", stack); #endif #if 0 double line_start[3] = {2.0, 3.0, 4.0}; double line_end[3] = {1.0, 1.0, 6.0}; double point[3] = {10.5, 20.5, 40.7}; double lamda; printf("%g\n", Geo3d_Point_Lineseg_Dist(point, line_start, line_end, &lamda)); double line_point[3]; double length = sqrt(Geo3d_Dist_Sqr(line_start[0], line_start[1], line_start[2], line_end[0], line_end[1], line_end[2])); line_point[0] = line_start[0] + lamda * (line_end[0] - line_start[0]); line_point[1] = line_start[1] + lamda * (line_end[1] - line_start[1]); line_point[2] = line_start[2] + lamda * (line_end[2] - line_start[2]); printf("%g\n", lamda); printf("%g\n", sqrt(Geo3d_Dist_Sqr(line_point[0], line_point[1], line_point[2], point[0], point[1], point[2]))); darray_sub(point, line_point, 3); darray_sub(line_end, line_point, 3); printf("%g\n", Geo3d_Dot_Product(point[0], point[1], point[2], line_end[0], line_end[1], line_end[2])); #endif #if 0 Geo3d_Scalar_Field *field = Read_Geo3d_Scalar_Field("../data/mouse_neuron3_org/seeds"); //Print_Geo3d_Scalar_Field(field); darray_write("../data/pts.bn", (double *)field->points, field->size * 3); darray_write("../data/ws.bn", field->values, field->size); coordinate_3d_t centroid; Geo3d_Scalar_Field_Centroid(field, centroid); Print_Coordinate_3d(centroid); double cov[9]; Geo3d_Scalar_Field_Cov(field, cov); darray_print2(cov, 3, 3); darray_write("../data/cov.bn", cov, 9); double vec[3]; Geo3d_Cov_Orientation(cov, vec); darray_print2(vec, 3, 1); #endif #if 0 double mu1, mu2; # if 0 /* parallel case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {1, 1, 10}; double line2_start[3] = {0, 1, 0}; double line2_end[3] = {1, 2, 10}; # endif # if 0 /* parallel case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {1, 1, 10}; double line2_start[3] = {-1, -1, -1}; double line2_end[3] = {-3, -3, -21}; # endif # if 0 /* i-i case */ double line1_start[3] = {0, 0, 0}; double line1_end[3] = {3, 4, 5}; double line2_start[3] = {-1, 8, 9}; double line2_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line1_start[3] = {3, 4, 5}; double line1_end[3] = {3, 4, 5}; double line2_start[3] = {-1, 8, 9}; double line2_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line2_start[3] = {3, 4, 5}; double line2_end[3] = {3, 4, 5}; double line1_start[3] = {-1, 8, 9}; double line1_end[3] = {1, -3, -4}; # endif # if 0 /* point to line case */ double line2_start[3] = {3, 4, 5}; double line2_end[3] = {3, 4, 5}; double line1_start[3] = {-1, 8, 9}; double line1_end[3] = {-1, 8, 9}; # endif # if 0 double line1_start[3] = {256.062, 328.674, 67.9029}; double line1_end[3] = {246.162, 330.078, 67.9896}; double line2_start[3] = {262.368, 336.609, 68.3076}; double line2_end[3] = {259.956, 326.944, 67.4325}; # endif int cond; double dist = Geo3d_Lineseg_Lineseg_Dist(line1_start, line1_end, line2_start, line2_end, &mu1, &mu2, &cond); printf("%d, %g\n", cond, dist); dist = Geo3d_Line_Line_Dist(line1_start, line1_end, line2_start, line2_end); printf("%g\n", dist); #endif #if 1 double *d = Unifrnd_Double_Array(12000000, NULL); double *d2 = Unifrnd_Double_Array(12000000, NULL); tic(); Rotate_XZ(d, d, 4000000, 0.1, 0.2, 1); printf("%llu\n", toc()); tic(); Rotate_XZ2(d, d, 4000000, 0.1, 0.2, 0); printf("%llu\n", toc()); #endif #if 0 double d[3] = {0.1, 0.2, 0.3}; Rotate_XZ(d, d, 1, 0.1, 0.2, 0); darray_print2(d, 3, 1); #endif #if 0 printf("%g\n", Ellipse_Point_Distance(5, 5, 3, 5)); #endif #if 0 Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; ellipse->orientation[0] = 1.0; Print_Geo3d_Ellipse(ellipse); FILE *fp = fopen("../data/test.swc", "w"); Swc_Node node; Geo3d_Ellipse_To_Swc_Node(ellipse, 1, -1, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); /* double pt[3] = {0.0, 0.0, 1.0}; printf("%g\n", Geo3d_Ellipse_Point_Distance(ellipse, pt)); */ Geo3d_Ellipse *ellipse2 = Copy_Geo3d_Ellipse(ellipse); ellipse2->center[0] += 10.0; ellipse2->orientation[0] = 2.0; ellipse2->radius += 3.0; Geo3d_Ellipse *ellipse3 = Geo3d_Ellipse_Interpolate(ellipse, ellipse2, 0.2, NULL); Geo3d_Ellipse_To_Swc_Node(ellipse3, 2, 1, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); Geo3d_Ellipse_To_Swc_Node(ellipse2, 3, 2, 1.0, 2, &node); Swc_Node_Fprint(fp, &node); Print_Geo3d_Ellipse(ellipse3); fclose(fp); #endif #if 0 Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; FILE *fp = fopen("../data/test.swc", "w"); coordinate_3d_t *pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 1, -1, 1.0, 2); ellipse->orientation[0] = 1.0; pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 21, -1, 1.0, 3); ellipse->center[2] = 5.0; pts = Geo3d_Ellipse_Sampling(ellipse, 20, 0, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 20, 41, -1, 1.0, 4); coordinate_3d_t vec[2]; Coordinate_3d_Copy(vec[0], ellipse->center); Geo3d_Ellipse_First_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 101, -1, 1.0, 5); Geo3d_Ellipse_Second_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 111, -1, 1.0, 6); Geo3d_Ellipse_Normal_Vector(ellipse, vec[1]); Coordinate_3d_Add(vec[0], vec[1], vec[1]); Geo3d_Point_Array_Swc_Fprint(fp, vec, 2, 121, -1, 1.0, 7); fclose(fp); #endif #if 0 Geo3d_Ellipse ep_array[10]; Geo3d_Ellipse *ellipse = New_Geo3d_Ellipse(); ellipse->scale = 0.5; Geo3d_Ellipse_Copy(ep_array, ellipse); FILE *fp = fopen("../data/test.swc", "w"); ellipse->orientation[0] += 0.5; ellipse->center[2] += 3.0; ellipse->center[0] += 1.0; Geo3d_Ellipse_Copy(ep_array + 1, ellipse); ellipse->center[2] += 3.0; Geo3d_Ellipse_Copy(ep_array + 2, ellipse); coordinate_3d_t *pts = Geo3d_Ellipse_Array_Sampling(ep_array, 3, 20, NULL); Geo3d_Point_Array_Swc_Fprint(fp, pts, 60, 1, -1, 1.0, 2); fclose(fp); #endif #if 0 printf("%g\n", Vector_Angle(1.0, 1.0) * 180 / TZ_PI); #endif #if 0 double theta, psi; coordinate_3d_t coord; coord[0] = 0.0822; coord[1] = 0.1515; coord[2] = 0.1369; Geo3d_Coord_Orientation(coord[0], coord[1], coord[2], &theta, &psi); printf("%g, %g\n", theta, psi); Geo3d_Orientation_Normal(theta, psi, coord, coord+1, coord+2); Print_Coordinate_3d(coord); #endif #if 0 double theta, psi; double x = -1; double y = 1.83697019872103e-16; double z = 3; Geo3d_Coord_Orientation(x, y, z, &theta, &psi); #endif #if 0 double theta = Vector_Angle2(0, 1, 1, 0, TRUE); printf("angle: %g\n", theta); theta = Vector_Angle2(0, 1, -1, 0, FALSE); printf("angle: %g\n", theta); theta = Vector_Angle2(-1, 0, -1, -1, TRUE); printf("angle: %g\n", theta); #endif return 0; }