GeometryUtilsExample.java

Go to the documentation of this file.

package com.navigine.examples;
 
import java.util.Arrays;
import java.util.List;

public class GeometryUtilsExample {
    
    public GeometryUtilsExample() {
        demonstrateGeometryUtilsMethods();
    }

    public void demonstrateGeometryUtilsMethods() {
        System.out.println("=== GeometryUtils Methods ===");
        
        demonstratePointOperations();
        demonstrateGlobalPointOperations();
        demonstrateSegmentOperations();
        demonstratePolygonOperations();
        demonstrateLineOperations();
        demonstrateAdvancedGeometryOperations();
    }

    public void demonstratePointOperations() {
        System.out.println("--- Point Operations ---");
 
        // [java_Point_constructor]
        // Create points with x, y coordinates
        Point point1 = new Point(10.0, 20.0);
        Point point2 = new Point(30.0, 40.0);
        Point point3 = new Point(50.0, 60.0);
        System.out.println("Created points: P1(" + point1.getX() + ", " + point1.getY() + 
                          "), P2(" + point2.getX() + ", " + point2.getY() + 
                          "), P3(" + point3.getX() + ", " + point3.getY() + ")");
        // [java_Point_constructor]
 
        // [java_Point_getX]
        // Get X coordinate
        double x1 = point1.getX();
        System.out.println("Point1 X coordinate: " + x1);
        // [java_Point_getX]
 
        // [java_Point_getY]
        // Get Y coordinate
        double y1 = point1.getY();
        System.out.println("Point1 Y coordinate: " + y1);
        // [java_Point_getY]
 
        // [java_GeometryUtils_distanceBetweenPoints]
        // Calculate distance between points
        double distance = GeometryUtils.distanceBetweenPoints(point1, point2);
        System.out.printf("Distance between P1 and P2: %.2f meters%n", distance);
        // [java_GeometryUtils_distanceBetweenPoints]
 
        // Create more points for testing
        List<Point> testPoints = Arrays.asList(
            new Point(0.0, 0.0),
            new Point(10.0, 0.0),
            new Point(10.0, 10.0),
            new Point(0.0, 10.0),
            new Point(5.0, 5.0)
        );
 
        System.out.println("Test points created for further calculations");
    }

    public void demonstrateGlobalPointOperations() {
        System.out.println("--- GlobalPoint Operations ---");
 
        // [java_GlobalPoint_constructor]
        // Create global points with latitude, longitude
        GlobalPoint globalPoint1 = new GlobalPoint(55.7558, 37.6176); // Moscow
        GlobalPoint globalPoint2 = new GlobalPoint(59.9311, 30.3609); // St. Petersburg
        GlobalPoint globalPoint3 = new GlobalPoint(55.7522, 37.6156); // Moscow center
        System.out.println("Created global points: GP1(" + globalPoint1.getLatitude() + ", " + globalPoint1.getLongitude() + 
                          "), GP2(" + globalPoint2.getLatitude() + ", " + globalPoint2.getLongitude() + ")");
        // [java_GlobalPoint_constructor]
 
        // [java_GlobalPoint_getLatitude]
        // Get latitude
        double lat1 = globalPoint1.getLatitude();
        System.out.println("GlobalPoint1 latitude: " + lat1);
        // [java_GlobalPoint_getLatitude]
 
        // [java_GlobalPoint_getLongitude]
        // Get longitude
        double lon1 = globalPoint1.getLongitude();
        System.out.println("GlobalPoint1 longitude: " + lon1);
        // [java_GlobalPoint_getLongitude]
 
        // [java_GeometryUtils_distanceBetweenGlobalPoints]
        // Calculate distance between global points
        double globalDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint2);
        System.out.printf("Distance between Moscow and St. Petersburg: %.2f meters%n", globalDistance);
        // [java_GeometryUtils_distanceBetweenGlobalPoints]
 
        // Calculate distance between nearby points
        double nearbyDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint3);
        System.out.printf("Distance between Moscow points: %.2f meters%n", nearbyDistance);
    }

    public void demonstrateSegmentOperations() {
        System.out.println("--- Segment Operations ---");
 
        // Create points for segments
        Point start1 = new Point(0.0, 0.0);
        Point end1 = new Point(10.0, 10.0);
        Point start2 = new Point(0.0, 10.0);
        Point end2 = new Point(10.0, 0.0);
        Point testPoint = new Point(5.0, 5.0);
 
        // [java_Segment_constructor]
        // Create segments
        Segment segment1 = new Segment(start1, end1);
        Segment segment2 = new Segment(start2, end2);
        System.out.println("Created segments: S1((" + segment1.getStart().getX() + ", " + segment1.getStart().getY() + 
                          ") -> (" + segment1.getEnd().getX() + ", " + segment1.getEnd().getY() + 
                          ")), S2((" + segment2.getStart().getX() + ", " + segment2.getStart().getY() + 
                          ") -> (" + segment2.getEnd().getX() + ", " + segment2.getEnd().getY() + "))");
        // [java_Segment_constructor]
 
        // [java_Segment_getStart]
        // Get start point
        Point segment1Start = segment1.getStart();
        System.out.println("Segment1 start point: (" + segment1Start.getX() + ", " + segment1Start.getY() + ")");
        // [java_Segment_getStart]
 
        // [java_Segment_getEnd]
        // Get end point
        Point segment1End = segment1.getEnd();
        System.out.println("Segment1 end point: (" + segment1End.getX() + ", " + segment1End.getY() + ")");
        // [java_Segment_getEnd]
 
        // [java_GeometryUtils_segmentLength]
        // Calculate segment length
        double length1 = GeometryUtils.segmentLength(segment1);
        double length2 = GeometryUtils.segmentLength(segment2);
        System.out.printf("Segment1 length: %.2f meters%n", length1);
        System.out.printf("Segment2 length: %.2f meters%n", length2);
        // [java_GeometryUtils_segmentLength]
 
        // [java_GeometryUtils_segmentPointDistance]
        // Calculate distance from segment to point
        double distanceToPoint = GeometryUtils.segmentPointDistance(segment1, testPoint);
        System.out.printf("Distance from segment1 to test point: %.2f meters%n", distanceToPoint);
        // [java_GeometryUtils_segmentPointDistance]
 
        // [java_GeometryUtils_segmentIntersectsSegment]
        // Check if segments intersect
        boolean intersects = GeometryUtils.segmentIntersectsSegment(segment1, segment2);
        System.out.println("Segments intersect: " + intersects);
        // [java_GeometryUtils_segmentIntersectsSegment]
 
        // [java_GeometryUtils_segmentIntersectionSegment]
        // Calculate intersection point
        Point intersection = GeometryUtils.segmentIntersectionSegment(segment1, segment2);
        System.out.printf("Intersection point: (%.2f, %.2f)%n", intersection.getX(), intersection.getY());
        // [java_GeometryUtils_segmentIntersectionSegment]
 
        // [java_GeometryUtils_divisionRatioBySegment]
        // Calculate division ratio
        double divisionRatio = GeometryUtils.divisionRatioBySegment(segment1, segment2);
        System.out.printf("Division ratio: %.2f%n", divisionRatio);
        // [java_GeometryUtils_divisionRatioBySegment]
 
        // [java_GeometryUtils_getRatioPoint]
        // Get point at specific ratio
        double ratio = 0.5;
        Point ratioPoint = GeometryUtils.getRatioPoint(segment1, ratio);
        System.out.printf("Point at ratio %.1f: (%.2f, %.2f)%n", ratio, ratioPoint.getX(), ratioPoint.getY());
        // [java_GeometryUtils_getRatioPoint]
 
        // [java_GeometryUtils_getProjectionRatio]
        // Calculate projection ratio
        double projectionRatio = GeometryUtils.getProjectionRatio(segment1, testPoint);
        System.out.printf("Projection ratio: %.2f%n", projectionRatio);
        // [java_GeometryUtils_getProjectionRatio]
    }

    public void demonstratePolygonOperations() {
        System.out.println("--- Polygon Operations ---");
 
        // Create points for polygon
        List<Point> polygonPoints = Arrays.asList(
            new Point(0.0, 0.0),
            new Point(10.0, 0.0),
            new Point(10.0, 10.0),
            new Point(0.0, 10.0)
        );
 
        // [java_Polygon_constructor]
        // Create polygon
        Polygon polygon = new Polygon(polygonPoints);
        System.out.println("Created polygon with " + polygon.getPoints().size() + " points");
        // [java_Polygon_constructor]
 
        // [java_Polygon_getPoints]
        // Get polygon points
        List<Point> points = polygon.getPoints();
        System.out.println("Polygon points: " + points.stream()
            .map(p -> "(" + p.getX() + ", " + p.getY() + ")")
            .reduce("", (a, b) -> a + (a.isEmpty() ? "" : ", ") + b));
        // [java_Polygon_getPoints]
 
        // [java_GeometryUtils_polygonArea]
        // Calculate polygon area
        double area = GeometryUtils.polygonArea(polygon);
        System.out.printf("Polygon area: %.2f square meters%n", area);
        // [java_GeometryUtils_polygonArea]
 
        // [java_GeometryUtils_polygonCenter]
        // Calculate polygon center
        Point center = GeometryUtils.polygonCenter(polygon);
        System.out.printf("Polygon center: (%.2f, %.2f)%n", center.getX(), center.getY());
        // [java_GeometryUtils_polygonCenter]
 
        // [java_GeometryUtils_polygonContainsPoint]
        // Check if polygon contains point
        Point insidePoint = new Point(5.0, 5.0);
        Point outsidePoint = new Point(15.0, 15.0);
        
        boolean containsInside = GeometryUtils.polygonContainsPoint(polygon, insidePoint);
        boolean containsOutside = GeometryUtils.polygonContainsPoint(polygon, outsidePoint);
        
        System.out.println("Polygon contains inside point: " + containsInside);
        System.out.println("Polygon contains outside point: " + containsOutside);
        // [java_GeometryUtils_polygonContainsPoint]
 
        // Create complex polygon
        List<Point> complexPolygonPoints = Arrays.asList(
            new Point(0.0, 0.0),
            new Point(20.0, 0.0),
            new Point(20.0, 20.0),
            new Point(10.0, 10.0),
            new Point(0.0, 20.0)
        );
        Polygon complexPolygon = new Polygon(complexPolygonPoints);
        
        double complexArea = GeometryUtils.polygonArea(complexPolygon);
        Point complexCenter = GeometryUtils.polygonCenter(complexPolygon);
        
        System.out.printf("Complex polygon area: %.2f square meters%n", complexArea);
        System.out.printf("Complex polygon center: (%.2f, %.2f)%n", complexCenter.getX(), complexCenter.getY());
    }

    public void demonstrateLineOperations() {
        System.out.println("--- Line Operations ---");
 
        // Create segments for line
        List<Segment> lineSegments = Arrays.asList(
            new Segment(new Point(0.0, 0.0), new Point(10.0, 10.0)),
            new Segment(new Point(10.0, 10.0), new Point(20.0, 5.0)),
            new Segment(new Point(20.0, 5.0), new Point(30.0, 15.0))
        );
 
        // [java_Line_constructor]
        // Create line
        Line line = new Line(lineSegments);
        System.out.println("Created line with " + line.getSegments().size() + " segments");
        // [java_Line_constructor]
 
        // [java_Line_getSegments]
        // Get line segments
        List<Segment> segments = line.getSegments();
        System.out.println("Line segments: " + segments.size() + " segments");
        // [java_Line_getSegments]
 
        // Calculate total length of line
        double totalLength = 0.0;
        for (Segment segment : segments) {
            totalLength += GeometryUtils.segmentLength(segment);
        }
        System.out.printf("Total line length: %.2f meters%n", totalLength);
 
        // Create complex line
        List<Segment> complexLineSegments = Arrays.asList(
            new Segment(new Point(0.0, 0.0), new Point(5.0, 5.0)),
            new Segment(new Point(5.0, 5.0), new Point(10.0, 0.0)),
            new Segment(new Point(10.0, 0.0), new Point(15.0, 10.0)),
            new Segment(new Point(15.0, 10.0), new Point(20.0, 5.0))
        );
        Line complexLine = new Line(complexLineSegments);
        
        double complexTotalLength = 0.0;
        for (Segment segment : complexLine.getSegments()) {
            complexTotalLength += GeometryUtils.segmentLength(segment);
        }
        System.out.printf("Complex line total length: %.2f meters%n", complexTotalLength);
    }

    public void demonstrateAdvancedGeometryOperations() {
        System.out.println("--- Advanced Geometry Operations ---");
 
        // Test distance calculations with various scenarios
        demonstrateDistanceCalculations();
        
        // Test intersection scenarios
        demonstrateIntersectionScenarios();
        
        // Test polygon operations with different shapes
        demonstratePolygonScenarios();
        
        // Test projection and ratio calculations
        demonstrateProjectionCalculations();
    }

    public void demonstrateDistanceCalculations() {
        System.out.println("--- Distance Calculations ---");
 
        // Test point distances
        Point origin = new Point(0.0, 0.0);
        List<Point> testPoints = Arrays.asList(
            new Point(3.0, 4.0),  // Should be 5.0 distance
            new Point(6.0, 8.0),  // Should be 10.0 distance
            new Point(1.0, 1.0)   // Should be sqrt(2) distance
        );
 
        for (Point testPoint : testPoints) {
            double distance = GeometryUtils.distanceBetweenPoints(origin, testPoint);
            System.out.printf("Distance from origin to (%.1f, %.1f): %.2f meters%n", 
                             testPoint.getX(), testPoint.getY(), distance);
        }
 
        // Test global point distances
        GlobalPoint moscow = new GlobalPoint(55.7558, 37.6176);
        GlobalPoint london = new GlobalPoint(51.5074, -0.1278);
        GlobalPoint tokyo = new GlobalPoint(35.6762, 139.6503);
 
        double moscowLondon = GeometryUtils.distanceBetweenGlobalPoints(moscow, london);
        double moscowTokyo = GeometryUtils.distanceBetweenGlobalPoints(moscow, tokyo);
        
        System.out.printf("Moscow to London: %.2f km%n", moscowLondon / 1000);
        System.out.printf("Moscow to Tokyo: %.2f km%n", moscowTokyo / 1000);
    }

    public void demonstrateIntersectionScenarios() {
        System.out.println("--- Intersection Scenarios ---");
 
        // Parallel segments (should not intersect)
        Segment parallel1 = new Segment(new Point(0.0, 0.0), new Point(10.0, 0.0));
        Segment parallel2 = new Segment(new Point(0.0, 5.0), new Point(10.0, 5.0));
        
        boolean parallelIntersects = GeometryUtils.segmentIntersectsSegment(parallel1, parallel2);
        System.out.println("Parallel segments intersect: " + parallelIntersects);
 
        // Perpendicular segments (should intersect)
        Segment perpendicular1 = new Segment(new Point(0.0, 0.0), new Point(10.0, 0.0));
        Segment perpendicular2 = new Segment(new Point(5.0, -5.0), new Point(5.0, 5.0));
        
        boolean perpendicularIntersects = GeometryUtils.segmentIntersectsSegment(perpendicular1, perpendicular2);
        System.out.println("Perpendicular segments intersect: " + perpendicularIntersects);
        
        if (perpendicularIntersects) {
            Point intersection = GeometryUtils.segmentIntersectionSegment(perpendicular1, perpendicular2);
            System.out.printf("Intersection point: (%.2f, %.2f)%n", intersection.getX(), intersection.getY());
        }
 
        // Overlapping segments
        Segment overlap1 = new Segment(new Point(0.0, 0.0), new Point(10.0, 0.0));
        Segment overlap2 = new Segment(new Point(5.0, 0.0), new Point(15.0, 0.0));
        
        boolean overlapIntersects = GeometryUtils.segmentIntersectsSegment(overlap1, overlap2);
        System.out.println("Overlapping segments intersect: " + overlapIntersects);
    }

    public void demonstratePolygonScenarios() {
        System.out.println("--- Polygon Scenarios ---");
 
        // Regular square
        List<Point> square = Arrays.asList(
            new Point(0.0, 0.0),
            new Point(10.0, 0.0),
            new Point(10.0, 10.0),
            new Point(0.0, 10.0)
        );
        Polygon squarePolygon = new Polygon(square);
        
        double squareArea = GeometryUtils.polygonArea(squarePolygon);
        Point squareCenter = GeometryUtils.polygonCenter(squarePolygon);
        
        System.out.printf("Square area: %.2f square meters%n", squareArea);
        System.out.printf("Square center: (%.2f, %.2f)%n", squareCenter.getX(), squareCenter.getY());
 
        // Triangle
        List<Point> triangle = Arrays.asList(
            new Point(0.0, 0.0),
            new Point(10.0, 0.0),
            new Point(5.0, 10.0)
        );
        Polygon trianglePolygon = new Polygon(triangle);
        
        double triangleArea = GeometryUtils.polygonArea(trianglePolygon);
        Point triangleCenter = GeometryUtils.polygonCenter(trianglePolygon);
        
        System.out.printf("Triangle area: %.2f square meters%n", triangleArea);
        System.out.printf("Triangle center: (%.2f, %.2f)%n", triangleCenter.getX(), triangleCenter.getY());
 
        // Test point containment
        Point insideSquare = new Point(5.0, 5.0);
        Point outsideSquare = new Point(15.0, 15.0);
        
        boolean containsInside = GeometryUtils.polygonContainsPoint(squarePolygon, insideSquare);
        boolean containsOutside = GeometryUtils.polygonContainsPoint(squarePolygon, outsideSquare);
        
        System.out.println("Square contains (5,5): " + containsInside);
        System.out.println("Square contains (15,15): " + containsOutside);
    }

    public void demonstrateProjectionCalculations() {
        System.out.println("--- Projection Calculations ---");
 
        Segment segment = new Segment(new Point(0.0, 0.0), new Point(10.0, 10.0));
        
        // Test different ratio points
        List<Double> ratios = Arrays.asList(0.0, 0.25, 0.5, 0.75, 1.0);
        
        for (Double ratio : ratios) {
            Point ratioPoint = GeometryUtils.getRatioPoint(segment, ratio);
            System.out.printf("Ratio %.2f: (%.2f, %.2f)%n", ratio, ratioPoint.getX(), ratioPoint.getY());
        }
 
        // Test projection ratio calculation
        Point testPoint = new Point(5.0, 5.0);
        double projectionRatio = GeometryUtils.getProjectionRatio(segment, testPoint);
        System.out.printf("Projection ratio for point (5,5): %.2f%n", projectionRatio);
 
        // Test distance from segment to point
        Point offSegmentPoint = new Point(5.0, 0.0);
        double distanceToOffPoint = GeometryUtils.segmentPointDistance(segment, offSegmentPoint);
        System.out.printf("Distance from segment to point (5,0): %.2f meters%n", distanceToOffPoint);
    }

    public void runExample() {
        System.out.println("=== GeometryUtils Example ===");
        
        // Wait a bit for processing
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("=== Example completed ===");
    }

    public static void main(String[] args) {
        GeometryUtilsExample example = new GeometryUtilsExample();
        example.runExample();
    }
}