void ZSwcNodeObjsModel::setupModelData(ZObjsItem *parent)
{
QList<QVariant> data;
m_typeToRow.clear();
m_swcTreeNodeToRow.clear();
m_swcTreeNodeToType.clear();
m_typeToRow[SwcTreeNode::TERMINAL] = 0;
m_typeToRow[SwcTreeNode::BRANCH_POINT] = 1;
data.clear();
data << "Termini" << "id" << "type" << "radius" << "x" << "y" << "z"
<< "label";
ZObjsItem *terminalItem = new ZObjsItem(data, NULL, parent);
terminalItem->setCheckState(Qt::Checked);
parent->appendChild(terminalItem);
data.clear();
data << "Branch Points" << "id" << "type" << "radius" << "x" << "y" << "z"
<< "label";
ZObjsItem *branchPointItem = new ZObjsItem(data, NULL, parent);
branchPointItem->setCheckState(Qt::Checked);
parent->appendChild(branchPointItem);
int terminalRow = 0;
int branchPointRow = 0;
QList<ZSwcTree*> swcList = m_doc->getSwcList();
for (int i=0; i<swcList.size(); i++) {
data.clear();
ZSwcTree *swcTree = swcList.at(i);
//ZObjsItem *nodeParent = new ZObjsItem(data, swcTree, parent);
//nodeParent->setCheckState(swcTree->isVisible() ? Qt::Checked : Qt::Unchecked);
//nodeParent->setToolTip(QString("source: %1").arg(QString::fromStdString(swcTree->source())));
//parent->appendChild(nodeParent);
swcTree->updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST); //depth first
for (Swc_Tree_Node *tn = swcTree->begin(); tn != swcTree->end(); tn = swcTree->next()) {
if (!SwcTreeNode::isVirtual(tn)) {
data.clear();
data << "" << tn->node.id << tn->node.type << tn->node.d << tn->node.x
<< tn->node.y << tn->node.z << tn->node.label << "";
if (SwcTreeNode::isBranchPoint(tn)) {
m_swcTreeNodeToType[tn] = SwcTreeNode::BRANCH_POINT;
m_swcTreeNodeToRow[tn] = branchPointRow++;
ZObjsItem *node = new ZObjsItem(data, tn, branchPointItem);
branchPointItem->appendChild(node);
} else if (SwcTreeNode::isRoot(tn) || SwcTreeNode::isLeaf(tn)) {
m_swcTreeNodeToType[tn] = SwcTreeNode::TERMINAL;
m_swcTreeNodeToRow[tn] = terminalRow++;
ZObjsItem *node = new ZObjsItem(data, tn, terminalItem);
terminalItem->appendChild(node);
}
}
}
}
}
std::vector<Swc_Tree_Node*> ZSwcRangeAnalyzer::getOutsideNode(
const ZSwcTree &host, const ZSwcTree &targetTree)
{
std::vector<Swc_Tree_Node*> nodeArray;
std::vector<ZEllipsoid> range = computeLayerRange(host);
ZSwcNodeCompositeSelector selector;
for (std::vector<ZEllipsoid>::iterator iter = range.begin();
iter != range.end(); ++iter) {
iter->setCenterX(0);
iter->setCenterY(0);
ZSwcNodeEllipsoidRangeSelector *childSelector =
new ZSwcNodeEllipsoidRangeSelector;
childSelector->setExpandFactor(3.0);
//iter->print();
/*
iter->setSize(iter->getXRadius() + sqrt(iter->getXRadius()),
iter->getYRadius() + sqrt(iter->getYRadius()),
iter->getZRadius() + sqrt(iter->getZRadius()) * 5);
*/
childSelector->setRange(*iter);
selector.addSelector(childSelector);
}
std::vector<ZEllipsoid> range2 = computeLayerRange(targetTree);
std::vector<ZPoint> pointArray = computerLayerCentroid(targetTree);
Swc_Tree_Node bufferNode;
targetTree.updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST);
for (Swc_Tree_Node *tn = targetTree.begin(); tn != NULL;
tn = targetTree.next()) {
if (SwcTreeNode::isRegular(tn)) {
bufferNode = *tn;
for (size_t i = 0; i < range2.size(); ++i) {
if (range2[i].containsPoint(
SwcTreeNode::x(tn), SwcTreeNode::y(tn), SwcTreeNode::z(tn))) {
SwcTreeNode::translate(&bufferNode, -pointArray[i].x(),
-pointArray[i].y(), 0.0);
break;
}
}
if (!selector.isSelected(&bufferNode)) {
nodeArray.push_back(tn);
}
}
}
return nodeArray;
}
std::vector<double> ZSwcLayerShollFeatureAnalyzer::computeFeature(
Swc_Tree_Node *tn)
{
TZ_ASSERT(tn != NULL, "null pointer");
std::vector<double> featureArray(2, 0);
ZSwcTree tree;
tree.setDataFromNodeRoot(tn);
tree.updateIterator(SWC_TREE_ITERATOR_BREADTH_FIRST);
double baseZ = SwcTreeNode::z(tn);
featureArray[0] = baseZ;
Swc_Tree_Node *iter = tree.begin();
//while (SwcTreeNode::isRoot(iter)) {
while (SwcTreeNode::isVirtual(iter)) {
iter = tree.next();
}
double upZ = baseZ - m_layerMargin;
double downZ = baseZ + m_layerMargin;
for (; iter != NULL; iter = iter->next) {
Swc_Tree_Node *parent = iter->parent;
double minZ = iter->node.z;
double maxZ = parent->node.z;
if (minZ > maxZ) {
minZ = parent->node.z;
maxZ = iter->node.z;
}
/*
double r1 = SwcTreeNode::radius(iter);
double r2 = SwcTreeNode::radius(parent);
*/
if (minZ <= downZ && maxZ >= upZ) {
featureArray[1] += 1.0;
}
}
#ifdef _DEBUG_
if (featureArray[1] == 0.0) {
cout << "debug here" << endl;
}
#endif
tree.setData(NULL, ZSwcTree::FREE_WRAPPER);
return featureArray;
}
pair<Swc_Tree_Node*, Swc_Tree_Node*> ZSwcConnector::identifyConnection(
const ZSwcPath &hook, const ZSwcTree &loop)
{
pair<Swc_Tree_Node*, Swc_Tree_Node*> conn;
if (!hook.empty()) {
loop.updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST);
Swc_Tree_Node *head = hook.front();
Swc_Tree_Node *tail = hook.back();
m_dist = Infinity;
for (const Swc_Tree_Node *tn = loop.begin(); tn != NULL; tn = loop.next()) {
if (SwcTreeNode::isRegular(tn)) {
double d = SwcTreeNode::scaledDistance(
head, tn, m_resolution.voxelSizeX(), m_resolution.voxelSizeY(),
m_resolution.voxelSizeZ());
if (d < m_dist) {
m_dist = d;
conn.first = head;
conn.second = const_cast<Swc_Tree_Node*>(tn);
}
if (tail != NULL) {
d = SwcTreeNode::scaledDistance(
tail, tn, m_resolution.voxelSizeX(), m_resolution.voxelSizeY(),
m_resolution.voxelSizeZ());
if (d < m_dist) {
m_dist = d;
conn.first = tail;
conn.second = const_cast<Swc_Tree_Node*>(tn);
}
}
}
}
}
return conn;
}
vector<double> ZSwcShollFeatureAnalyzer::computeFeature(Swc_Tree_Node *tn)
{
vector<SwcNodePair> distanceArray;
vector<double> crossingNumberArray;
ZPoint center(tn->node.x, tn->node.y, tn->node.z);
ZSwcTree sourceTree;
sourceTree.setDataFromNodeRoot(tn);
//cout << sourceTree.data()->root << endl;
sourceTree.updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST, false);
double maxLength = 0.0;
for (Swc_Tree_Node *tn = sourceTree.begin(); tn != sourceTree.end();
tn = sourceTree.next()) {
if (Swc_Tree_Node_Is_Regular(tn) && !Swc_Tree_Node_Is_Root(tn)) {
//Compute the central distances of the current node and its parent
SwcNodePair distancePair;
ZPoint v1(Swc_Tree_Node_X(tn), Swc_Tree_Node_Y(tn),
Swc_Tree_Node_Z(tn));
ZPoint v2(Swc_Tree_Node_X(tn->parent),
Swc_Tree_Node_Y(tn->parent),
Swc_Tree_Node_Z(tn->parent));
double d1 = v1.distanceTo(center);
double d2 = v2.distanceTo(center);
//Make sure that distancePair.first < distancePair.second
if (d1 > d2) {
distancePair.first = d2;
distancePair.second = d1;
distancePair.firstNode = tn->parent;
distancePair.secondNode = tn;
} else {
distancePair.first = d1;
distancePair.second = d2;
distancePair.firstNode = tn;
distancePair.secondNode = tn->parent;
}
//Calculate the distance between v1 and v2
double length = v1.distanceTo(v2);
if (length > maxLength) {
maxLength = length;
}
distanceArray.push_back(distancePair);
}
}
sort(distanceArray.begin(), distanceArray.end(),
SwcNodePairLessThan());
int startIndex = 0;
int endIndex = 0;
int lastIndex = int(distanceArray.size()) - 1;
for (double r = m_shollStart; r <= m_shollEnd; r += m_shollRadius) {
if (startIndex <= lastIndex) {
//Update start index and end index
while (distanceArray[startIndex].first < r - maxLength) {
startIndex++;
if (startIndex > lastIndex) {
break;
}
}
if (endIndex <= lastIndex) {
while (distanceArray[endIndex].first < r) {
endIndex++;
if (endIndex > lastIndex) {
break;
}
}
}
//Crossing test
int crossingNumber = 0;
if (startIndex <= lastIndex) {
for (int i = startIndex; i < endIndex; ++i) {
//If a crossing point is detected
if (distanceArray[i].second >= r) {
crossingNumber += 1.0;
}
}
}
crossingNumberArray.push_back(crossingNumber);
} else {
crossingNumberArray.push_back(0);
}
}
//cout << sourceTree.data()->root << endl;
sourceTree.setData(NULL, ZSwcTree::FREE_WRAPPER);
return crossingNumberArray;
}
ZSwcTreeNodeArray ZSwcNodeDistSelector::select(const ZSwcTree &tree) const
{
tree.setLabel(0);
ZSwcTreeNodeArray nodeArray;
tree.updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST);
Swc_Tree_Node *tn = tree.begin();
if (SwcTreeNode::isVirtual(tn)) {
tn = tree.next();
}
if (SwcTreeNode::isRegular(tn)) {
nodeArray.push_back(tn);
SwcTreeNode::setLabel(tn, 1);
}
for (; tn != NULL; tn = tree.next()) {
double dist = 0.0;
Swc_Tree_Node *parent = tn;
while (parent != NULL) {
dist += SwcTreeNode::length(parent);
if (dist > m_minDistance) {
nodeArray.push_back(tn);
SwcTreeNode::setLabel(tn, 1);
}
parent = SwcTreeNode::parent(parent);
if ((parent == NULL) || SwcTreeNode::label(parent) > 0) {
break;
}
}
}
#if 0
#ifdef _DEBUG_2
tree.print();
#endif
tree.updateIterator(SWC_TREE_ITERATOR_LEAF);
for (Swc_Tree_Node *tn = tree.begin(); tn != NULL; tn = tree.next()) {
nodeArray.push_back(tn);
SwcTreeNode::setLabel(tn, 2);
double dist = 0;
Swc_Tree_Node *parent = SwcTreeNode::parent(tn);
if (SwcTreeNode::label(parent) > 0 || SwcTreeNode::isVirtual(parent)) {
continue;
}
dist += SwcTreeNode::length(tn);
while (SwcTreeNode::isRegular(parent)) {
SwcTreeNode::setLabel(parent, 1);
if (dist >= m_minDistance) {
nodeArray.push_back(parent);
dist = 0;
SwcTreeNode::setLabel(parent, 2);
}
dist += SwcTreeNode::length(parent);
parent = SwcTreeNode::parent(parent);
if (SwcTreeNode::label(parent) > 0) {
break;
}
}
}
#endif
return nodeArray;
}
