Designing for floating point error

Question

Hello,
I am stuck with floating point errors and I'm not sure what to do. Specifically, to determine if a point is inside of a triangle, or if it is on the exact edge of the triangle. I use three cross products with the edge as one vector and the other vector is from the edge start to the query point.
The theory says that if the cross product is 0 then the point is directly on the line. If the cross product is <0, then the point is inside the triangle. If >0, then the point is outside the triangle.
To account for the floating point error I was running into, I changed it from =0 to abs(cross_product)<1e-6.
The trouble is, I run into cases where the algorithm is wrong and fails because there is a point which is classified as being on the edge of the triangle which isn't.
I'm not really sure how to handle this.
Thanks,
Eric

Answer 1

So, I changed epsilon from 1e-6 to 1e-10 and it seems to work better (I am using doubles btw). However, that doesn't really solve the problem, it just buries it deeper. I'm interested in how actual commercial applications (such as video games or robots) deal with this issue. Obviously you don't see them giving you an error every time a floating point error messes something up. I think the issue here is that I am using data gathered from physical sensors, meaning the inputs can be arbitrarily close to each other. I am worried though that if I round the inputs, that I will get different data points with the exact same x and y value, and I'm not sure how the geometry algorithms will handle that. Also, I am creating a global navigation mesh of triangles with this data. Floating point errors that are not accounted for correctly lead to triangles inside one another (as opposed to adjacent to each other), which damages the integrity of the entire mesh, as its hard to get your program to fix its own mistake.
FYI:
I am running java 1.6.0_20 in Eclipse Helios with Ubuntu 10.04x64
Here is some code that didn't work using 1e-6 for delta. The test point new Point(-294.18294451166435,-25.496614108304477), is outside the triangle, but because of the delta choice it is seen as on the edge:
class Point
     double x,y;
class Edge
     Point start, end;
class Triangle
     Edge[] edges;
     public Point[] getOrderedPoints() throws Exception{
          Point[] points = new Point[3];
          points[0]=edges[0].getStart();
          points[1]=edges[0].getEnd();
          if (edges[1].getStart().equals(points[0]) || edges[1].getStart().equals(points[1]))
               points[2]=edges[1].getEnd();
          else if (edges[1].getEnd().equals(points[0]) || edges[1].getEnd().equals(points[1]))
               points[2]=edges[1].getStart();
          else
               throw new Exception("MalformedTriangleException\n"+this.print());
          orderNodes(points);
          return points;
        /** Orders node1 node2 and node3 in clockwise order, more specifically
      * node1 is swapped with node2 if doing so will order the nodes clockwise
      * with respect to the other nodes.
      * Does not modify node1, node2, or node3; Modifies only the nodes reference
      * Note: "order" of nodes 1, 2, and 3 is clockwise when the path from point
      * 1 to 2 to 3 back to 1 travels clockwise on the circumcircle of points 1,
      * 2, and 3.
     private void orderNodes(Point[] points){
          //the K component (z axis) of the cross product a x b
          double xProductK = crossProduct(points[0],points[0], points[1], points[2]);
          /*        (3)
           *          +
           *        ^
           *      B
           * (1)+             + (2)
           *       ------A-->
           * Graphical representation of vector A and B. 1, 2, and 3 are not in
           * clockwise order, and the x product of A and B is positive.
          if(xProductK > 0)
               //the cross product is positive so B is oriented as such with
               //respect to A and 1, 2, 3 are not clockwise in order.
               //swapping any 2 points in a triangle changes its "clockwise order"
               Point temp = points[0];
               points[0] = points[1];
               points[1] = temp;
class TriangleTest
     private double delta = 1e-6;
     public static void main(String[] args)  {
                Point a = new Point(-294.183483785282, -25.498196740397056);
          Point b = new Point(-294.18345625812026, -25.49859505161433);
          Point c = new Point(-303.88217906116796, -63.04183512930035);
          Edge aa = new Edge (a, b);
          Edge bb = new Edge (c, a);
          Edge cc = new Edge (b, c);
          Triangle aaa = new Triangle(aa, bb, cc);
          Point point = new Point(-294.18294451166435,-25.496614108304477);
          System.out.println(aaa.enclosesPointDetailed(point));
      * Check if a point is inside this triangle
      * @param point The test point
      * @return     1 if the point is inside the triangle, 0 if the point is on a triangle, -1 if the point is not is the triangle
      * @throws MalformedTriangleException
     public int enclosesPointDetailed(LocalPose point, boolean verbose) throws Exception
          Point[] points = getOrderedPoints();          
          int cp1 = crossProduct(points[0], points[0], points[1], point);
          int cp2 = crossProduct(points[1], points[1], points[2], point);
          int cp3 = crossProduct(points[2], points[2], points[0], point);
          if (cp1 < 0 && cp2 <0  && cp3 <0)
               return 1;
          else if (cp1 <=0 && cp2 <=0  && cp3 <=0)
               return 0;
          else
               return -1;
         public static int crossProduct(Point start1, Point start2, Point end1, POint end2){
          double crossProduct = (end1.getX()-start1.getX())*(end2.getY()-start2.getY())-(end1.getY()-start1.getY())*(end2.getX()-start2.getX());
          if (crossProduct>floatingPointDelta){
               return 1;
          else if (Math.abs(crossProduct)<floatingPointDelta){
               return 0;
          else{
               return -1;
}