ZSwcTree* ZSwcGenerator::createCircleSwc(double cx, double cy, double cz, double r)
{
if (r < 0.0) {
return NULL;
}
ZSwcTree *tree = createVirtualRootSwc();
Swc_Tree_Node *parent = tree->root();
double nodeRadius = r * 0.05;
for (double angle = 0.0; angle < 6.0; angle += 0.314) {
double x, y, z;
x = r * cos(angle) + cx;
y = r * sin(angle) + cy;
z = cz;
Swc_Tree_Node *tn = SwcTreeNode::makePointer(x, y, z, nodeRadius);
SwcTreeNode::setParent(tn, parent);
parent = tn;
}
Swc_Tree_Node *tn = SwcTreeNode::makePointer();
SwcTreeNode::copyProperty(SwcTreeNode::firstChild(tree->root()), tn);
SwcTreeNode::setParent(tn, parent);
tree->resortId();
return tree;
}
ZSwcTree* ZSwcGenerator::createSwc(const ZObject3dScan &obj)
{
if (obj.isEmpty()) {
return NULL;
}
ZSwcTree *tree = new ZSwcTree();
tree->forceVirtualRoot();
Swc_Tree_Node *root = tree->root();
size_t stripeNumber = obj.getStripeNumber();
for (size_t i = 0; i < stripeNumber; ++i) {
const ZObject3dStripe &stripe = obj.getStripe(i);
int segNumber = stripe.getSegmentNumber();
int y = stripe.getY();
int z = stripe.getZ();
for (int j = 0; j < segNumber; ++j) {
Swc_Tree_Node *tn =
SwcTreeNode::makePointer(stripe.getSegmentStart(j), y, z, 2.0);
SwcTreeNode::setFirstChild(root, tn);
Swc_Tree_Node *tn2 =
SwcTreeNode::makePointer(stripe.getSegmentEnd(j), y, z, 2.0);
SwcTreeNode::setFirstChild(tn, tn2);
}
}
tree->resortId();
return tree;
}
ZSwcTree* ZSwcGenerator::createSwc(const ZStroke2d &stroke)
{
#if _QT_GUI_USED_
if (stroke.isEmpty()) {
return NULL;
}
double z = stroke.getZ();
double r = stroke.getWidth() / 2.0;
ZSwcTree *tree = new ZSwcTree();
tree->forceVirtualRoot();
Swc_Tree_Node *parent = tree->root();
for (size_t i = 0; i < stroke.getPointNumber(); ++i) {
double x, y;
stroke.getPoint(&x, &y, i);
Swc_Tree_Node *tn = SwcTreeNode::makePointer(x, y, z, r);
SwcTreeNode::setParent(tn, parent);
parent = tn;
}
tree->resortId();
return tree;
#else
return NULL;
#endif
}
Geo3d_Scalar_Field* ZNeuronTracer::extractSeedSkel(const Stack *mask)
{
Stack *skel = Stack_Bwthin(mask, NULL);
/* alloc <dist> */
Stack *dist = Stack_Bwdist_L_U16(mask, NULL, 0);
ZStackProcessor::RemoveBranchPoint(skel, 26);
Stack *skel_proc = C_Stack::clone(skel);
Geo3d_Scalar_Field *field1 = extractLineSeed(skel_proc, dist);
C_Stack::kill(skel_proc);
for (int i = 0; i <field1->size; ++i) {
int x = field1->points[i][0];
int y = field1->points[i][1];
int z = field1->points[i][2];
Set_Stack_Pixel(skel, x, y, z, 0, 0);
}
#ifdef _DEBUG_2
C_Stack::write(GET_TEST_DATA_DIR + "/test.tif", skel);
#endif
Geo3d_Scalar_Field *field2 = extractLineSeed(skel, dist, 0);
Geo3d_Scalar_Field *field = Geo3d_Scalar_Field_Merge(field1, field2, NULL);
Kill_Geo3d_Scalar_Field(field1);
Kill_Geo3d_Scalar_Field(field2);
#ifdef _DEBUG_2
ZSwcTree tree;
tree.forceVirtualRoot();
for (int i = 0; i <field->size; ++i) {
int x = field->points[i][0];
int y = field->points[i][1];
int z = field->points[i][2];
double radius = field->values[i];
SwcTreeNode::setFirstChild(
tree.root(), SwcTreeNode::makePointer(x, y, z, radius));
}
tree.save(GET_TEST_DATA_DIR + "/test.swc");
#endif
/* free <dist> */
C_Stack::kill(dist);
C_Stack::kill(skel);
return field;
}
ZSwcTree* ZStroke2dPlayer::getSwcDecoration() const
{
ZSwcTree *tree = NULL;
ZStroke2d *stroke = getCompleteData();
if (stroke != NULL) {
if (!stroke->isEmpty()) {
tree->forceVirtualRoot();
Swc_Tree_Node *parent = tree->root();
double z = stroke->getZ();
double radius = stroke->getWidth() / 2.0;
for (size_t i = 0; i < stroke->getPointNumber(); ++i) {
double x = 0;
double y = 0;
stroke->getPoint(&x, &y, i);
Swc_Tree_Node *tn = SwcTreeNode::makePointer(x, y, z, radius, parent);
parent = tn;
}
}
}
return tree;
}
ZSwcTree* ZSwcGenerator::createSwc(
const ZObject3d &obj, double radius, int sampleStep)
{
if (obj.isEmpty()) {
return NULL;
}
ZSwcTree *tree = new ZSwcTree();
tree->forceVirtualRoot();
Swc_Tree_Node *parent = tree->root();
for (size_t i = 0; i < obj.size(); i += sampleStep) {
Swc_Tree_Node *tn = SwcTreeNode::makePointer(
obj.getX(i), obj.getY(i), obj.getZ(i), radius);
SwcTreeNode::setId(tn, i + 1);
SwcTreeNode::setFirstChild(parent, tn);
// SwcTreeNode::setParent(tn, parent);
}
// tree->resortId();
tree->setColor(obj.getColor());
return tree;
}
ZSwcTree* ZSwcGenerator::createSurfaceSwc(const ZStack &stack, int sparseLevel)
{
if (stack.kind() != GREY) {
return NULL;
}
ZSwcTree *tree = NULL;
if (stack.hasData()) {
int width = stack.width();
int height = stack.height();
int depth = stack.depth();
int cwidth = width - 1;
int cheight = height - 1;
int cdepth = depth - 1;
const uint8_t* in_array = stack.array8();
int conn = 6;
size_t offset = 0;
int neighbor[26];
int is_in_bound[26];
int n_in_bound;
int count = 0;
tree = new ZSwcTree();
tree->forceVirtualRoot();
Swc_Tree_Node *root = tree->root();
Stack_Neighbor_Offset(conn, width, height, neighbor);
for (int k = 0; k <= cdepth; k++) {
for (int j = 0; j <= cheight; j++) {
for (int i = 0; i <= cwidth; i++) {
// out_array[offset] = 0;
if (in_array[offset] > 0) {
n_in_bound = Stack_Neighbor_Bound_Test_S(
conn, cwidth, cheight, cdepth, i, j, k, is_in_bound);
bool isSurface = false;
if (n_in_bound == conn) {
for (int n = 0; n < n_in_bound; n++) {
if (in_array[offset + neighbor[n]] != in_array[offset]) {
isSurface = true;
break;
}
}
} else {
isSurface = true;
}
if (isSurface) {
if (count++ % sparseLevel == 0) {
SwcTreeNode::makePointer(i + stack.getOffset().getX(),
j + stack.getOffset().getY(),
k + stack.getOffset().getZ(),
sparseLevel * 0.7, root);
}
}
}
offset++;
}
}
}
}
#if 0
Stack *surface = Stack_Perimeter(stack.c_stack(), NULL, 6);
#ifdef _DEBUG_2
C_Stack::write(GET_DATA_DIR + "/test.tif", surface);
#endif
if (surface != NULL) {
tree = new ZSwcTree();
tree->forceVirtualRoot();
Swc_Tree_Node *root = tree->root();
int width = C_Stack::width(surface);
int height = C_Stack::height(surface);
int depth = C_Stack::depth(surface);
size_t offset = 0;
int count = 0;
for (int z = 0; z < depth; ++z) {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
if ((surface->array[offset++]) > 0) {
if (count++ % sparseLevel == 0) {
SwcTreeNode::makePointer(x + stack.getOffset().getX(),
y + stack.getOffset().getY(),
z + stack.getOffset().getZ(),
sparseLevel * 0.7, root);
}
}
}
}
}
C_Stack::kill(surface);
}
#endif
return tree;
}
