void ZLocsegChainConn::display(QPainter &painter, int z, Display_Style option) const
{
UNUSED_PARAMETER(option);
if ((m_hookChain != NULL) && (m_loopChain != NULL)) {
Local_Neuroseg *locseg1;
Local_Neuroseg *locseg2;
if (m_hookSpot == 0) {
locseg1 = m_hookChain->headNeuroseg();
} else {
locseg1 = m_hookChain->tailNeuroseg();
}
if (m_mode == NEUROCOMP_CONN_LINK) {
if (m_loopSpot == 0) {
locseg2 = m_loopChain->headNeuroseg();
} else {
locseg2 = m_loopChain->tailNeuroseg();
}
} else {
#ifdef _DEBUG_2
print();
#endif
locseg2 = m_loopChain->neurosegAt(m_loopSpot);
}
double center1[3], center2[3];
Local_Neuroseg_Center(locseg1, center1);
Local_Neuroseg_Center(locseg2, center2);
for (int i = 0; i < 3; i++) {
center1[i] = round(center1[i]);
center2[i] = round(center2[i]);
}
QPointF center;
painter.setPen(QPen(QColor(255, 255, 255, 255), .7));
if ((center1[2] == z) || (z < 0)) {
center.setX(center1[0]);
center.setY(center1[1]);
painter.drawEllipse(center, 3, 3);
}
if ((center2[2] == z) || (z < 0)){
center.setX(center2[0]);
center.setY(center2[1]);
painter.drawEllipse(center, 3, 3);
}
voxel_t start, end;
for (int i = 0; i < 3; i++) {
start[i] = iround(center1[i]);
end[i] = iround(center2[i]);
}
if (start[2] == z || z < 0 || end[2] == z || z < 0 ||
(start[2] < z && end[2] > z) ||
(start[2] > z && end[2] < z)) {
QColor lineColor(255, 255, 255);
painter.setPen(QPen(lineColor, .7));
painter.drawLine(QPointF(center1[0], center1[1]),
QPointF(center2[0], center2[1]));
}
/*
Object_3d *obj = Line_To_Object_3d(start, end);
for (size_t i = 0; i < obj->size; i++) {
if (((obj->voxels[i][2] == z) || (z < 0))&&
IS_IN_CLOSE_RANGE(obj->voxels[i][0], 0, widget->width() - 1) &&
IS_IN_CLOSE_RANGE(obj->voxels[i][1], 0, widget->height() - 1)){
uchar *pixel = widget->scanLine(obj->voxels[i][1])
+ 4 * obj->voxels[i][0];
if (i % 2 == 0) {
pixel[0] = 255;
pixel[1] = 255;
pixel[2] = 255;
pixel[3] = 255;
} else {
pixel[0] = 0;
pixel[1] = 0;
pixel[2] = 0;
pixel[3] = 255;
}
}
}
Kill_Object_3d(obj);
*/
}
}
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);
}
}
}
