commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r1131127 [3/3] - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/geometry/euclidean/oned/ main/java/org/apache/commons/math/geometry/euclidean/threed/ main/java/org/apache/commons/math/geometry/euclidean/twod/ test/java...
Date Fri, 03 Jun 2011 18:08:13 GMT
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/geometry/euclidean/twod/PolygonsSetTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/geometry/euclidean/twod/PolygonsSetTest.java?rev=1131127&r1=1131126&r2=1131127&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/geometry/euclidean/twod/PolygonsSetTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/geometry/euclidean/twod/PolygonsSetTest.java Fri Jun  3 18:08:12 2011
@@ -21,12 +21,13 @@ import java.util.List;
 
 import org.apache.commons.math.geometry.euclidean.oned.Interval;
 import org.apache.commons.math.geometry.euclidean.oned.IntervalsSet;
-import org.apache.commons.math.geometry.euclidean.oned.Point1D;
+import org.apache.commons.math.geometry.euclidean.oned.Vector1D;
 import org.apache.commons.math.geometry.euclidean.twod.Line;
-import org.apache.commons.math.geometry.euclidean.twod.Point2D;
+import org.apache.commons.math.geometry.euclidean.twod.Vector2D;
 import org.apache.commons.math.geometry.euclidean.twod.PolygonsSet;
 import org.apache.commons.math.geometry.partitioning.BSPTree;
 import org.apache.commons.math.geometry.partitioning.Region;
+import org.apache.commons.math.geometry.partitioning.RegionFactory;
 import org.apache.commons.math.geometry.partitioning.SubHyperplane;
 import org.apache.commons.math.util.FastMath;
 import org.junit.Assert;
@@ -36,59 +37,59 @@ public class PolygonsSetTest {
 
     @Test
     public void testSimplyConnected() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(36.0, 22.0),
-                new Point2D(39.0, 32.0),
-                new Point2D(19.0, 32.0),
-                new Point2D( 6.0, 16.0),
-                new Point2D(31.0, 10.0),
-                new Point2D(42.0, 16.0),
-                new Point2D(34.0, 20.0),
-                new Point2D(29.0, 19.0),
-                new Point2D(23.0, 22.0),
-                new Point2D(33.0, 25.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(36.0, 22.0),
+                new Vector2D(39.0, 32.0),
+                new Vector2D(19.0, 32.0),
+                new Vector2D( 6.0, 16.0),
+                new Vector2D(31.0, 10.0),
+                new Vector2D(42.0, 16.0),
+                new Vector2D(34.0, 20.0),
+                new Vector2D(29.0, 19.0),
+                new Vector2D(23.0, 22.0),
+                new Vector2D(33.0, 25.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
-        Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Point2D(50.0, 30.0)));
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(30.0, 15.0),
-            new Point2D(15.0, 20.0),
-            new Point2D(24.0, 25.0),
-            new Point2D(35.0, 30.0),
-            new Point2D(19.0, 17.0)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(50.0, 30.0),
-            new Point2D(30.0, 35.0),
-            new Point2D(10.0, 25.0),
-            new Point2D(10.0, 10.0),
-            new Point2D(40.0, 10.0),
-            new Point2D(50.0, 15.0),
-            new Point2D(30.0, 22.0)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(30.0, 32.0),
-            new Point2D(34.0, 20.0)
+        Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Vector2D(50.0, 30.0)));
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(30.0, 15.0),
+            new Vector2D(15.0, 20.0),
+            new Vector2D(24.0, 25.0),
+            new Vector2D(35.0, 30.0),
+            new Vector2D(19.0, 17.0)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(50.0, 30.0),
+            new Vector2D(30.0, 35.0),
+            new Vector2D(10.0, 25.0),
+            new Vector2D(10.0, 10.0),
+            new Vector2D(40.0, 10.0),
+            new Vector2D(50.0, 15.0),
+            new Vector2D(30.0, 22.0)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(30.0, 32.0),
+            new Vector2D(34.0, 20.0)
         });
         checkVertices(set.getVertices(), vertices);
     }
 
     @Test
     public void testStair() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0, 0.0),
-                new Point2D( 0.0, 2.0),
-                new Point2D(-0.1, 2.0),
-                new Point2D(-0.1, 1.0),
-                new Point2D(-0.3, 1.0),
-                new Point2D(-0.3, 1.5),
-                new Point2D(-1.3, 1.5),
-                new Point2D(-1.3, 2.0),
-                new Point2D(-1.8, 2.0),
-                new Point2D(-1.8 - 1.0 / FastMath.sqrt(2.0),
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0, 0.0),
+                new Vector2D( 0.0, 2.0),
+                new Vector2D(-0.1, 2.0),
+                new Vector2D(-0.1, 1.0),
+                new Vector2D(-0.3, 1.0),
+                new Vector2D(-0.3, 1.5),
+                new Vector2D(-1.3, 1.5),
+                new Vector2D(-1.3, 2.0),
+                new Vector2D(-1.8, 2.0),
+                new Vector2D(-1.8 - 1.0 / FastMath.sqrt(2.0),
                             2.0 - 1.0 / FastMath.sqrt(2.0))
             }
         };
@@ -102,91 +103,91 @@ public class PolygonsSetTest {
 
     @Test
     public void testHole() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(0.0, 0.0),
-                new Point2D(3.0, 0.0),
-                new Point2D(3.0, 3.0),
-                new Point2D(0.0, 3.0)
-            }, new Point2D[] {
-                new Point2D(1.0, 2.0),
-                new Point2D(2.0, 2.0),
-                new Point2D(2.0, 1.0),
-                new Point2D(1.0, 1.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(0.0, 0.0),
+                new Vector2D(3.0, 0.0),
+                new Vector2D(3.0, 3.0),
+                new Vector2D(0.0, 3.0)
+            }, new Vector2D[] {
+                new Vector2D(1.0, 2.0),
+                new Vector2D(2.0, 2.0),
+                new Vector2D(2.0, 1.0),
+                new Vector2D(1.0, 1.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(0.5, 0.5),
-            new Point2D(1.5, 0.5),
-            new Point2D(2.5, 0.5),
-            new Point2D(0.5, 1.5),
-            new Point2D(2.5, 1.5),
-            new Point2D(0.5, 2.5),
-            new Point2D(1.5, 2.5),
-            new Point2D(2.5, 2.5),
-            new Point2D(0.5, 1.0)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(1.5, 1.5),
-            new Point2D(3.5, 1.0),
-            new Point2D(4.0, 1.5),
-            new Point2D(6.0, 6.0)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(1.5, 0.0),
-            new Point2D(1.5, 1.0),
-            new Point2D(1.5, 2.0),
-            new Point2D(1.5, 3.0),
-            new Point2D(3.0, 3.0)
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(0.5, 0.5),
+            new Vector2D(1.5, 0.5),
+            new Vector2D(2.5, 0.5),
+            new Vector2D(0.5, 1.5),
+            new Vector2D(2.5, 1.5),
+            new Vector2D(0.5, 2.5),
+            new Vector2D(1.5, 2.5),
+            new Vector2D(2.5, 2.5),
+            new Vector2D(0.5, 1.0)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(1.5, 1.5),
+            new Vector2D(3.5, 1.0),
+            new Vector2D(4.0, 1.5),
+            new Vector2D(6.0, 6.0)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(1.5, 0.0),
+            new Vector2D(1.5, 1.0),
+            new Vector2D(1.5, 2.0),
+            new Vector2D(1.5, 3.0),
+            new Vector2D(3.0, 3.0)
         });
         checkVertices(set.getVertices(), vertices);
     }
 
     @Test
     public void testDisjointPolygons() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(0.0, 1.0),
-                new Point2D(2.0, 1.0),
-                new Point2D(1.0, 2.0)
-            }, new Point2D[] {
-                new Point2D(4.0, 0.0),
-                new Point2D(5.0, 1.0),
-                new Point2D(3.0, 1.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(0.0, 1.0),
+                new Vector2D(2.0, 1.0),
+                new Vector2D(1.0, 2.0)
+            }, new Vector2D[] {
+                new Vector2D(4.0, 0.0),
+                new Vector2D(5.0, 1.0),
+                new Vector2D(3.0, 1.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
-        Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Point2D(1.0, 1.5)));
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(1.0, 1.5),
-            new Point2D(4.5, 0.8)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(1.0, 0.0),
-            new Point2D(3.5, 1.2),
-            new Point2D(2.5, 1.0),
-            new Point2D(3.0, 4.0)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(3.5, 0.5),
-            new Point2D(0.0, 1.0)
+        Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Vector2D(1.0, 1.5)));
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(1.0, 1.5),
+            new Vector2D(4.5, 0.8)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(1.0, 0.0),
+            new Vector2D(3.5, 1.2),
+            new Vector2D(2.5, 1.0),
+            new Vector2D(3.0, 4.0)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(3.5, 0.5),
+            new Vector2D(0.0, 1.0)
         });
         checkVertices(set.getVertices(), vertices);
     }
 
     @Test
     public void testOppositeHyperplanes() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(1.0, 0.0),
-                new Point2D(2.0, 1.0),
-                new Point2D(3.0, 1.0),
-                new Point2D(2.0, 2.0),
-                new Point2D(1.0, 1.0),
-                new Point2D(0.0, 1.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(1.0, 0.0),
+                new Vector2D(2.0, 1.0),
+                new Vector2D(3.0, 1.0),
+                new Vector2D(2.0, 2.0),
+                new Vector2D(1.0, 1.0),
+                new Vector2D(0.0, 1.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
@@ -195,16 +196,16 @@ public class PolygonsSetTest {
 
     @Test
     public void testSingularPoint() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 1.0,  0.0),
-                new Point2D( 1.0,  1.0),
-                new Point2D( 0.0,  1.0),
-                new Point2D( 0.0,  0.0),
-                new Point2D(-1.0,  0.0),
-                new Point2D(-1.0, -1.0),
-                new Point2D( 0.0, -1.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 1.0,  0.0),
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 0.0,  1.0),
+                new Vector2D( 0.0,  0.0),
+                new Vector2D(-1.0,  0.0),
+                new Vector2D(-1.0, -1.0),
+                new Vector2D( 0.0, -1.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
@@ -213,48 +214,48 @@ public class PolygonsSetTest {
 
     @Test
     public void testLineIntersection() {
-        Point2D[][] vertices = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0),
-                new Point2D( 1.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        Vector2D[][] vertices = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0),
+                new Vector2D( 1.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             }
         };
         PolygonsSet set = buildSet(vertices);
 
-        Line l1 = new Line(new Point2D(-1.5, 0.0), FastMath.PI / 4);
-        SubHyperplane s1 = set.intersection(new SubHyperplane(l1));
+        Line l1 = new Line(new Vector2D(-1.5, 0.0), FastMath.PI / 4);
+        SubLine s1 = (SubLine) set.intersection(l1.wholeHyperplane());
         List<Interval> i1 = ((IntervalsSet) s1.getRemainingRegion()).asList();
         Assert.assertEquals(2, i1.size());
         Interval v10 = (Interval) i1.get(0);
-        Point2D p10Lower = (Point2D) l1.toSpace(new Point1D(v10.getLower()));
+        Vector2D p10Lower = (Vector2D) l1.toSpace(new Vector1D(v10.getLower()));
         Assert.assertEquals(0.0, p10Lower.getX(), 1.0e-10);
         Assert.assertEquals(1.5, p10Lower.getY(), 1.0e-10);
-        Point2D p10Upper = (Point2D) l1.toSpace(new Point1D(v10.getUpper()));
+        Vector2D p10Upper = (Vector2D) l1.toSpace(new Vector1D(v10.getUpper()));
         Assert.assertEquals(0.5, p10Upper.getX(), 1.0e-10);
         Assert.assertEquals(2.0, p10Upper.getY(), 1.0e-10);
         Interval v11 = (Interval) i1.get(1);
-        Point2D p11Lower = (Point2D) l1.toSpace(new Point1D(v11.getLower()));
+        Vector2D p11Lower = (Vector2D) l1.toSpace(new Vector1D(v11.getLower()));
         Assert.assertEquals(1.0, p11Lower.getX(), 1.0e-10);
         Assert.assertEquals(2.5, p11Lower.getY(), 1.0e-10);
-        Point2D p11Upper = (Point2D) l1.toSpace(new Point1D(v11.getUpper()));
+        Vector2D p11Upper = (Vector2D) l1.toSpace(new Vector1D(v11.getUpper()));
         Assert.assertEquals(1.5, p11Upper.getX(), 1.0e-10);
         Assert.assertEquals(3.0, p11Upper.getY(), 1.0e-10);
 
-        Line l2 = new Line(new Point2D(-1.0, 2.0), 0);
-        SubHyperplane s2 = set.intersection(new SubHyperplane(l2));
+        Line l2 = new Line(new Vector2D(-1.0, 2.0), 0);
+        SubLine s2 = (SubLine) set.intersection(l2.wholeHyperplane());
         List<Interval> i2 = ((IntervalsSet) s2.getRemainingRegion()).asList();
         Assert.assertEquals(1, i2.size());
         Interval v20 = (Interval) i2.get(0);
-        Point2D p20Lower = (Point2D) l2.toSpace(new Point1D(v20.getLower()));
+        Vector2D p20Lower = (Vector2D) l2.toSpace(new Vector1D(v20.getLower()));
         Assert.assertEquals(1.0, p20Lower.getX(), 1.0e-10);
         Assert.assertEquals(2.0, p20Lower.getY(), 1.0e-10);
-        Point2D p20Upper = (Point2D) l2.toSpace(new Point1D(v20.getUpper()));
+        Vector2D p20Upper = (Vector2D) l2.toSpace(new Vector1D(v20.getUpper()));
         Assert.assertEquals(3.0, p20Upper.getX(), 1.0e-10);
         Assert.assertEquals(2.0, p20Upper.getY(), 1.0e-10);
 
@@ -262,37 +263,38 @@ public class PolygonsSetTest {
 
     @Test
     public void testUnlimitedSubHyperplane() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(0.0, 0.0),
-                new Point2D(4.0, 0.0),
-                new Point2D(1.4, 1.5),
-                new Point2D(0.0, 3.5)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(0.0, 0.0),
+                new Vector2D(4.0, 0.0),
+                new Vector2D(1.4, 1.5),
+                new Vector2D(0.0, 3.5)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D(1.4,  0.2),
-                new Point2D(2.8, -1.2),
-                new Point2D(2.5,  0.6)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(1.4,  0.2),
+                new Vector2D(2.8, -1.2),
+                new Vector2D(2.5,  0.6)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
 
-        PolygonsSet set = (PolygonsSet) Region.union(set1.copySelf(),
-                                                     set2.copySelf());
+        PolygonsSet set =
+            (PolygonsSet) new RegionFactory<Euclidean2D>().union(set1.copySelf(),
+                                                                 set2.copySelf());
         checkVertices(set1.getVertices(), vertices1);
         checkVertices(set2.getVertices(), vertices2);
-        checkVertices(set.getVertices(), new Point2D[][] {
-            new Point2D[] {
-                new Point2D(0.0,  0.0),
-                new Point2D(1.6,  0.0),
-                new Point2D(2.8, -1.2),
-                new Point2D(2.6,  0.0),
-                new Point2D(4.0,  0.0),
-                new Point2D(1.4,  1.5),
-                new Point2D(0.0,  3.5)
+        checkVertices(set.getVertices(), new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(0.0,  0.0),
+                new Vector2D(1.6,  0.0),
+                new Vector2D(2.8, -1.2),
+                new Vector2D(2.6,  0.0),
+                new Vector2D(4.0,  0.0),
+                new Vector2D(1.4,  1.5),
+                new Vector2D(0.0,  3.5)
             }
         });
 
@@ -300,306 +302,306 @@ public class PolygonsSetTest {
 
     @Test
     public void testUnion() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
-        PolygonsSet set  = (PolygonsSet) Region.union(set1.copySelf(),
-                                                      set2.copySelf());
+        PolygonsSet set  = (PolygonsSet) new RegionFactory<Euclidean2D>().union(set1.copySelf(),
+                                                                                set2.copySelf());
         checkVertices(set1.getVertices(), vertices1);
         checkVertices(set2.getVertices(), vertices2);
-        checkVertices(set.getVertices(), new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0),
-                new Point2D( 1.0,  2.0),
-                new Point2D( 0.0,  2.0)
-            }
-        });
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(0.5, 0.5),
-            new Point2D(2.0, 2.0),
-            new Point2D(2.5, 2.5),
-            new Point2D(0.5, 1.5),
-            new Point2D(1.5, 1.5),
-            new Point2D(1.5, 0.5),
-            new Point2D(1.5, 2.5),
-            new Point2D(2.5, 1.5),
-            new Point2D(2.5, 2.5)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(-0.5, 0.5),
-            new Point2D( 0.5, 2.5),
-            new Point2D( 2.5, 0.5),
-            new Point2D( 3.5, 2.5)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(0.0, 0.0),
-            new Point2D(0.5, 2.0),
-            new Point2D(2.0, 0.5),
-            new Point2D(2.5, 1.0),
-            new Point2D(3.0, 2.5)
+        checkVertices(set.getVertices(), new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0),
+                new Vector2D( 1.0,  2.0),
+                new Vector2D( 0.0,  2.0)
+            }
+        });
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(0.5, 0.5),
+            new Vector2D(2.0, 2.0),
+            new Vector2D(2.5, 2.5),
+            new Vector2D(0.5, 1.5),
+            new Vector2D(1.5, 1.5),
+            new Vector2D(1.5, 0.5),
+            new Vector2D(1.5, 2.5),
+            new Vector2D(2.5, 1.5),
+            new Vector2D(2.5, 2.5)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(-0.5, 0.5),
+            new Vector2D( 0.5, 2.5),
+            new Vector2D( 2.5, 0.5),
+            new Vector2D( 3.5, 2.5)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(0.0, 0.0),
+            new Vector2D(0.5, 2.0),
+            new Vector2D(2.0, 0.5),
+            new Vector2D(2.5, 1.0),
+            new Vector2D(3.0, 2.5)
         });
 
     }
 
     @Test
     public void testIntersection() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
-        PolygonsSet set  = (PolygonsSet) Region.intersection(set1.copySelf(),
-                                                             set2.copySelf());
+        PolygonsSet set  = (PolygonsSet) new RegionFactory<Euclidean2D>().intersection(set1.copySelf(),
+                                                                                       set2.copySelf());
         checkVertices(set1.getVertices(), vertices1);
         checkVertices(set2.getVertices(), vertices2);
-        checkVertices(set.getVertices(), new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 2.0,  1.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 1.0,  2.0)
-            }
-        });
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(1.5, 1.5)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(0.5, 1.5),
-            new Point2D(2.5, 1.5),
-            new Point2D(1.5, 0.5),
-            new Point2D(0.5, 0.5)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(2.0, 2.0),
-            new Point2D(1.0, 1.5),
-            new Point2D(1.5, 2.0)
+        checkVertices(set.getVertices(), new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 2.0,  1.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 1.0,  2.0)
+            }
+        });
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(1.5, 1.5)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(0.5, 1.5),
+            new Vector2D(2.5, 1.5),
+            new Vector2D(1.5, 0.5),
+            new Vector2D(0.5, 0.5)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(2.0, 2.0),
+            new Vector2D(1.0, 1.5),
+            new Vector2D(1.5, 2.0)
         });
     }
 
     @Test
     public void testXor() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
-        PolygonsSet set  = (PolygonsSet) Region.xor(set1.copySelf(),
-                                                    set2.copySelf());
+        PolygonsSet set  = (PolygonsSet) new RegionFactory<Euclidean2D>().xor(set1.copySelf(),
+                                                                              set2.copySelf());
         checkVertices(set1.getVertices(), vertices1);
         checkVertices(set2.getVertices(), vertices2);
-        checkVertices(set.getVertices(), new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0),
-                new Point2D( 1.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        checkVertices(set.getVertices(), new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0),
+                new Vector2D( 1.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             },
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 1.0,  2.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 2.0,  1.0)
-            }
-        });
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(0.5, 0.5),
-            new Point2D(2.5, 2.5),
-            new Point2D(0.5, 1.5),
-            new Point2D(1.5, 0.5),
-            new Point2D(1.5, 2.5),
-            new Point2D(2.5, 1.5),
-            new Point2D(2.5, 2.5)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D(-0.5, 0.5),
-            new Point2D( 0.5, 2.5),
-            new Point2D( 2.5, 0.5),
-            new Point2D( 1.5, 1.5),
-            new Point2D( 3.5, 2.5)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(2.0, 2.0),
-            new Point2D(1.5, 1.0),
-            new Point2D(2.0, 1.5),
-            new Point2D(0.0, 0.0),
-            new Point2D(0.5, 2.0),
-            new Point2D(2.0, 0.5),
-            new Point2D(2.5, 1.0),
-            new Point2D(3.0, 2.5)
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 1.0,  2.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 2.0,  1.0)
+            }
+        });
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(0.5, 0.5),
+            new Vector2D(2.5, 2.5),
+            new Vector2D(0.5, 1.5),
+            new Vector2D(1.5, 0.5),
+            new Vector2D(1.5, 2.5),
+            new Vector2D(2.5, 1.5),
+            new Vector2D(2.5, 2.5)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D(-0.5, 0.5),
+            new Vector2D( 0.5, 2.5),
+            new Vector2D( 2.5, 0.5),
+            new Vector2D( 1.5, 1.5),
+            new Vector2D( 3.5, 2.5)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(2.0, 2.0),
+            new Vector2D(1.5, 1.0),
+            new Vector2D(2.0, 1.5),
+            new Vector2D(0.0, 0.0),
+            new Vector2D(0.5, 2.0),
+            new Vector2D(2.0, 0.5),
+            new Vector2D(2.5, 1.0),
+            new Vector2D(3.0, 2.5)
         });
     }
 
     @Test
     public void testDifference() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  2.0),
-                new Point2D( 0.0,  2.0)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  2.0),
+                new Vector2D( 0.0,  2.0)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0,  1.0),
-                new Point2D( 3.0,  1.0),
-                new Point2D( 3.0,  3.0),
-                new Point2D( 1.0,  3.0)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 3.0,  1.0),
+                new Vector2D( 3.0,  3.0),
+                new Vector2D( 1.0,  3.0)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
-        PolygonsSet set  = (PolygonsSet) Region.difference(set1.copySelf(),
-                                                           set2.copySelf());
+        PolygonsSet set  = (PolygonsSet) new RegionFactory<Euclidean2D>().difference(set1.copySelf(),
+                                                                                     set2.copySelf());
         checkVertices(set1.getVertices(), vertices1);
         checkVertices(set2.getVertices(), vertices2);
-        checkVertices(set.getVertices(), new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.0,  0.0),
-                new Point2D( 2.0,  0.0),
-                new Point2D( 2.0,  1.0),
-                new Point2D( 1.0,  1.0),
-                new Point2D( 1.0,  2.0),
-                new Point2D( 0.0,  2.0)
-            }
-        });
-        checkPoints(Region.Location.INSIDE, set, new Point2D[] {
-            new Point2D(0.5, 0.5),
-            new Point2D(0.5, 1.5),
-            new Point2D(1.5, 0.5)
-        });
-        checkPoints(Region.Location.OUTSIDE, set, new Point2D[] {
-            new Point2D( 2.5, 2.5),
-            new Point2D(-0.5, 0.5),
-            new Point2D( 0.5, 2.5),
-            new Point2D( 2.5, 0.5),
-            new Point2D( 1.5, 1.5),
-            new Point2D( 3.5, 2.5),
-            new Point2D( 1.5, 2.5),
-            new Point2D( 2.5, 1.5),
-            new Point2D( 2.0, 1.5),
-            new Point2D( 2.0, 2.0),
-            new Point2D( 2.5, 1.0),
-            new Point2D( 2.5, 2.5),
-            new Point2D( 3.0, 2.5)
-        });
-        checkPoints(Region.Location.BOUNDARY, set, new Point2D[] {
-            new Point2D(1.0, 1.0),
-            new Point2D(1.5, 1.0),
-            new Point2D(0.0, 0.0),
-            new Point2D(0.5, 2.0),
-            new Point2D(2.0, 0.5)
+        checkVertices(set.getVertices(), new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.0,  0.0),
+                new Vector2D( 2.0,  0.0),
+                new Vector2D( 2.0,  1.0),
+                new Vector2D( 1.0,  1.0),
+                new Vector2D( 1.0,  2.0),
+                new Vector2D( 0.0,  2.0)
+            }
+        });
+        checkPoints(Region.Location.INSIDE, set, new Vector2D[] {
+            new Vector2D(0.5, 0.5),
+            new Vector2D(0.5, 1.5),
+            new Vector2D(1.5, 0.5)
+        });
+        checkPoints(Region.Location.OUTSIDE, set, new Vector2D[] {
+            new Vector2D( 2.5, 2.5),
+            new Vector2D(-0.5, 0.5),
+            new Vector2D( 0.5, 2.5),
+            new Vector2D( 2.5, 0.5),
+            new Vector2D( 1.5, 1.5),
+            new Vector2D( 3.5, 2.5),
+            new Vector2D( 1.5, 2.5),
+            new Vector2D( 2.5, 1.5),
+            new Vector2D( 2.0, 1.5),
+            new Vector2D( 2.0, 2.0),
+            new Vector2D( 2.5, 1.0),
+            new Vector2D( 2.5, 2.5),
+            new Vector2D( 3.0, 2.5)
+        });
+        checkPoints(Region.Location.BOUNDARY, set, new Vector2D[] {
+            new Vector2D(1.0, 1.0),
+            new Vector2D(1.5, 1.0),
+            new Vector2D(0.0, 0.0),
+            new Vector2D(0.5, 2.0),
+            new Vector2D(2.0, 0.5)
         });
     }
 
     @Test
     public void testEmptyDifference() {
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.5, 3.5),
-                new Point2D( 0.5, 4.5),
-                new Point2D(-0.5, 4.5),
-                new Point2D(-0.5, 3.5)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.5, 3.5),
+                new Vector2D( 0.5, 4.5),
+                new Vector2D(-0.5, 4.5),
+                new Vector2D(-0.5, 3.5)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 1.0, 2.0),
-                new Point2D( 1.0, 8.0),
-                new Point2D(-1.0, 8.0),
-                new Point2D(-1.0, 2.0)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 1.0, 2.0),
+                new Vector2D( 1.0, 8.0),
+                new Vector2D(-1.0, 8.0),
+                new Vector2D(-1.0, 2.0)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
-        Assert.assertTrue(Region.difference(set1.copySelf(), set2.copySelf()).isEmpty());
+        Assert.assertTrue(new RegionFactory<Euclidean2D>().difference(set1.copySelf(), set2.copySelf()).isEmpty());
     }
 
     @Test
     public void testChoppedHexagon() {
         double pi6   = FastMath.PI / 6.0;
         double sqrt3 = FastMath.sqrt(3.0);
-        SubHyperplane[] hyp = {
-            new SubHyperplane(new Line(new Point2D(   0.0, 1.0),  5 * pi6)),
-            new SubHyperplane(new Line(new Point2D(-sqrt3, 1.0),  7 * pi6)),
-            new SubHyperplane(new Line(new Point2D(-sqrt3, 1.0),  9 * pi6)),
-            new SubHyperplane(new Line(new Point2D(-sqrt3, 0.0), 11 * pi6)),
-            new SubHyperplane(new Line(new Point2D(   0.0, 0.0), 13 * pi6)),
-            new SubHyperplane(new Line(new Point2D(   0.0, 1.0),  3 * pi6)),
-            new SubHyperplane(new Line(new Point2D(-5.0 * sqrt3 / 6.0, 0.0), 9 * pi6))
-        };
-        hyp[1] =                              hyp[0].getHyperplane().split(hyp[1]).getMinus();
-        hyp[2] =                              hyp[1].getHyperplane().split(hyp[2]).getMinus();
-        hyp[3] =                              hyp[2].getHyperplane().split(hyp[3]).getMinus();
-        hyp[4] = hyp[0].getHyperplane().split(hyp[3].getHyperplane().split(hyp[4]).getMinus()).getMinus();
-        hyp[5] = hyp[0].getHyperplane().split(hyp[4].getHyperplane().split(hyp[5]).getMinus()).getMinus();
-        hyp[6] = hyp[1].getHyperplane().split(hyp[3].getHyperplane().split(hyp[6]).getMinus()).getMinus();
-        BSPTree tree = new BSPTree(Boolean.TRUE);
+        SubLine[] hyp = {
+            new Line(new Vector2D(   0.0, 1.0),  5 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(-sqrt3, 1.0),  7 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(-sqrt3, 1.0),  9 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(-sqrt3, 0.0), 11 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(   0.0, 0.0), 13 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(   0.0, 1.0),  3 * pi6).wholeHyperplane(),
+            new Line(new Vector2D(-5.0 * sqrt3 / 6.0, 0.0), 9 * pi6).wholeHyperplane()
+        };
+        hyp[1] = (SubLine) hyp[1].split(hyp[0].getHyperplane()).getMinus();
+        hyp[2] = (SubLine) hyp[2].split(hyp[1].getHyperplane()).getMinus();
+        hyp[3] = (SubLine) hyp[3].split(hyp[2].getHyperplane()).getMinus();
+        hyp[4] = (SubLine) hyp[4].split(hyp[3].getHyperplane()).getMinus().split(hyp[0].getHyperplane()).getMinus();
+        hyp[5] = (SubLine) hyp[5].split(hyp[4].getHyperplane()).getMinus().split(hyp[0].getHyperplane()).getMinus();
+        hyp[6] = (SubLine) hyp[6].split(hyp[3].getHyperplane()).getMinus().split(hyp[1].getHyperplane()).getMinus();
+        BSPTree<Euclidean2D> tree = new BSPTree<Euclidean2D>(Boolean.TRUE);
         for (int i = hyp.length - 1; i >= 0; --i) {
-            tree = new BSPTree(hyp[i], new BSPTree(Boolean.FALSE), tree, null);
+            tree = new BSPTree<Euclidean2D>(hyp[i], new BSPTree<Euclidean2D>(Boolean.FALSE), tree, null);
         }
         PolygonsSet set = new PolygonsSet(tree);
-        SubHyperplane splitter =
-            new SubHyperplane(new Line(new Point2D(-2.0 * sqrt3 / 3.0, 0.0), 9 * pi6));
+        SubLine splitter =
+            new Line(new Vector2D(-2.0 * sqrt3 / 3.0, 0.0), 9 * pi6).wholeHyperplane();
         PolygonsSet slice =
-            new PolygonsSet(new BSPTree(splitter,
-                                        set.getTree(false).split(splitter).getPlus(),
-                                        new BSPTree(Boolean.FALSE), null));
+            new PolygonsSet(new BSPTree<Euclidean2D>(splitter,
+                                                     set.getTree(false).split(splitter).getPlus(),
+                                                     new BSPTree<Euclidean2D>(Boolean.FALSE), null));
         Assert.assertEquals(Region.Location.OUTSIDE,
-                            slice.checkPoint(new Point2D(0.1, 0.5)));
+                            slice.checkPoint(new Vector2D(0.1, 0.5)));
         Assert.assertEquals(11.0 / 3.0, slice.getBoundarySize(), 1.0e-10);
 
     }
@@ -607,27 +609,27 @@ public class PolygonsSetTest {
     @Test
     public void testConcentric() {
         double h = FastMath.sqrt(3.0) / 2.0;
-        Point2D[][] vertices1 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.00, 0.1 * h),
-                new Point2D( 0.05, 0.1 * h),
-                new Point2D( 0.10, 0.2 * h),
-                new Point2D( 0.05, 0.3 * h),
-                new Point2D(-0.05, 0.3 * h),
-                new Point2D(-0.10, 0.2 * h),
-                new Point2D(-0.05, 0.1 * h)
+        Vector2D[][] vertices1 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.00, 0.1 * h),
+                new Vector2D( 0.05, 0.1 * h),
+                new Vector2D( 0.10, 0.2 * h),
+                new Vector2D( 0.05, 0.3 * h),
+                new Vector2D(-0.05, 0.3 * h),
+                new Vector2D(-0.10, 0.2 * h),
+                new Vector2D(-0.05, 0.1 * h)
             }
         };
         PolygonsSet set1 = buildSet(vertices1);
-        Point2D[][] vertices2 = new Point2D[][] {
-            new Point2D[] {
-                new Point2D( 0.00, 0.0 * h),
-                new Point2D( 0.10, 0.0 * h),
-                new Point2D( 0.20, 0.2 * h),
-                new Point2D( 0.10, 0.4 * h),
-                new Point2D(-0.10, 0.4 * h),
-                new Point2D(-0.20, 0.2 * h),
-                new Point2D(-0.10, 0.0 * h)
+        Vector2D[][] vertices2 = new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D( 0.00, 0.0 * h),
+                new Vector2D( 0.10, 0.0 * h),
+                new Vector2D( 0.20, 0.2 * h),
+                new Vector2D( 0.10, 0.4 * h),
+                new Vector2D(-0.10, 0.4 * h),
+                new Vector2D(-0.20, 0.2 * h),
+                new Vector2D(-0.10, 0.0 * h)
             }
         };
         PolygonsSet set2 = buildSet(vertices2);
@@ -636,109 +638,127 @@ public class PolygonsSetTest {
 
     @Test
     public void testBug20040520() {
-        BSPTree a0 = new BSPTree(buildSegment(new Point2D(0.85, -0.05),
-                                              new Point2D(0.90, -0.10)),
-                                              new BSPTree(Boolean.FALSE),
-                                              new BSPTree(Boolean.TRUE),
-                                              null);
-        BSPTree a1 = new BSPTree(buildSegment(new Point2D(0.85, -0.10),
-                                              new Point2D(0.90, -0.10)),
-                                              new BSPTree(Boolean.FALSE), a0, null);
-        BSPTree a2 = new BSPTree(buildSegment(new Point2D(0.90, -0.05),
-                                              new Point2D(0.85, -0.05)),
-                                              new BSPTree(Boolean.FALSE), a1, null);
-        BSPTree a3 = new BSPTree(buildSegment(new Point2D(0.82, -0.05),
-                                              new Point2D(0.82, -0.08)),
-                                              new BSPTree(Boolean.FALSE),
-                                              new BSPTree(Boolean.TRUE),
-                                              null);
-        BSPTree a4 = new BSPTree(buildHalfLine(new Point2D(0.85, -0.05),
-                                               new Point2D(0.80, -0.05),
-                                               false),
-                                               new BSPTree(Boolean.FALSE), a3, null);
-        BSPTree a5 = new BSPTree(buildSegment(new Point2D(0.82, -0.08),
-                                              new Point2D(0.82, -0.18)),
-                                              new BSPTree(Boolean.FALSE),
-                                              new BSPTree(Boolean.TRUE),
-                                              null);
-        BSPTree a6 = new BSPTree(buildHalfLine(new Point2D(0.82, -0.18),
-                                               new Point2D(0.85, -0.15),
-                                               true),
-                                               new BSPTree(Boolean.FALSE), a5, null);
-        BSPTree a7 = new BSPTree(buildHalfLine(new Point2D(0.85, -0.05),
-                                               new Point2D(0.82, -0.08),
-                                               false),
-                                               a4, a6, null);
-        BSPTree a8 = new BSPTree(buildLine(new Point2D(0.85, -0.25),
-                                           new Point2D(0.85,  0.05)),
-                                           a2, a7, null);
-        BSPTree a9 = new BSPTree(buildLine(new Point2D(0.90,  0.05),
-                                           new Point2D(0.90, -0.50)),
-                                           a8, new BSPTree(Boolean.FALSE), null);
-
-        BSPTree b0 = new BSPTree(buildSegment(new Point2D(0.92, -0.12),
-                                              new Point2D(0.92, -0.08)),
-                                              new BSPTree(Boolean.FALSE), new BSPTree(Boolean.TRUE),
-                                              null);
-        BSPTree b1 = new BSPTree(buildHalfLine(new Point2D(0.92, -0.08),
-                                               new Point2D(0.90, -0.10),
-                                               true),
-                                               new BSPTree(Boolean.FALSE), b0, null);
-        BSPTree b2 = new BSPTree(buildSegment(new Point2D(0.92, -0.18),
-                                              new Point2D(0.92, -0.12)),
-                                              new BSPTree(Boolean.FALSE), new BSPTree(Boolean.TRUE),
-                                              null);
-        BSPTree b3 = new BSPTree(buildSegment(new Point2D(0.85, -0.15),
-                                              new Point2D(0.90, -0.20)),
-                                              new BSPTree(Boolean.FALSE), b2, null);
-        BSPTree b4 = new BSPTree(buildSegment(new Point2D(0.95, -0.15),
-                                              new Point2D(0.85, -0.05)),
-                                              b1, b3, null);
-        BSPTree b5 = new BSPTree(buildHalfLine(new Point2D(0.85, -0.05),
-                                               new Point2D(0.85, -0.25),
-                                               true),
-                                               new BSPTree(Boolean.FALSE), b4, null);
-        BSPTree b6 = new BSPTree(buildLine(new Point2D(0.0, -1.10),
-                                           new Point2D(1.0, -0.10)),
-                                           new BSPTree(Boolean.FALSE), b5, null);
-
-        PolygonsSet c = (PolygonsSet) Region.union(new PolygonsSet(a9),
-                                                   new PolygonsSet(b6));
-
-        checkPoints(Region.Location.INSIDE, c, new Point2D[] {
-            new Point2D(0.83, -0.06),
-            new Point2D(0.83, -0.15),
-            new Point2D(0.88, -0.15),
-            new Point2D(0.88, -0.09),
-            new Point2D(0.88, -0.07),
-            new Point2D(0.91, -0.18),
-            new Point2D(0.91, -0.10)
-        });
-
-        checkPoints(Region.Location.OUTSIDE, c, new Point2D[] {
-            new Point2D(0.80, -0.10),
-            new Point2D(0.83, -0.50),
-            new Point2D(0.83, -0.20),
-            new Point2D(0.83, -0.02),
-            new Point2D(0.87, -0.50),
-            new Point2D(0.87, -0.20),
-            new Point2D(0.87, -0.02),
-            new Point2D(0.91, -0.20),
-            new Point2D(0.91, -0.08),
-            new Point2D(0.93, -0.15)
+        BSPTree<Euclidean2D> a0 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.85, -0.05),
+                                                  new Vector2D(0.90, -0.10)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE),
+                                                  new BSPTree<Euclidean2D>(Boolean.TRUE),
+                                                  null);
+        BSPTree<Euclidean2D> a1 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.85, -0.10),
+                                                  new Vector2D(0.90, -0.10)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE), a0, null);
+        BSPTree<Euclidean2D> a2 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.90, -0.05),
+                                                  new Vector2D(0.85, -0.05)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE), a1, null);
+        BSPTree<Euclidean2D> a3 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.82, -0.05),
+                                                  new Vector2D(0.82, -0.08)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE),
+                                                  new BSPTree<Euclidean2D>(Boolean.TRUE),
+                                                  null);
+        BSPTree<Euclidean2D> a4 =
+            new BSPTree<Euclidean2D>(buildHalfLine(new Vector2D(0.85, -0.05),
+                                                   new Vector2D(0.80, -0.05),
+                                                   false),
+                                                   new BSPTree<Euclidean2D>(Boolean.FALSE), a3, null);
+        BSPTree<Euclidean2D> a5 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.82, -0.08),
+                                                  new Vector2D(0.82, -0.18)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE),
+                                                  new BSPTree<Euclidean2D>(Boolean.TRUE),
+                                                  null);
+        BSPTree<Euclidean2D> a6 =
+            new BSPTree<Euclidean2D>(buildHalfLine(new Vector2D(0.82, -0.18),
+                                                   new Vector2D(0.85, -0.15),
+                                                   true),
+                                                   new BSPTree<Euclidean2D>(Boolean.FALSE), a5, null);
+        BSPTree<Euclidean2D> a7 =
+            new BSPTree<Euclidean2D>(buildHalfLine(new Vector2D(0.85, -0.05),
+                                                   new Vector2D(0.82, -0.08),
+                                                   false),
+                                                   a4, a6, null);
+        BSPTree<Euclidean2D> a8 =
+            new BSPTree<Euclidean2D>(buildLine(new Vector2D(0.85, -0.25),
+                                               new Vector2D(0.85,  0.05)),
+                                               a2, a7, null);
+        BSPTree<Euclidean2D> a9 =
+            new BSPTree<Euclidean2D>(buildLine(new Vector2D(0.90,  0.05),
+                                               new Vector2D(0.90, -0.50)),
+                                               a8, new BSPTree<Euclidean2D>(Boolean.FALSE), null);
+
+        BSPTree<Euclidean2D> b0 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.92, -0.12),
+                                                  new Vector2D(0.92, -0.08)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE), new BSPTree<Euclidean2D>(Boolean.TRUE),
+                                                  null);
+        BSPTree<Euclidean2D> b1 =
+            new BSPTree<Euclidean2D>(buildHalfLine(new Vector2D(0.92, -0.08),
+                                                   new Vector2D(0.90, -0.10),
+                                                   true),
+                                                   new BSPTree<Euclidean2D>(Boolean.FALSE), b0, null);
+        BSPTree<Euclidean2D> b2 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.92, -0.18),
+                                                  new Vector2D(0.92, -0.12)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE), new BSPTree<Euclidean2D>(Boolean.TRUE),
+                                                  null);
+        BSPTree<Euclidean2D> b3 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.85, -0.15),
+                                                  new Vector2D(0.90, -0.20)),
+                                                  new BSPTree<Euclidean2D>(Boolean.FALSE), b2, null);
+        BSPTree<Euclidean2D> b4 =
+            new BSPTree<Euclidean2D>(buildSegment(new Vector2D(0.95, -0.15),
+                                                  new Vector2D(0.85, -0.05)),
+                                                  b1, b3, null);
+        BSPTree<Euclidean2D> b5 =
+            new BSPTree<Euclidean2D>(buildHalfLine(new Vector2D(0.85, -0.05),
+                                                   new Vector2D(0.85, -0.25),
+                                                   true),
+                                                   new BSPTree<Euclidean2D>(Boolean.FALSE), b4, null);
+        BSPTree<Euclidean2D> b6 =
+            new BSPTree<Euclidean2D>(buildLine(new Vector2D(0.0, -1.10),
+                                               new Vector2D(1.0, -0.10)),
+                                               new BSPTree<Euclidean2D>(Boolean.FALSE), b5, null);
+
+        PolygonsSet c =
+            (PolygonsSet) new RegionFactory<Euclidean2D>().union(new PolygonsSet(a9),
+                                                                 new PolygonsSet(b6));
+
+        checkPoints(Region.Location.INSIDE, c, new Vector2D[] {
+            new Vector2D(0.83, -0.06),
+            new Vector2D(0.83, -0.15),
+            new Vector2D(0.88, -0.15),
+            new Vector2D(0.88, -0.09),
+            new Vector2D(0.88, -0.07),
+            new Vector2D(0.91, -0.18),
+            new Vector2D(0.91, -0.10)
+        });
+
+        checkPoints(Region.Location.OUTSIDE, c, new Vector2D[] {
+            new Vector2D(0.80, -0.10),
+            new Vector2D(0.83, -0.50),
+            new Vector2D(0.83, -0.20),
+            new Vector2D(0.83, -0.02),
+            new Vector2D(0.87, -0.50),
+            new Vector2D(0.87, -0.20),
+            new Vector2D(0.87, -0.02),
+            new Vector2D(0.91, -0.20),
+            new Vector2D(0.91, -0.08),
+            new Vector2D(0.93, -0.15)
         });
 
         checkVertices(c.getVertices(),
-                      new Point2D[][] {
-            new Point2D[] {
-                new Point2D(0.85, -0.15),
-                new Point2D(0.90, -0.20),
-                new Point2D(0.92, -0.18),
-                new Point2D(0.92, -0.08),
-                new Point2D(0.90, -0.10),
-                new Point2D(0.90, -0.05),
-                new Point2D(0.82, -0.05),
-                new Point2D(0.82, -0.18),
+                      new Vector2D[][] {
+            new Vector2D[] {
+                new Vector2D(0.85, -0.15),
+                new Vector2D(0.90, -0.20),
+                new Vector2D(0.92, -0.18),
+                new Vector2D(0.92, -0.08),
+                new Vector2D(0.90, -0.10),
+                new Vector2D(0.90, -0.05),
+                new Vector2D(0.82, -0.05),
+                new Vector2D(0.82, -0.18),
             }
         });
 
@@ -748,43 +768,42 @@ public class PolygonsSetTest {
     public void testBug20041003() {
 
         Line[] l = {
-            new Line(new Point2D(0.0, 0.625000007541172),
-                     new Point2D(1.0, 0.625000007541172)),
-                     new Line(new Point2D(-0.19204433621902645, 0.0),
-                              new Point2D(-0.19204433621902645, 1.0)),
-                              new Line(new Point2D(-0.40303524786887,  0.4248364535319128),
-                                       new Point2D(-1.12851149797877, -0.2634107480798909)),
-                                       new Line(new Point2D(0.0, 2.0),
-                                                new Point2D(1.0, 2.0))
+            new Line(new Vector2D(0.0, 0.625000007541172),
+                     new Vector2D(1.0, 0.625000007541172)),
+                     new Line(new Vector2D(-0.19204433621902645, 0.0),
+                              new Vector2D(-0.19204433621902645, 1.0)),
+                              new Line(new Vector2D(-0.40303524786887,  0.4248364535319128),
+                                       new Vector2D(-1.12851149797877, -0.2634107480798909)),
+                                       new Line(new Vector2D(0.0, 2.0),
+                                                new Vector2D(1.0, 2.0))
         };
 
-        BSPTree node1 =
-            new BSPTree(new SubHyperplane(l[0],
+        BSPTree<Euclidean2D> node1 =
+            new BSPTree<Euclidean2D>(new SubLine(l[0],
                                           new IntervalsSet(intersectionAbscissa(l[0], l[1]),
                                                            intersectionAbscissa(l[0], l[2]))),
-                                                           new BSPTree(Boolean.TRUE), new BSPTree(Boolean.FALSE),
+                                                           new BSPTree<Euclidean2D>(Boolean.TRUE), new BSPTree<Euclidean2D>(Boolean.FALSE),
                                                            null);
-        BSPTree node2 =
-            new BSPTree(new SubHyperplane(l[1],
+        BSPTree<Euclidean2D> node2 =
+            new BSPTree<Euclidean2D>(new SubLine(l[1],
                                           new IntervalsSet(intersectionAbscissa(l[1], l[2]),
                                                            intersectionAbscissa(l[1], l[3]))),
-                                                           node1, new BSPTree(Boolean.FALSE), null);
-        BSPTree node3 =
-            new BSPTree(new SubHyperplane(l[2],
+                                                           node1, new BSPTree<Euclidean2D>(Boolean.FALSE), null);
+        BSPTree<Euclidean2D> node3 =
+            new BSPTree<Euclidean2D>(new SubLine(l[2],
                                           new IntervalsSet(intersectionAbscissa(l[2], l[3]),
                                                            Double.POSITIVE_INFINITY)),
-                                                           node2, new BSPTree(Boolean.FALSE), null);
-        BSPTree node4 =
-            new BSPTree(new SubHyperplane(l[3]),
-                        node3, new BSPTree(Boolean.FALSE), null);
+                                                           node2, new BSPTree<Euclidean2D>(Boolean.FALSE), null);
+        BSPTree<Euclidean2D> node4 =
+            new BSPTree<Euclidean2D>(l[3].wholeHyperplane(), node3, new BSPTree<Euclidean2D>(Boolean.FALSE), null);
 
         PolygonsSet set = new PolygonsSet(node4);
         Assert.assertEquals(0, set.getVertices().length);
 
     }
 
-    private PolygonsSet buildSet(Point2D[][] vertices) {
-        ArrayList<SubHyperplane> edges = new ArrayList<SubHyperplane>();
+    private PolygonsSet buildSet(Vector2D[][] vertices) {
+        ArrayList<SubHyperplane<Euclidean2D>> edges = new ArrayList<SubHyperplane<Euclidean2D>>();
         for (int i = 0; i < vertices.length; ++i) {
             int l = vertices[i].length;
             for (int j = 0; j < l; ++j) {
@@ -794,49 +813,49 @@ public class PolygonsSetTest {
         return new PolygonsSet(edges);
     }
 
-    private SubHyperplane buildLine(Point2D start, Point2D end) {
-        return new SubHyperplane(new Line(start, end));
+    private SubHyperplane<Euclidean2D> buildLine(Vector2D start, Vector2D end) {
+        return new Line(start, end).wholeHyperplane();
     }
 
     private double intersectionAbscissa(Line l0, Line l1) {
-        Point2D p = (Point2D) l0.intersection(l1);
-        return ((Point1D) l0.toSubSpace(p)).getAbscissa();
+        Vector2D p = (Vector2D) l0.intersection(l1);
+        return ((Vector1D) l0.toSubSpace(p)).getX();
     }
 
-    private SubHyperplane buildHalfLine(Point2D start, Point2D end,
-                                        boolean startIsVirtual) {
+    private SubHyperplane<Euclidean2D> buildHalfLine(Vector2D start, Vector2D end,
+                                                     boolean startIsVirtual) {
         Line   line  = new Line(start, end);
         double lower = startIsVirtual
         ? Double.NEGATIVE_INFINITY
-        : ((Point1D) line.toSubSpace(start)).getAbscissa();
+        : ((Vector1D) line.toSubSpace(start)).getX();
         double upper = startIsVirtual
-        ? ((Point1D) line.toSubSpace(end)).getAbscissa()
+        ? ((Vector1D) line.toSubSpace(end)).getX()
         : Double.POSITIVE_INFINITY;
-        return new SubHyperplane(line, new IntervalsSet(lower, upper));
+        return new SubLine(line, new IntervalsSet(lower, upper));
     }
 
-    private SubHyperplane buildSegment(Point2D start, Point2D end) {
+    private SubHyperplane<Euclidean2D> buildSegment(Vector2D start, Vector2D end) {
         Line   line  = new Line(start, end);
-        double lower = ((Point1D) line.toSubSpace(start)).getAbscissa();
-        double upper = ((Point1D) line.toSubSpace(end)).getAbscissa();
-        return new SubHyperplane(line, new IntervalsSet(lower, upper));
+        double lower = ((Vector1D) line.toSubSpace(start)).getX();
+        double upper = ((Vector1D) line.toSubSpace(end)).getX();
+        return new SubLine(line, new IntervalsSet(lower, upper));
     }
 
     private void checkPoints(Region.Location expected, PolygonsSet set,
-                             Point2D[] points) {
+                             Vector2D[] points) {
         for (int i = 0; i < points.length; ++i) {
             Assert.assertEquals(expected, set.checkPoint(points[i]));
         }
     }
 
-    private boolean checkInSegment(Point2D p,
-                                   Point2D p1, Point2D p2,
+    private boolean checkInSegment(Vector2D p,
+                                   Vector2D p1, Vector2D p2,
                                    double tolerance) {
         Line line = new Line(p1, p2);
         if (line.getOffset(p) < tolerance) {
-            double x  = ((Point1D) line.toSubSpace(p)).getAbscissa();
-            double x1 = ((Point1D) line.toSubSpace(p1)).getAbscissa();
-            double x2 = ((Point1D) line.toSubSpace(p2)).getAbscissa();
+            double x  = ((Vector1D) line.toSubSpace(p)).getX();
+            double x1 = ((Vector1D) line.toSubSpace(p1)).getX();
+            double x2 = ((Vector1D) line.toSubSpace(p2)).getX();
             return (((x - x1) * (x - x2) <= 0.0)
                     || (p1.distance(p) < tolerance)
                     || (p2.distance(p) < tolerance));
@@ -845,16 +864,16 @@ public class PolygonsSetTest {
         }
     }
 
-    private void checkVertices(Point2D[][] rebuiltVertices,
-                               Point2D[][] vertices) {
+    private void checkVertices(Vector2D[][] rebuiltVertices,
+                               Vector2D[][] vertices) {
 
         // each rebuilt vertex should be in a segment joining two original vertices
         for (int i = 0; i < rebuiltVertices.length; ++i) {
             for (int j = 0; j < rebuiltVertices[i].length; ++j) {
                 boolean inSegment = false;
-                Point2D p = rebuiltVertices[i][j];
+                Vector2D p = rebuiltVertices[i][j];
                 for (int k = 0; k < vertices.length; ++k) {
-                    Point2D[] loop = vertices[k];
+                    Vector2D[] loop = vertices[k];
                     int length = loop.length;
                     for (int l = 0; (! inSegment) && (l < length); ++l) {
                         inSegment = checkInSegment(p, loop[l], loop[(l + 1) % length], 1.0e-10);



Mime
View raw message