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;
}
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;
}
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;
}
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;
}
