/* 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; }
ZSwcPath ZNeuronTracer::trace(double x, double y, double z) { if (m_traceWorkspace->trace_mask == NULL) { m_traceWorkspace->trace_mask = C_Stack::make(GREY, C_Stack::width(m_stack), C_Stack::height(m_stack), C_Stack::depth(m_stack)); Zero_Stack(m_traceWorkspace->trace_mask); } double pos[3]; pos[0] = x; pos[1] = y; pos[2] = z; Local_Neuroseg *locseg = New_Local_Neuroseg(); Set_Neuroseg(&(locseg->seg), 3.0, 0.0, 11.0, TZ_PI_4, 0.0, 0.0, 0.0, 1.0); Set_Neuroseg_Position(locseg, pos, NEUROSEG_CENTER); Locseg_Fit_Workspace *ws = (Locseg_Fit_Workspace*) m_traceWorkspace->fit_workspace; Local_Neuroseg_Optimize_W(locseg, m_stack, 1.0, 1, ws); Trace_Record *tr = New_Trace_Record(); tr->mask = ZERO_BIT_MASK; Trace_Record_Set_Fix_Point(tr, 0.0); Trace_Record_Set_Direction(tr, DL_BOTHDIR); Locseg_Node *p = Make_Locseg_Node(locseg, tr); Locseg_Chain *locseg_chain = Make_Locseg_Chain(p); Trace_Workspace_Set_Trace_Status(m_traceWorkspace, TRACE_NORMAL, TRACE_NORMAL); Trace_Locseg(m_stack, 1.0, locseg_chain, m_traceWorkspace); Locseg_Chain_Remove_Overlap_Ends(locseg_chain); Locseg_Chain_Remove_Turn_Ends(locseg_chain, 1.0); int n; Geo3d_Circle *circles = Locseg_Chain_To_Geo3d_Circle_Array(locseg_chain, NULL, &n); ZSwcPath path; for (int i = 0; i < n; ++i) { Swc_Tree_Node *tn = SwcTreeNode::makePointer(circles[i].center[0], circles[i].center[1], circles[i].center[2], circles[i].radius); if (!path.empty()) { SwcTreeNode::setParent(tn, path.back()); } path.push_back(tn); } return path; }
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; }
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); } } }
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(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; }
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[]) { #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; }
Stack* ZNeuronTraceSeeder::sortSeed( Geo3d_Scalar_Field *seedPointArray, const Stack *signal, Trace_Workspace *ws) { Locseg_Fit_Workspace *fws = (Locseg_Fit_Workspace *) ws->fit_workspace; fws->sws->fs.n = 2; fws->sws->fs.options[0] = STACK_FIT_DOT; fws->sws->fs.options[1] = STACK_FIT_CORRCOEF; fws->pos_adjust = 1; m_seedArray.resize(seedPointArray->size); m_seedScoreArray.resize(seedPointArray->size); /* <seed_mask> allocated */ Stack *seed_mask = C_Stack::make(GREY, signal->width, signal->height, signal->depth); Zero_Stack(seed_mask); for (int i = 0; i < seedPointArray->size; i++) { printf("-----------------------------> seed: %d / %d\n", i, seedPointArray->size); int index = i; int x = (int) seedPointArray->points[index][0]; int y = (int) seedPointArray->points[index][1]; int z = (int) seedPointArray->points[index][2]; double width = seedPointArray->values[index]; ssize_t seed_offset = C_Stack::offset(x, y, z, signal->width, signal->height, signal->depth); if (width < 3.0) { width += 0.5; } Set_Neuroseg(&(m_seedArray[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(&(m_seedArray[i]), cpos, NEUROSEG_CENTER); if (seed_mask->array[seed_offset] > 0) { printf("labeled\n"); m_seedScoreArray[i] = 0.0; continue; } //Local_Neuroseg_Optimize(locseg + i, signal, z_scale, 0); double z_scale = 1.0; Local_Neuroseg_Optimize_W(&(m_seedArray[i]), signal, z_scale, 0, fws); m_seedScoreArray[i] = fws->sws->fs.scores[1]; double min_score = ws->min_score; if (m_seedScoreArray[i] > min_score) { Local_Neuroseg_Label_G(&(m_seedArray[i]), seed_mask, -1, 2, z_scale); } else { Local_Neuroseg_Label_G(&(m_seedArray[i]), seed_mask, -1, 1, z_scale); } } /* <seed_mask> freed */ // C_Stack::kill(seed_mask); return seed_mask; }
ZSwcPath ZNeuronTracer::trace(double x, double y, double z) { setTraceScoreThreshold(TRACING_INTERACTIVE); if (m_traceWorkspace->trace_mask == NULL) { m_traceWorkspace->trace_mask = C_Stack::make(GREY, getStack()->width(), getStack()->height(), getStack()->depth()); Zero_Stack(m_traceWorkspace->trace_mask); } Stack *stackData = getIntensityData(); ZIntPoint stackOffset = getStack()->getOffset(); double pos[3]; pos[0] = x - stackOffset.getX(); pos[1] = y - stackOffset.getY(); pos[2] = z - stackOffset.getZ(); /* alloc <locseg> */ Local_Neuroseg *locseg = New_Local_Neuroseg(); Set_Neuroseg(&(locseg->seg), 3.0, 0.0, 11.0, TZ_PI_4, 0.0, 0.0, 0.0, 1.0); Set_Neuroseg_Position(locseg, pos, NEUROSEG_CENTER); Locseg_Fit_Workspace *ws = (Locseg_Fit_Workspace*) m_traceWorkspace->fit_workspace; Local_Neuroseg_Optimize_W(locseg, stackData, 1.0, 1, ws); Trace_Record *tr = New_Trace_Record(); tr->mask = ZERO_BIT_MASK; Trace_Record_Set_Fix_Point(tr, 0.0); Trace_Record_Set_Direction(tr, DL_BOTHDIR); /* consume <locseg> */ Locseg_Node *p = Make_Locseg_Node(locseg, tr); /* alloc <locseg_chain> */ Locseg_Chain *locseg_chain = Make_Locseg_Chain(p); Trace_Workspace_Set_Trace_Status(m_traceWorkspace, TRACE_NORMAL, TRACE_NORMAL); Trace_Locseg(stackData, 1.0, locseg_chain, m_traceWorkspace); Locseg_Chain_Remove_Overlap_Ends(locseg_chain); Locseg_Chain_Remove_Turn_Ends(locseg_chain, 1.0); int n; /* alloc <circles> */ Geo3d_Circle *circles = Locseg_Chain_To_Geo3d_Circle_Array(locseg_chain, NULL, &n); /* free <locseg_chain> */ Kill_Locseg_Chain(locseg_chain); ZSwcPath path; if (n > 0) { // bool hit = false; int start = 0; int end = n; if (Trace_Workspace_Mask_Value(m_traceWorkspace, circles[0].center) > 0) { for (int i = 1; i < n; ++i) { start = i - 1; if (Trace_Workspace_Mask_Value(m_traceWorkspace, circles[i].center) == 0) { break; } } } if (n > 1) { if (Trace_Workspace_Mask_Value(m_traceWorkspace, circles[n - 1].center) > 0) { for (int i = n - 2; i >= 0; --i) { end = i + 2; if (Trace_Workspace_Mask_Value(m_traceWorkspace, circles[i].center) == 0) { break; } } } } for (int i = start; i < end; ++i) { Swc_Tree_Node *tn = SwcTreeNode::makePointer(circles[i].center[0], circles[i].center[1], circles[i].center[2], circles[i].radius); if (!path.empty()) { SwcTreeNode::setParent(tn, path.back()); } SwcTreeNode::translate(tn, stackOffset); path.push_back(tn); } } /* free <circles> */ if (circles != NULL) { free(circles); } return path; }
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(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() { #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; }