Another round of types parameterization in geometry.

Fixes #368

Author: maisonobe

hipparchus-geometry/src/changes/changes.xml

@@ -50,7 +50,7 @@ If the output is not quite correct, check for invisible trailing spaces!
   </properties>
   <release version="4.0" date="TBD" description="TBD">
     <action dev="luc" type="fix" issue="issues/368">
-      Added point type to geometry classes parameters
+      Added point, hyperplane and sub-hyperplane types to geometry classes parameters
     </action>
     <action dev="luc" type="update" issue="issues/314">
       Improved robustness of BSP tree operations

hipparchus-geometry/src/main/java/org/hipparchus/geometry/euclidean/oned/IntervalsSet.java

@@ -28,7 +28,7 @@
  * boolean.</p>
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
-public class OrientedPoint implements Hyperplane<Euclidean1D, Vector1D> {
+public class OrientedPoint implements Hyperplane<Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint> {
 
     /** Vector location. */
     private final Vector1D location;
@@ -111,8 +111,8 @@ public IntervalsSet wholeSpace() {
 
     /** {@inheritDoc} */
     @Override
-    public boolean sameOrientationAs(final Hyperplane<Euclidean1D, Vector1D> other) {
-        return direct == ((OrientedPoint) other).direct;
+    public boolean sameOrientationAs(final OrientedPoint other) {
+        return direct == other.direct;
     }
 
     /** {@inheritDoc}

hipparchus-geometry/src/main/java/org/hipparchus/geometry/euclidean/oned/OrientedPoint.java

@@ -22,22 +22,23 @@
 package org.hipparchus.geometry.euclidean.oned;
 
 import org.hipparchus.geometry.partitioning.AbstractSubHyperplane;
-import org.hipparchus.geometry.partitioning.Hyperplane;
 import org.hipparchus.geometry.partitioning.Region;
 
 /** This class represents sub-hyperplane for {@link OrientedPoint}.
  * <p>An hyperplane in 1D is a simple point, its orientation being a
  * boolean.</p>
  * <p>Instances of this class are guaranteed to be immutable.</p>
  */
-public class SubOrientedPoint extends AbstractSubHyperplane<Euclidean1D, Vector1D, Euclidean1D, Vector1D> {
+public class SubOrientedPoint
+    extends AbstractSubHyperplane<Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint,
+                                  Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint> {
 
     /** Simple constructor.
      * @param hyperplane underlying hyperplane
      * @param remainingRegion remaining region of the hyperplane
      */
-    public SubOrientedPoint(final Hyperplane<Euclidean1D, Vector1D> hyperplane,
-                            final Region<Euclidean1D, Vector1D> remainingRegion) {
+    public SubOrientedPoint(final OrientedPoint hyperplane,
+                            final Region<Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint> remainingRegion) {
         super(hyperplane, remainingRegion);
     }
 
@@ -55,16 +56,15 @@ public boolean isEmpty() {
 
     /** {@inheritDoc} */
     @Override
-    protected AbstractSubHyperplane<Euclidean1D, Vector1D, Euclidean1D, Vector1D>
-        buildNew(final Hyperplane<Euclidean1D, Vector1D> hyperplane,
-                 final Region<Euclidean1D, Vector1D> remainingRegion) {
+    protected SubOrientedPoint buildNew(final OrientedPoint hyperplane,
+                                        final Region<Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint> remainingRegion) {
         return new SubOrientedPoint(hyperplane, remainingRegion);
     }
 
     /** {@inheritDoc} */
     @Override
-    public SplitSubHyperplane<Euclidean1D, Vector1D> split(final Hyperplane<Euclidean1D, Vector1D> hyperplane) {
-        final double global = hyperplane.getOffset(((OrientedPoint) getHyperplane()).getLocation());
+    public SplitSubHyperplane<Euclidean1D, Vector1D, OrientedPoint, SubOrientedPoint> split(final OrientedPoint hyperplane) {
+        final double global = hyperplane.getOffset(getHyperplane().getLocation());
         if (global < -hyperplane.getTolerance()) {
             return new SplitSubHyperplane<>(null, this);
         } else if (global > hyperplane.getTolerance()) {

hipparchus-geometry/src/main/java/org/hipparchus/geometry/euclidean/oned/SubOrientedPoint.java

@@ -24,14 +24,14 @@
 import java.util.ArrayList;
 
 import org.hipparchus.geometry.euclidean.twod.Euclidean2D;
+import org.hipparchus.geometry.euclidean.twod.Line;
 import org.hipparchus.geometry.euclidean.twod.PolygonsSet;
+import org.hipparchus.geometry.euclidean.twod.SubLine;
 import org.hipparchus.geometry.euclidean.twod.Vector2D;
-import org.hipparchus.geometry.partitioning.AbstractSubHyperplane;
 import org.hipparchus.geometry.partitioning.BSPTree;
 import org.hipparchus.geometry.partitioning.BSPTreeVisitor;
 import org.hipparchus.geometry.partitioning.BoundaryAttribute;
 import org.hipparchus.geometry.partitioning.RegionFactory;
-import org.hipparchus.geometry.partitioning.SubHyperplane;
 import org.hipparchus.util.FastMath;
 import org.hipparchus.util.MathUtils;
 
@@ -123,7 +123,7 @@ private boolean pointIsBetween(final Vector2D[] loop, final int n, final int i)
     }
 
     /** Visitor projecting the boundary facets on a plane. */
-    private class BoundaryProjector implements BSPTreeVisitor<Euclidean3D, Vector3D> {
+    private class BoundaryProjector implements BSPTreeVisitor<Euclidean3D, Vector3D, Plane, SubPlane> {
 
         /** Projection of the polyhedrons set on the plane. */
         private PolygonsSet projected;
@@ -141,16 +141,16 @@ private class BoundaryProjector implements BSPTreeVisitor<Euclidean3D, Vector3D>
 
         /** {@inheritDoc} */
         @Override
-        public Order visitOrder(final BSPTree<Euclidean3D, Vector3D> node) {
+        public Order visitOrder(final BSPTree<Euclidean3D, Vector3D, Plane, SubPlane> node) {
             return Order.MINUS_SUB_PLUS;
         }
 
         /** {@inheritDoc} */
         @Override
-        public void visitInternalNode(final BSPTree<Euclidean3D, Vector3D> node) {
+        public void visitInternalNode(final BSPTree<Euclidean3D, Vector3D, Plane, SubPlane> node) {
             @SuppressWarnings("unchecked")
-            final BoundaryAttribute<Euclidean3D, Vector3D> attribute =
-                (BoundaryAttribute<Euclidean3D, Vector3D>) node.getAttribute();
+            final BoundaryAttribute<Euclidean3D, Vector3D, Plane, SubPlane> attribute =
+                (BoundaryAttribute<Euclidean3D, Vector3D, Plane, SubPlane>) node.getAttribute();
             if (attribute.getPlusOutside() != null) {
                 addContribution(attribute.getPlusOutside());
             }
@@ -161,23 +161,18 @@ public void visitInternalNode(final BSPTree<Euclidean3D, Vector3D> node) {
 
         /** {@inheritDoc} */
         @Override
-        public void visitLeafNode(final BSPTree<Euclidean3D, Vector3D> node) {
+        public void visitLeafNode(final BSPTree<Euclidean3D, Vector3D, Plane, SubPlane> node) {
         }
 
         /** Add he contribution of a boundary facet.
          * @param facet boundary facet
          */
-        private void addContribution(final SubHyperplane<Euclidean3D, Vector3D> facet) {
+        private void addContribution(final SubPlane facet) {
 
-            // extract the vertices of the facet
-            final AbstractSubHyperplane<Euclidean3D, Vector3D, Euclidean2D, Vector2D> absFacet =
-                (AbstractSubHyperplane<Euclidean3D, Vector3D, Euclidean2D, Vector2D>) facet;
-            final Plane plane    = (Plane) facet.getHyperplane();
-
-            final double scal = plane.getNormal().dotProduct(w);
+            final double scal = facet.getHyperplane().getNormal().dotProduct(w);
             if (FastMath.abs(scal) > 1.0e-3) {
                 Vector2D[][] vertices =
-                    ((PolygonsSet) absFacet.getRemainingRegion()).getVertices();
+                    ((PolygonsSet) facet.getRemainingRegion()).getVertices();
 
                 if (scal < 0) {
                     // the facet is seen from the back of the plane,
@@ -205,21 +200,21 @@ private void addContribution(final SubHyperplane<Euclidean3D, Vector3D> facet) {
                 }
 
                 // compute the projection of the facet in the outline plane
-                final ArrayList<SubHyperplane<Euclidean2D, Vector2D>> edges = new ArrayList<>();
+                final ArrayList<SubLine> edges = new ArrayList<>();
                 for (Vector2D[] loop : vertices) {
                     final boolean closed = loop[0] != null;
                     int previous         = closed ? (loop.length - 1) : 1;
-                    final Vector3D previous3D = plane.toSpace(loop[previous]);
+                    final Vector3D previous3D = facet.getHyperplane().toSpace(loop[previous]);
                     int current          = (previous + 1) % loop.length;
                     Vector2D pPoint      = new Vector2D(previous3D.dotProduct(u), previous3D.dotProduct(v));
                     while (current < loop.length) {
 
-                        final Vector3D current3D = plane.toSpace(loop[current]);
+                        final Vector3D current3D = facet.getHyperplane().toSpace(loop[current]);
                         final Vector2D  cPoint    = new Vector2D(current3D.dotProduct(u),
                                                                  current3D.dotProduct(v));
                         final org.hipparchus.geometry.euclidean.twod.Line line =
                             new org.hipparchus.geometry.euclidean.twod.Line(pPoint, cPoint, tolerance);
-                        SubHyperplane<Euclidean2D, Vector2D> edge = line.wholeHyperplane();
+                        SubLine edge = line.wholeHyperplane();
 
                         if (closed || (previous != 1)) {
                             // the previous point is a real vertex
@@ -249,7 +244,8 @@ private void addContribution(final SubHyperplane<Euclidean3D, Vector3D> facet) {
                 final PolygonsSet projectedFacet = new PolygonsSet(edges, tolerance);
 
                 // add the contribution of the facet to the global outline
-                projected = (PolygonsSet) new RegionFactory<Euclidean2D, Vector2D>().union(projected, projectedFacet);
+                final RegionFactory<Euclidean2D, Vector2D, Line, SubLine> factory = new RegionFactory<>();
+                projected = (PolygonsSet) factory.union(projected, projectedFacet);
 
             }
         }

hipparchus-geometry/src/main/java/org/hipparchus/geometry/euclidean/threed/OutlineExtractor.java

@@ -26,6 +26,7 @@
 import org.hipparchus.geometry.euclidean.oned.Vector1D;
 import org.hipparchus.geometry.euclidean.twod.Euclidean2D;
 import org.hipparchus.geometry.euclidean.twod.PolygonsSet;
+import org.hipparchus.geometry.euclidean.twod.SubLine;
 import org.hipparchus.geometry.euclidean.twod.Vector2D;
 import org.hipparchus.geometry.partitioning.Embedding;
 import org.hipparchus.geometry.partitioning.Hyperplane;
@@ -35,8 +36,8 @@
 /** The class represent planes in a three dimensional space.
  */
 public class Plane
-    implements Hyperplane<Euclidean3D, Vector3D>,
-               Embedding<Euclidean3D, Vector3D, Euclidean2D, Vector2D> {
+    implements Hyperplane<Euclidean3D, Vector3D, Plane, SubPlane>,
+               Embedding<Euclidean3D, Vector3D,  Euclidean2D, Vector2D> {
 
     /** Offset of the origin with respect to the plane. */
     private double originOffset;
@@ -414,7 +415,8 @@ public SubPlane wholeHyperplane() {
     /** {@inheritDoc} */
     @Override
     public SubPlane emptyHyperplane() {
-        return new SubPlane(this, new RegionFactory<Euclidean2D, Vector2D>().getComplement(new PolygonsSet(tolerance)));
+        final RegionFactory<Euclidean2D, Vector2D, org.hipparchus.geometry.euclidean.twod.Line, SubLine> factory = new RegionFactory<>();
+        return new SubPlane(this, factory.getComplement(new PolygonsSet(tolerance)));
     }
 
     /** Build a region covering the whole space.
@@ -467,8 +469,8 @@ public double getOffset(final Vector3D point) {
      * the same orientation
      */
     @Override
-    public boolean sameOrientationAs(final Hyperplane<Euclidean3D, Vector3D> other) {
-        return (((Plane) other).w).dotProduct(w) > 0.0;
+    public boolean sameOrientationAs(final Plane other) {
+        return other.w.dotProduct(w) > 0.0;
     }
 
 }