Ensure that HyperBox does not produce duplicate intersections

In certain corner cases (literally) two coincident intersections could be
produced when the ray passed through the edge of the box, preventing
intersctions on the opposite side from being produced.

diff --git a/source/geometry/hyperbox.h b/source/geometry/hyperbox.h
index 546ad0ec3984c5b338978c23b37f0c8ea5f97533..b9fad33d620d205f1a5043e002cb88556cbc6e32 100644 (file)
--- a/source/geometry/hyperbox.h
+++ b/source/geometry/hyperbox.h
@@ -112,14 +112,23 @@ inline unsigned HyperBox<T, D>::get_intersections(const Ray<T, D> &ray, SurfaceP
                        {
                                if(points)
                                {
-                                       points[n].position = p;
-                                       points[n].normal = LinAl::Vector<T, D>();
-                                       points[n].normal[i] = j;
-                                       points[n].distance = x;
-                                       points[n].entry = (T(j)*ray.get_direction()[i]<T(0));
-
-                                       if(n==1 && x<points[0].distance)
-                                               std::swap(points[0], points[1]);
+                                       bool entry = (T(j)*ray.get_direction()[i]<T(0));
+                                       unsigned k = 0;
+                                       if(n>0 && entry!=points[0].entry)
+                                       {
+                                               if(entry)
+                                                       points[1] = points[0];
+                                               else
+                                                       ++k;
+                                       }
+                                       if(k<n && entry==points[k].entry)
+                                               --n;
+
+                                       points[k].position = p;
+                                       points[k].normal = LinAl::Vector<T, D>();
+                                       points[k].normal[i] = j;
+                                       points[k].distance = x;
+                                       points[k].entry = (T(j)*ray.get_direction()[i]<T(0));
                                }
 
                                ++n;