Exemplo n.º 1
0
void TreeFastCache::addPointRecursive(const double pt[3], const double color[3], double point_accuracy)
{
  NodeHandle* nh = top().nh;
  assert(nh);
  double node_cell_size = nh->getNodeGeometry().getSize();

  // adds point to empty node
  if (nh->isEmpty() && point_accuracy >= node_cell_size / BITS_D)
  {
    nh->setPoint(pt, color);
    return;
  }
    
  // reached maximum resultion of the tree
  if (node_cell_size < tree.getMinCellSize())
  {
    nh->addPoint(pt, color);
    return;
  }


  // this node is a leaf, and we need to copy the original point one level down
  if (!nh->isEmpty() && nh->isLeaf())
  {
    // Determines which child the point should be added to.
    uint8_t original_child = nh->getChildForNodePoint();
    NodeHandle new_leaf;
    tree.createChildNode(*nh, original_child, new_leaf);

    nh->getNode()->copyToChildNode(original_child, new_leaf.getNode());
    tree.releaseNode(new_leaf);
  }

  // Gets the child node to recurse on.
  uint8_t new_child = nh->getNodeGeometry().whichChild(pt);
  NodeHandle* new_child_nh = NULL;
  if (nh->hasChild(new_child)) {
    new_child_nh = tree.getChildNode(*nh, new_child);
    new_child_nh->waitUntilLoaded();
  }
  else {
    new_child_nh = tree.createChildNode(*nh, new_child);
  }

  // recursion to add point to child
  push(NodeCache(new_child_nh));

  addPointRecursive(pt, color, point_accuracy);
}
Exemplo n.º 2
0
void addPointRecursive(MegaTree& tree, NodeHandle& node, 
                       const double* pt, const double* color,
                       double point_accuracy)
{
  //printf("Adding point %f %f %f to node %s\n", pt[0], pt[1], pt[2], node.toString().c_str());
  double node_cell_size = node.getNodeGeometry().getSize();

  // adds point to empty node
  if (node.isEmpty() && point_accuracy >= node_cell_size / BITS_D)
  {
    node.setPoint(pt, color);
    return;
  }
    
  // reached maximum resultion of the tree
  if (node_cell_size < tree.getMinCellSize())
  {
    node.addPoint(pt, color);
    return;
  }


  // this node is a leaf, and we need to copy the original point one level down
  if (!node.isEmpty() && node.isLeaf())
  {
    // Determines which child the point should be added to.
    uint8_t original_child = node.getChildForNodePoint();

    //create_leaf_timer.start();
    NodeHandle new_leaf;
    tree.createChildNode(node, original_child, new_leaf);
    //create_leaf_timer.pause();

    node.getNode()->copyToChildNode(original_child, new_leaf.getNode());
    tree.releaseNode(new_leaf);
  }

  // Gets the child node to recurse on.
  uint8_t new_child = node.getNodeGeometry().whichChild(pt);
  NodeHandle new_child_node;
  if (node.hasChild(new_child)) {
    //getnode_timer.start();
    tree.getChildNode(node, new_child, new_child_node);
    new_child_node.waitUntilLoaded();
    //getnode_timer.pause();
  }
  else {
    //create_node_timer.start();
    tree.createChildNode(node, new_child, new_child_node);
    //create_node_timer.pause();
  }

  // recursion to add point to child
  addPointRecursive(tree, new_child_node, pt, color, point_accuracy);

  tree.releaseNode(new_child_node);

  // Re-computes the summary point.
  MegaTree::ChildIterator it(tree, node, new_child_node.getNodeFile());
  node.copyFromChildNodes(it.getAllChildren());
}