test: refactorings and tests + a lot of small bugs fixed

Author: mrmaxguns

freepapermaps/src/main/java/io/github/mrmaxguns/freepapermaps/geometry/BaseCoordinate.java

@@ -5,7 +5,7 @@
  * BoundingBox represents a box in space defined as the rectangular region between a top left point and a bottom right
  * point. BoundingBoxes are immutable, just like Coordinates.
  */
-public class BoundingBox<C extends BaseCoordinate<C>> {
+public class BoundingBox<C extends Coordinate<?>> {
     /** The top left corner (minimum x/lon, maximum y/lat). */
     private final C topLeftCorner;
     /** The bottom right corner (maximum x/lon, minimum y/lat). */
@@ -56,28 +56,40 @@ public double getHeight() {
 
     public double getMaxLat() { return getMaxY(); }
 
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof BoundingBox<?>)) { return false; }
+        return equals((BoundingBox<?>) other);
+    }
+
     /** Returns true if the top left and bottom right coordinates of both bounding boxes are exactly equal. */
-    public boolean equals(BoundingBox<C> other) {
+    public boolean equals(BoundingBox<?> other) {
         return equals(other, 0.0);
     }
 
     /**
      * Returns true if the top left and bottom right coordinates of both bounding boxes are within (inclusive) of some
      * <code>epsilon</code>.
      */
-    public boolean equals(BoundingBox<C> other, double epsilon) {
+    public boolean equals(BoundingBox<?> other, double epsilon) {
         return equals(other, epsilon, epsilon);
     }
 
     /**
      * Returns true if the top left and bottom right coordinates of both bounding boxes are within (inclusive) of some
      * x and y epsilon.
      */
-    public boolean equals(BoundingBox<C> other, double epsilonX, double epsilonY) {
+    public boolean equals(BoundingBox<?> other, double epsilonX, double epsilonY) {
         return topLeftCorner.equals(other.getTopLeftCorner(), epsilonX, epsilonY) &&
                bottomRightCorner.equals(other.getBottomRightCorner(), epsilonX, epsilonY);
     }
 
+    /** Returns true if both the top left and bottom right coordinates of both bounding boxes are almost equal. */
+    public boolean almostEquals(BoundingBox<?> other) {
+        return topLeftCorner.almostEquals(other.getTopLeftCorner()) &&
+               bottomRightCorner.almostEquals(other.getBottomRightCorner());
+    }
+
     @Override
     public String toString() {
         return "BoundingBox(topLeftCorner=" + topLeftCorner + ", bottomRightCorner=" + bottomRightCorner + ")";

freepapermaps/src/main/java/io/github/mrmaxguns/freepapermaps/geometry/BoundingBox.java

@@ -1,11 +1,106 @@
 package io.github.mrmaxguns.freepapermaps.geometry;
 
-public interface Coordinate {
-    double getX();
+/** Coordinate represents an x/y or longitude/latitude position in space. Coordinates are immutable. */
+public abstract class Coordinate<T extends Coordinate<T>> {
+    /** Represents x or longitude. */
+    private final double x;
+    /** Represents y or latitude. */
+    private final double y;
 
-    double getY();
+    public Coordinate(double xOrLon, double yOrLat) {
+        x = xOrLon;
+        y = yOrLat;
+    }
 
-    double getLon();
+    /**
+     * Creates an instance of a Coordinate subclass. This is needed so that methods defined in the abstract
+     * Coordinate class can create instances of the subclass.
+     */
+    protected abstract T createInstance(double xOrLon, double yOrLat);
 
-    double getLat();
+    public double getX() {
+        return x;
+    }
+
+    public double getY() {
+        return y;
+    }
+
+    public double getLon() {
+        return x;
+    }
+
+    public double getLat() {
+        return y;
+    }
+
+    /** Returns a new Coordinate which is the sum of this one and <code>other</code>. */
+    public T add(T other) {
+        return createInstance(x + other.getX(), y + other.getY());
+    }
+
+    /** Returns a new Coordinate which is the result of this coordinate minus <code>other</code>. */
+    public T subtract(T other) {
+        return createInstance(x - other.getX(), y - other.getY());
+    }
+
+    /** Returns a new Coordinate whose components are multiplied by <code>scaleFactor</code>. */
+    public T scale(double scaleFactor) {
+        return createInstance(x * scaleFactor, y * scaleFactor);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof Coordinate<?>)) { return false; }
+        return equals((Coordinate<?>) other);
+    }
+
+    /** Returns true if both coordinates are exactly equal. */
+    public boolean equals(Coordinate<?> other) {
+        return equals(other, 0.0);
+    }
+
+    /** Returns true if both coordinate x and y values are within (inclusive) of some <code>epsilon</code>. */
+    public boolean equals(Coordinate<?> other, double epsilon) {
+        return equals(other, epsilon, epsilon);
+    }
+
+    /** Returns true if both coordinate x and y values are within (inclusive) of some x and y epsilon, respectively. */
+    public boolean equals(Coordinate<?> other, double epsilonX, double epsilonY) {
+        if (this == other) {
+            return true;
+        }
+        return (Math.abs(x - other.getX()) <= epsilonX) && (Math.abs(y - other.getY()) <= epsilonY);
+    }
+
+    /**
+     * Returns true if both coordinate x and y values are almost equal for the purposes of geography, regardless of
+     * their magnitude.
+     */
+    public boolean almostEquals(Coordinate<?> other) {
+        return valuesAlmostEqual(x, other.getX()) && valuesAlmostEqual(y, other.getY());
+    }
+
+    /** Returns true if two doubles are almost equal, given hard-coded minimum and relative tolerances. */
+    private boolean valuesAlmostEqual(double a, double b) {
+        final double absEpsilon = 1e-12; // minimum absolute threshold
+        final double relEpsilon = 1e-9;  // relative tolerance
+
+        double diff = Math.abs(a - b);
+        double largest = Math.max(Math.abs(a), Math.abs(b));
+
+        return diff <= Math.max(absEpsilon, largest * relEpsilon);
+    }
+
+    /** Returns a short, human-readable identifier of the Coordinate's type (e.g. WGS84). */
+    public abstract String getCoordinateType();
+
+    /** Returns a string representing an appropriate unit for this coordinate (e.g. m). */
+    public abstract String getCoordinateUnit();
+
+    /** Returns a String representation of this Coordinate. */
+    @Override
+    public String toString() {
+        return getCoordinateType() + "(" + x + getCoordinateUnit() + ", " + y + getCoordinateUnit() + ")";
+    }
 }

freepapermaps/src/main/java/io/github/mrmaxguns/freepapermaps/geometry/Coordinate.java

@@ -3,12 +3,22 @@
 import io.github.mrmaxguns.freepapermaps.osm.TagList;
 
 
+/** Represents a geometry loosely based on both the OSM and SimpleFeatures specifications. */
 public abstract class Geometry {
+    /** A list of OSM tags associated with this <code>Geometry</code>. */
     private final TagList tags = new TagList();
 
     public TagList getTags() {
         return tags;
     }
 
+    /** Returns true if the <code>Geometry</code> passes basic validation checks that are essential for proper
+     * rendering. */
     public abstract boolean isValid();
+
+    /**
+     * Returns true if the <code>Geometry</code> passes more computationally expensive validation checks that may not
+     * be necessary for rendering and/or handle rare edge cases.
+     */
+    public abstract boolean isCompletelyValid();
 }

freepapermaps/src/main/java/io/github/mrmaxguns/freepapermaps/geometry/Geometry.java

@@ -1,17 +1,31 @@
 package io.github.mrmaxguns.freepapermaps.geometry;
 
 
-public record LineSegment(Coordinate edge1, Coordinate edge2) {
-    // Based on https://stackoverflow.com/a/3842240/13501679 and https://www.geeksforgeeks
-    // .org/dsa/check-if-two-given-line-segments-intersect/
+import io.github.mrmaxguns.freepapermaps.projections.RawCoordinate;
+
+
+public record LineSegment(Coordinate<?> edge1, Coordinate<?> edge2) {
+    // Based on https://stackoverflow.com/a/3842240/13501679 and
+    // https://www.geeksforgeeks.org/dsa/check-if-two-given-line-segments-intersect/
     public boolean intersects(LineSegment other) {
         Orientation o1 = getOrientation(edge1, edge2, other.edge1);
         Orientation o2 = getOrientation(edge1, edge2, other.edge2);
         Orientation o3 = getOrientation(other.edge1, other.edge2, edge1);
         Orientation o4 = getOrientation(other.edge1, other.edge2, edge2);
 
         if (o1 != o2 && o3 != o4) {
-            return false;
+            // Calculate intersection point, since we don't count simply sharing the same node as an intersection.
+            Coordinate<?> intersection = computeIntersectionPoint(this.edge1, this.edge2, other.edge1, other.edge2);
+
+            if (intersection == null) {
+                // The intersection should only be null if the lines are parallel, in which case the original condition
+                // of this if-statement should not have been triggered.
+                throw new RuntimeException("Failed to determine whether line segments intersect.");
+            }
+
+            // If intersection is exactly an endpoint, ignore it.
+            return !intersection.equals(edge1) && !intersection.equals(edge2) && !intersection.equals(other.edge1) &&
+                   !intersection.equals(other.edge2);  // touching at endpoint only
         }
 
         // Special cases
@@ -32,12 +46,12 @@ public boolean intersects(LineSegment other) {
     }
 
     // Returns true if q is on the segment between p and r.
-    private boolean onSegment(Coordinate p, Coordinate q, Coordinate r) {
+    private boolean onSegment(Coordinate<?> p, Coordinate<?> q, Coordinate<?> r) {
         return (q.getX() <= Math.max(p.getX(), r.getX()) && q.getX() >= Math.min(p.getX(), r.getX()) &&
                 q.getY() <= Math.max(p.getY(), r.getY()) && q.getY() >= Math.min(p.getY(), r.getY()));
     }
 
-    private Orientation getOrientation(Coordinate p, Coordinate q, Coordinate r) {
+    private Orientation getOrientation(Coordinate<?> p, Coordinate<?> q, Coordinate<?> r) {
         double t1 = (q.getY() - p.getY()) * (r.getX() - q.getX());
         double t2 = (q.getX() - p.getX()) * (r.getY() - q.getY());
         double determinant = t1 - t2;
@@ -53,5 +67,31 @@ private Orientation getOrientation(Coordinate p, Coordinate q, Coordinate r) {
         return determinant > 0 ? Orientation.Clockwise : Orientation.Counterclockwise;
     }
 
+    public boolean isDegenerate() {
+        return edge1.equals(edge2);
+    }
+
     private enum Orientation {Collinear, Clockwise, Counterclockwise}
+
+    private Coordinate<?> computeIntersectionPoint(Coordinate<?> p1, Coordinate<?> q1, Coordinate<?> p2,
+                                                   Coordinate<?> q2) {
+        double A1 = q1.getY() - p1.getY();
+        double B1 = p1.getX() - q1.getX();
+        double C1 = A1 * p1.getX() + B1 * p1.getY();
+
+        double A2 = q2.getY() - p2.getY();
+        double B2 = p2.getX() - q2.getX();
+        double C2 = A2 * p2.getX() + B2 * p2.getY();
+
+        double det = A1 * B2 - A2 * B1;
+
+        if (det == 0) {
+            // Lines are parallel
+            return null;
+        } else {
+            double x = (B2 * C1 - B1 * C2) / det;
+            double y = (A1 * C2 - A2 * C1) / det;
+            return new RawCoordinate(x, y);
+        }
+    }
 }