Traversal a KDTree - c++

Question

I have some problem with my render, when I try to render a scene.
This is my traversal algorithm:
bool KDTree::traverse(Ray &ray, Node &node, double &tMin, double &tMax, double &tNear, double &u, double &v, Triangle* &hitObject)
{
if(node.tris.size() == 0) return 0;
bool current = false;
//bool intersected = false;
if(!node.isLeaf)
{
int axis = node.split_axis;
double tSplit = (node.split_pos - ray.orig[axis]) / ray.dir[axis];
Node* nearNode = ray.orig[axis] < node.split_pos ? node.leftNode : node.rightNode;
Node* farNode = ray.orig[axis] < node.split_pos ? node.rightNode : node.leftNode;
if (tSplit > tMax)
return traverse(ray, *nearNode , tMin, tMax, tNear, u, v, hitObject);//case A
else if (tSplit < tMin)
{
if(tSplit>0)
return traverse(ray, *farNode, tMin, tMax, tNear, u, v, hitObject);//case B
else if(tSplit<0)
return traverse(ray, *nearNode, tMin, tMax, tNear, u, v, hitObject);//case C
else
{//tSplit==0
if(ray.dir[axis]<0)
return traverse(ray, *farNode, tMin, tMax, tNear, u, v, hitObject);//case D
else
return traverse(ray, *nearNode, tMin, tMax, tNear, u, v, hitObject);//case E
}
}
else
{
if(tSplit>0)
{//case F
current = traverse(ray, *nearNode, tMin, tSplit, tNear, u, v, hitObject);
if (current != false)
return current;
else
return traverse(ray, *farNode, tSplit, tMax, tNear, u, v, hitObject);
}
else
{
return traverse(ray, *nearNode,tSplit, tMax, tNear, u, v, hitObject);//case G
}
}
}
else
{
tNear = 9999999;
for(unsigned int i = 0; i < node.tris.size(); ++i)
{
double t = 9999999;
if(node.tris[i]->intersect(ray, t, u, v) && t < tNear)
{
hitObject = node.tris[i];
tNear = t;
}
}
return (hitObject != nullptr);
}
}
And this is my build algorithm:
void KDTree::buildkdtree(Node &node)
{
std::cout << "stò inizializzando il nodo di profondità: " << node.depth << std::endl;
if(node.tris.size() <= 30 || node.depth >= 15)
{
std::cout << "ho creato una foglia di livello: " << node.depth << " , con " << node.tris.size() << " triangoli" << std::endl;
node.isLeaf = true;
return;
}
int axis = (node.depth % 3);
std::vector<Vec3d> midPoints;
for(unsigned int i = 0; i < node.tris.size(); ++i)
{
midPoints.push_back(node.tris[i]->getMidPoint());
}
std::vector<double> mid;
node.split_axis = axis;
node.rightNode = new struct Node;
node.leftNode = new struct Node;
double max, min, med;
switch(node.split_axis)
{
case(0):
std::cout << "splitto su x" << std::endl;
for(unsigned int i = 0; i < midPoints.size(); ++i)
{
mid.push_back(midPoints[i].x);
}
std::sort(mid.begin(), mid.end());
if(mid.size() % 2 == 0)
med = (mid[mid.size()/2 - 1] + mid[mid.size()/2]) / 2;
else
med = mid[mid.size()/2];
node.split_pos = med;
std::cout << "l'intervallo e': (" << node.bbox->xMin << " ," << node.bbox->xMax << ")\n";
std::cout << "split_pos = " << node.split_pos << std::endl;
node.rightNode->bbox = new Bbox(node.bbox->xMax, node.split_pos, node.bbox->yMax, node.bbox->yMin, node.bbox->zMax, node.bbox->zMin);
node.leftNode->bbox = new Bbox(node.split_pos, node.bbox->xMin, node.bbox->yMax, node.bbox->yMin, node.bbox->zMax, node.bbox->zMin);
for(unsigned int i = 0; i < node.tris.size(); ++i)
{
node.tris[i]->getExtreme(max, min, axis);
if(min <= node.split_pos)
node.leftNode->tris.push_back(node.tris[i]);
if(max >= node.split_pos)
node.rightNode->tris.push_back(node.tris[i]);
}
break;
case(1):
std::cout << "splitto su y" << std::endl;
for(unsigned int i = 0; i < midPoints.size(); ++i)
{
mid.push_back(midPoints[i].y);
}
std::sort(mid.begin(), mid.end());
if(mid.size() % 2 == 0)
med = (mid[mid.size()/2 - 1] + mid[mid.size()/2]) / 2;
else
med = mid[mid.size()/2];
node.split_pos = med;
std::cout << "l'intervallo e': (" << node.bbox->yMin << " ," << node.bbox->yMax << ")\n";
std::cout << "split_pos = " << node.split_pos << std::endl;
node.rightNode->bbox = new Bbox(node.bbox->xMax, node.bbox->xMin, node.split_pos, node.bbox->yMin, node.bbox->zMax, node.bbox->zMin);
node.leftNode->bbox = new Bbox(node.bbox->xMax, node.bbox->xMin, node.bbox->yMax, node.split_pos, node.bbox->zMax, node.bbox->zMin);
for(unsigned int i = 0; i < node.tris.size(); ++i)
{
node.tris[i]->getExtreme(max, min, axis);
if(min <= node.split_pos)
node.leftNode->tris.push_back(node.tris[i]);
if(max >= node.split_pos)
node.rightNode->tris.push_back(node.tris[i]);
}
break;
case(2):
std::cout << "splitto su z" << std::endl;
for(unsigned int i = 0; i < midPoints.size(); ++i)
{
mid.push_back(midPoints[i].z);
}
std::sort(mid.begin(), mid.end());
if(mid.size() % 2 == 0)
med = (mid[mid.size()/2 - 1] + mid[mid.size()/2]) / 2;
else
med = mid[mid.size()/2];
node.split_pos = med;
std::cout << "l'intervallo e': (" << node.bbox->zMin << " ," << node.bbox->zMax << ")\n";
std::cout << "split_pos = " << node.split_pos << std::endl;
node.rightNode->bbox = new Bbox(node.bbox->xMax, node.bbox->xMin, node.bbox->yMax, node.bbox->yMin, node.split_pos, node.bbox->zMin);
node.leftNode->bbox = new Bbox(node.bbox->xMax, node.bbox->xMin, node.bbox->yMax, node.bbox->yMin, node.bbox->zMax, node.split_pos);
for(unsigned int i = 0; i < node.tris.size(); ++i)
{
node.tris[i]->getExtreme(max, min, axis);
if(min <= node.split_pos)
node.leftNode->tris.push_back(node.tris[i]);
if(max >= node.split_pos)
node.rightNode->tris.push_back(node.tris[i]);
}
break;
default:
std::cout << "Errore, non ho uno dei tre assi" << std::endl;
break;
}
std::cout << "i " << node.tris.size() << " triangoli del padre sono stati divisi così\n";
std::cout << node.rightNode->tris.size() << " nel nodo di destra\n";
std::cout << node.leftNode->tris.size() << " nel nodo di sinistra\n" << std::endl;
node.rightNode->depth = node.depth + 1;
node.leftNode->depth = node.depth + 1;
std::cout << "sto processando figlio di destra del nodo di profondità: " << node.depth << std::endl;
buildkdtree(*(node.rightNode));
std::cout << "sto processando figlio di sinistra del nodo di profondità: " << node.depth << std::endl;
buildkdtree(*(node.leftNode));}
Someone can help me?
PS: this is the image I get:

Answer 1

I had this same issue when writing my ray tracer. The problem could actually be in your build code or in your traversal code. Consider that if you build a bad tree, a "correct" traversal will also result in artifacts.
I found the issue by building a simple OpenGL renderer on top of my ray tracer. This involved the following:
Create an OpenGL rendering instance and feed it your scene & camera info. It looks like all you have are triangles and a light or two, so this should be pretty easy. OpenGL renders a good-enough approximation for our purposes.
Create an output window using GLUT and display the OpenGL output in a continuous rendering loop. Modify the output window such that it accepts user input (keyboard, mouse, whatever) to move the camera's position and direction around.
Modify your OpenGL renderer to also draw all the KDNode bounding boxes. Make the bounding boxes semi-transparent.
Create a second window that contains a tree control. Bind your KDTree to the tree control such that every element in the KDTree corresponds to exactly one node in your tree control. You should be able to visually inspect your KDTree now.
Modify the tree window such it accepts user input to select, expand, and collapse nodes.
Modify your OpenGL renderer such that the currently selected treenode's (KDNode's) bounding box, and the triangles assigned to that KDNode, are drawn in a special color.
Now, by selecting a node in the tree window, you can see the associated KDNode's bounding boxes, what triangles are assigned to the KDNode, and you can move the camera around to verify that the triangles you think are assigned to the KDNode are actually assigned to the node.
When I first did this, I was taken aback by how different my mental model of the tree was from what my algorithm was actually creating. With this tool, you ought to be able to verify that your build code is doing what you think it's doing. You can also use it to fine-tune your build code's parameters to get a more efficient tree.
Your output window ought to look something like this (courtesy Michele Bosi):
EDIT: Another example courtesy of Yining Karl Li
EDIT: A third example courtesy of Apollo Ellis