C++ ZSwcTree::updateIterator方法代码示例

pair<Swc_Tree_Node*, Swc_Tree_Node*> ZSwcConnector::identifyConnection(
      const ZSwcTree &hook, const ZSwcTree &loop)
{
  pair<Swc_Tree_Node*, Swc_Tree_Node*> conn;

  loop.updateIterator(SWC_TREE_ITERATOR_DEPTH_FIRST);
  m_dist = Infinity;

  ZSwcTree::TerminalIterator hookIter(&hook);

  ZSwcTree::DepthFirstIterator loopIter(&loop);
  while (loopIter.hasNext()) {
    Swc_Tree_Node *tn = loopIter.next();
    if (SwcTreeNode::isRegular(tn)) {
      hookIter.begin();
      while (hookIter.hasNext()) {
        Swc_Tree_Node *head = hookIter.next();
        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);
        }
      }
    }
  }

  return conn;
}

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