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;
}
void Trace_Evaluate_Seed(const Geo3d_Scalar_Field *seed,
const Stack *signal, double z_scale,
Trace_Evaluate_Seed_Workspace *ws)
{
OBJECT_SAFE_FREE(ws->score, free);
ws->score = darray_malloc(seed->size);
int i;
OBJECT_SAFE_FREE(ws->locseg, free);
ws->locseg = (Local_Neuroseg *) malloc(seed->size * sizeof(Local_Neuroseg));
ws->nseed = seed->size;
int index = 0;
if (ws->base_mask == NULL) {
ws->base_mask = Make_Stack(GREY, signal->width, signal->height,
signal->depth);
Zero_Stack(ws->base_mask);
}
for (i = 0; i < seed->size; i++) {
printf("-----------------------------> seed: %d / %d\n", i, seed->size);
index = i;
int x = (int) seed->points[index][0];
int y = (int) seed->points[index][1];
int z = (int) seed->points[index][2];
if (ws->zshift) {
stack_adjust_zpos(signal, x, y, &z);
if (ws->trace_mask != NULL) {
if (Stack_Pixel(ws->trace_mask, x, y, z, 0) > 0.0) {
printf("traced**\n");
ws->score[i] = 0.0;
continue;
}
}
}
double width = seed->values[index];
int seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height,
signal->depth);
if (width < 3.0) {
width += 0.5;
}
Set_Neuroseg(&(ws->locseg[i].seg), width, 0.0, NEUROSEG_DEFAULT_H,
0.0, 0.0, 0.0, 0.0, 1.0);
double cpos[3];
cpos[0] = x;
cpos[1] = y;
cpos[2] = z;
cpos[2] /= z_scale;
Set_Neuroseg_Position(&(ws->locseg[i]), cpos, NEUROSEG_CENTER);
if (ws->base_mask->array[seed_offset] > 0) {
printf("labeled\n");
ws->score[i] = 0.0;
continue;
}
{ /* for faster evaluation*/
Local_Neuroseg *locseg = ws->locseg + i;
Stack_Fit_Score fs;
fs.n = 1;
fs.options[0] = STACK_FIT_CORRCOEF;
Locseg_Fit_Workspace *fw = (Locseg_Fit_Workspace*) ws->fws;
int k;
for (k = 0; k < fw->pos_adjust; k++) {
Local_Neuroseg_Position_Adjust(locseg, signal, z_scale);
}
Local_Neuroseg_Orientation_Search_C(locseg, signal, z_scale, &fs);
if (ws->fit_option <= 1) {
for (k = 0; k < 3; k++) {
Local_Neuroseg_Position_Adjust(locseg, signal, z_scale);
}
}
double bpos[3];
double tpos[3];
Local_Neuroseg_Bottom(locseg, bpos);
Local_Neuroseg_Center(locseg, cpos);
Local_Neuroseg_Top(locseg, tpos);
if (ws->trace_mask != NULL) {
if ((Stack_Pixel(ws->trace_mask, bpos[0], bpos[1], bpos[2], 0) > 0) &&
(Stack_Pixel(ws->trace_mask, cpos[0], cpos[1], cpos[2], 0) > 0) &&
(Stack_Pixel(ws->trace_mask, tpos[0], tpos[1], tpos[2], 0) > 0)) {
printf("traced*\n");
ws->score[i] = 0.0;
continue;
}
}
if ((ws->fit_option == 1) || (ws->fit_option == 2)) {
Local_Neuroseg_R_Scale_Search(locseg, signal, z_scale, 1.0, 10.0, 1.0,
0.5, 5.0, 0.5, NULL);
}
Fit_Local_Neuroseg_W(locseg, signal, z_scale, fw);
}
if (ws->trace_mask != NULL) {
if (Local_Neuroseg_Hit_Mask(ws->locseg + i,
ws->trace_mask, z_scale) > 0) {
printf("traced\n");
ws->score[i] = 0.0;
continue;
}
}
//ws->score[i] = Local_Neuroseg_Score(ws->locseg + i, signal, z_scale, &fs);
ws->score[i] = ws->fws->sws->fs.scores[1];
printf("%g\n", ws->score[i]);
if (Local_Neuroseg_Good_Score(ws->locseg + i, ws->score[i], ws->min_score)
== TRUE) {
Local_Neuroseg_Label_G(ws->locseg + i, ws->base_mask, -1, 2, z_scale);
} else {
Local_Neuroseg_Label_G(ws->locseg + i, ws->base_mask, -1, 1, z_scale);
}
}
}
Stack* 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 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;
}
/*
* trace_neuron - trace neuron from given seeds
*
* trace_neuron [!wtr] seed_file -Dsave_dir
* -r: write intermediate results
*
*/
int main(int argc, char* argv[])
{
static char *Spec[] = {
"[!wtr] [-canvas <string>] [-mask <string>] [-res <string>] [-minr <int>]",
"-minlen <double>",
" <image:string> -S<string> -D<string>",
NULL};
Process_Arguments(argc, argv, Spec, 1);
char *dir = Get_String_Arg("-D");
char file_path[100];
sprintf(file_path, "%s/%s", dir, Get_String_Arg("-S"));
printf("%s\n", file_path);
Geo3d_Scalar_Field *seed = Read_Geo3d_Scalar_Field(file_path);
int idx;
sprintf(file_path, "%s/%s.bn", dir, "max_r");
double max_r;
int tmp;
if (fexist(file_path)) {
darray_read2(file_path, &max_r, &tmp);
} else {
max_r = darray_max(seed->values, seed->size, &idx);
}
printf("%g\n", max_r);
max_r *= 1.5;
/*
sprintf(file_path, "%s/%s", dir, "soma0.bn");
if (!fexist(file_path)) {
max_r *= 2.0;
}
*/
Set_Neuroseg_Max_Radius(max_r);
Stack *signal = Read_Stack(Get_String_Arg("image"));
dim_type dim[3];
dim[0] = signal->width;
dim[1] = signal->height;
dim[2] = signal->depth;
/*
IMatrix *chord = Make_IMatrix(dim, 3);
Stack *code = Make_Stack(GREY16,
signal->width, signal->height, signal->depth);
*/
Rgb_Color color;
Set_Color(&color, 255, 0, 0);
Stack *canvas = NULL;
char trace_file_path[100];
sprintf(trace_file_path, "%s/%s", dir, Get_String_Arg("-canvas"));
if (fexist(trace_file_path) == 1) {
canvas = Read_Stack((char *) trace_file_path);
} else {
canvas = Copy_Stack(signal);
Stretch_Stack_Value_Q(canvas, 0.999);
Translate_Stack(canvas, COLOR, 1);
}
Stack *traced = NULL;
char trace_mask_path[100];
sprintf(trace_mask_path, "%s/%s", dir, Get_String_Arg("-mask"));
if (fexist(trace_mask_path) == 1) {
traced = Read_Stack((char *) trace_mask_path);
} else {
traced = Make_Stack(GREY, signal->width, signal->height, signal->depth);
One_Stack(traced);
}
//Object_3d *obj = NULL;
int seed_offset = -1;
Neurochain *chain = NULL;
double z_scale = 1.0;
if (Is_Arg_Matched("-res")) {
sprintf(file_path, "%s", Get_String_Arg("-res"));
if (fexist(file_path)) {
double res[3];
int length;
darray_read2(file_path, res, &length);
if (res[0] != res[1]) {
perror("Different X-Y resolutions.");
TZ_ERROR(ERROR_DATA_VALUE);
}
z_scale = res[0] / res[2];
}
}
//sprintf(file_path, "%s/%s", dir, Get_String_Arg("-M"));
//Stack *stack = Read_Stack(file_path);
tic();
FILE *fp = NULL;
char chain_file_path[100];
char vrml_file_path[100];
double min_chain_length = 25.0;
if (Is_Arg_Matched("-minlen")) {
min_chain_length = Get_Double_Arg("-minlen");
}
int *indices = iarray_malloc(seed->size);
double *values = darray_malloc(seed->size);
int i;
Local_Neuroseg *locseg = (Local_Neuroseg *)
malloc(seed->size * sizeof(Local_Neuroseg));
int index = 0;
for (i = 0; i < seed->size; i++) {
printf("-----------------------------> seed: %d / %d\n", i, seed->size);
indices[i] = i;
index = i;
int x = (int) seed->points[index][0];
int y = (int) seed->points[index][1];
int z = (int) seed->points[index][2];
double width = seed->values[index];
chain = New_Neurochain();
seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height,
signal->depth);
if (width < 3.0) {
width += 0.5;
}
Set_Neuroseg(&(locseg[i].seg), width, width, 12.0,
0.0, 0.0, 0.0);
double cpos[3];
cpos[0] = x;
cpos[1] = y;
cpos[2] = z;
cpos[2] *= z_scale;
Set_Neuroseg_Position(&(locseg[i]), cpos, NEUROSEG_CENTER);
Stack_Fit_Score fs;
fs.n = 1;
fs.options[0] = 1;
values[i] = Local_Neuroseg_Orientation_Search_C(&(locseg[i]), signal, z_scale, &fs);
}
darray_qsort(values, indices, seed->size);
/*
for (i = 0; i < seed->size; i++) {
indices[i] = i;
}
darraycpy(values, seed->values, 0, seed->size);
darray_qsort(values, indices, seed->size);
*/
int counter = 0;
// for (i = seed->size - 1; i >= seed->size - 231; i--) {
for (i = seed->size - 1; i >= 0; i--) {
index = indices[i];
printf("-----------------------------> seed: %d / %d\n", i, seed->size);
sprintf(chain_file_path, "%s/chain%d.bn", dir, index);
sprintf(vrml_file_path, "%s/chain%d.wrl", dir, index);
if (fexist(chain_file_path) == 1) {
chain = Read_Neurochain(chain_file_path);
if (Neurochain_Geolen(chain) >= min_chain_length) {
Write_Neurochain_Vrml(vrml_file_path, chain);
Neurochain_Label(canvas, chain, z_scale);
Neurochain_Erase_E(traced, chain, z_scale, 0,
Neurochain_Length(chain, FORWARD),
1.5, 0.0);
}
Free_Neurochain(chain);
printf("chain exists\n");
continue;
}
int x = (int) seed->points[index][0];
int y = (int) seed->points[index][1];
int z = (int) seed->points[index][2];
if (*STACK_PIXEL_8(traced, x, y, z, 0) == 0) {
printf("traced \n");
continue;
}
double width = seed->values[index];
if (width > max_r) {
printf("too thick\n");
continue;
}
if (Is_Arg_Matched("-minr")) {
int max_level = (int) (width + 0.5);
if (max_level <= Get_Int_Arg("-minr")) {
printf("too thin\n");
continue;
}
}
/*
seed_offset = Stack_Util_Offset(x, y, z, signal->width, signal->height,
signal->depth);
*/
chain = New_Neurochain();
/*
Stack_Level_Code_Constraint(stack, code, chord->array, &seed_offset, 1,
max_level + 1);
Voxel_t v;
v[0] = x;
v[1] = y;
v[2] = z;
Stack *tmp_stack = Copy_Stack(stack);
obj = Stack_Grow_Object_Constraint(tmp_stack, 1, v, chord, code,
max_level);
Free_Stack(tmp_stack);
Print_Object_3d_Info(obj);
double vec[3];
Object_3d_Orientation_Zscale(obj, vec, MAJOR_AXIS, z_scale);
double theta, psi;
Geo3d_Vector obj_vec;
Set_Geo3d_Vector(&obj_vec, vec[0], vec[1], vec[2]);
Geo3d_Vector_Orientation(&obj_vec, &theta, &psi);
*/
/*
if (width < 3.0) {
width += 0.5;
}
Set_Neuroseg(&(chain->locseg.seg), width, width, 12.0,
0.0, 0.0, 0.0);
double cpos[3];
cpos[0] = x;
cpos[1] = y;
cpos[2] = z;
cpos[2] *= z_scale;
//Set_Neuroseg_Position(&(chain->locseg), cpos, NEUROSEG_BOTTOM);
Set_Neuroseg_Position(&(chain->locseg), cpos, NEUROSEG_CENTER);
Stack_Fit_Score fs;
fs.n = 1;
fs.options[0] = 1;
Local_Neuroseg_Orientation_Search_C(&(chain->locseg), signal, z_scale,
&fs);
//fs.options[0] = 1;
*/
Copy_Local_Neuroseg(&(chain->locseg), &(locseg[index]));
Neurochain *chain_head = chain;
if (Initialize_Tracing(signal, chain, NULL, z_scale) >= MIN_SCORE) {
if ((Neuroseg_Hit_Traced(&(chain->locseg), traced, z_scale) == FALSE) &&
(chain->locseg.seg.r1 < max_r) &&
(chain->locseg.seg.r2 < max_r)) {
//Initialize_Tracing(signal, chain, NULL, z_scale);
chain = Trace_Neuron2(signal, chain, BOTH, traced, z_scale, 500);
//Neurochain *chain_head = Neurochain_Head(chain);
chain_head = Neurochain_Remove_Overlap_Segs(chain);
chain_head = Neurochain_Remove_Turn_Ends(chain_head, 0.5);
/*
if (i == seed->size - 231) {
Print_Neurochain(chain_head);
}
*/
fp = fopen(chain_file_path, "w");
Neurochain_Fwrite(chain_head, fp);
fclose(fp);
if (Neurochain_Geolen(chain_head) >= min_chain_length) {
Write_Neurochain_Vrml(vrml_file_path, chain_head);
Neurochain_Erase_E(traced, chain_head, z_scale, 0,
Neurochain_Length(chain_head, FORWARD),
1.5, 0.0);
Neurochain_Label(canvas, chain_head, z_scale);
counter += Neurochain_Length(chain_head, FORWARD);
if (counter > 500) {
if (Is_Arg_Matched("-r")) {
Write_Stack((char *) trace_mask_path, traced);
}
if (Is_Arg_Matched("-r")) {
Write_Stack((char *) trace_file_path, canvas);
}
counter = 0;
}
}
}
}
Free_Neurochain(chain_head);
//Kill_Object_3d(obj);
}
Write_Stack((char *) trace_file_path, canvas);
if (Is_Arg_Matched("-r")) {
Write_Stack((char *) trace_mask_path, traced);
}
Kill_Geo3d_Scalar_Field(seed);
printf("Time passed: %lld\n", toc());
return 0;
}
