geometry_utils_example.dart

Go to the documentation of this file.

import 'dart:async';
import 'dart:io';
import 'dart:math';
import 'package:navigine_sdk/navigine_sdk.dart';

class GeometryUtilsExample {
  GeometryUtilsExample() {
    _demonstrateGeometryUtilsMethods();
  }

  void _demonstrateGeometryUtilsMethods() {
    print("=== GeometryUtils Methods ===");
    
    _demonstratePointOperations();
    _demonstrateGlobalPointOperations();
    _demonstrateBoundingBoxOperations();
    _demonstrateSegmentOperations();
    _demonstratePolygonOperations();
    _demonstrateLineOperations();
    _demonstrateAdvancedGeometryOperations();
  }

  void _demonstratePointOperations() {
    print("--- Point Operations ---");
 
    // [dart_Point_constructor]
    // Create points with x, y coordinates
    Point point1 = Point(10.0, 20.0);
    Point point2 = Point(30.0, 40.0);
    Point point3 = Point(50.0, 60.0);
    print("Created points: P1(${point1.x}, ${point1.y}), P2(${point2.x}, ${point2.y}), P3(${point3.x}, ${point3.y})");
    // [dart_Point_constructor]
 
    // [dart_Point_getX]
    // Get X coordinate
    double x1 = point1.x;
    print("Point1 X coordinate: $x1");
    // [dart_Point_getX]
 
    // [dart_Point_getY]
    // Get Y coordinate
    double y1 = point1.y;
    print("Point1 Y coordinate: $y1");
    // [dart_Point_getY]
 
    // [dart_GeometryUtils_distanceBetweenPoints]
    // Calculate distance between points
    double distance = GeometryUtils.distanceBetweenPoints(point1, point2);
    print("Distance between P1 and P2: ${distance.toStringAsFixed(2)} meters");
    // [dart_GeometryUtils_distanceBetweenPoints]
 
    // Create more points for testing
    List<Point> testPoints = [
      Point(0.0, 0.0),
      Point(10.0, 0.0),
      Point(10.0, 10.0),
      Point(0.0, 10.0),
      Point(5.0, 5.0),
    ];
 
    print("Test points created for further calculations");
  }

  void _demonstrateBoundingBoxOperations() {
    print("--- BoundingBox Operations ---");
 
    Point bottomLeft = Point(0.0, 0.0);
    Point topRight = Point(10.0, 20.0);
 
    // [dart_BoundingBox_constructor]
    BoundingBox boundingBox = BoundingBox(bottomLeft, topRight);
    print("Created bounding box: bottomLeft(${boundingBox.bottomLeft.x}, ${boundingBox.bottomLeft.y}), topRight(${boundingBox.topRight.x}, ${boundingBox.topRight.y})");
    // [dart_BoundingBox_constructor]
 
    // [dart_BoundingBox_getBottomLeft]
    Point leftCorner = boundingBox.bottomLeft;
    print("Bottom-left corner: (${leftCorner.x}, ${leftCorner.y})");
    // [dart_BoundingBox_getBottomLeft]
 
    // [dart_BoundingBox_getTopRight]
    Point rightCorner = boundingBox.topRight;
    print("Top-right corner: (${rightCorner.x}, ${rightCorner.y})");
    // [dart_BoundingBox_getTopRight]
  }

  void _demonstrateGlobalPointOperations() {
    print("--- GlobalPoint Operations ---");
 
    // [dart_GlobalPoint_constructor]
    // Create global points with latitude, longitude
    GlobalPoint globalPoint1 = GlobalPoint(55.7558, 37.6176); // Moscow
    GlobalPoint globalPoint2 = GlobalPoint(59.9311, 30.3609); // St. Petersburg
    GlobalPoint globalPoint3 = GlobalPoint(55.7522, 37.6156); // Moscow center
    print("Created global points: GP1(${globalPoint1.latitude}, ${globalPoint1.longitude}), GP2(${globalPoint2.latitude}, ${globalPoint2.longitude})");
    // [dart_GlobalPoint_constructor]
 
    // [dart_GlobalPoint_getLatitude]
    // Get latitude
    double lat1 = globalPoint1.latitude;
    print("GlobalPoint1 latitude: $lat1");
    // [dart_GlobalPoint_getLatitude]
 
    // [dart_GlobalPoint_getLongitude]
    // Get longitude
    double lon1 = globalPoint1.longitude;
    print("GlobalPoint1 longitude: $lon1");
    // [dart_GlobalPoint_getLongitude]
 
    // [dart_GeometryUtils_distanceBetweenGlobalPoints]
    // Calculate distance between global points
    double globalDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint2);
    print("Distance between Moscow and St. Petersburg: ${globalDistance.toStringAsFixed(2)} meters");
    // [dart_GeometryUtils_distanceBetweenGlobalPoints]
 
    // Calculate distance between nearby points
    double nearbyDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint3);
    print("Distance between Moscow points: ${nearbyDistance.toStringAsFixed(2)} meters");
  }

  void _demonstrateSegmentOperations() {
    print("--- Segment Operations ---");
 
    // Create points for segments
    Point start1 = Point(0.0, 0.0);
    Point end1 = Point(10.0, 10.0);
    Point start2 = Point(0.0, 10.0);
    Point end2 = Point(10.0, 0.0);
    Point testPoint = Point(5.0, 5.0);
 
    // [dart_Segment_constructor]
    // Create segments
    Segment segment1 = Segment(start1, end1);
    Segment segment2 = Segment(start2, end2);
    print("Created segments: S1((${segment1.start.x}, ${segment1.start.y}) -> (${segment1.end.x}, ${segment1.end.y})), S2((${segment2.start.x}, ${segment2.start.y}) -> (${segment2.end.x}, ${segment2.end.y}))");
    // [dart_Segment_constructor]
 
    // [dart_Segment_getStart]
    // Get start point
    Point segment1Start = segment1.start;
    print("Segment1 start point: (${segment1Start.x}, ${segment1Start.y})");
    // [dart_Segment_getStart]
 
    // [dart_Segment_getEnd]
    // Get end point
    Point segment1End = segment1.end;
    print("Segment1 end point: (${segment1End.x}, ${segment1End.y})");
    // [dart_Segment_getEnd]
 
    // [dart_GeometryUtils_segmentLength]
    // Calculate segment length
    double length1 = GeometryUtils.segmentLength(segment1);
    double length2 = GeometryUtils.segmentLength(segment2);
    print("Segment1 length: ${length1.toStringAsFixed(2)} meters");
    print("Segment2 length: ${length2.toStringAsFixed(2)} meters");
    // [dart_GeometryUtils_segmentLength]
 
    // [dart_GeometryUtils_segmentPointDistance]
    // Calculate distance from segment to point
    double distanceToPoint = GeometryUtils.segmentPointDistance(segment1, testPoint);
    print("Distance from segment1 to test point: ${distanceToPoint.toStringAsFixed(2)} meters");
    // [dart_GeometryUtils_segmentPointDistance]
 
    // [dart_GeometryUtils_segmentIntersectsSegment]
    // Check if segments intersect
    bool intersects = GeometryUtils.segmentIntersectsSegment(segment1, segment2);
    print("Segments intersect: $intersects");
    // [dart_GeometryUtils_segmentIntersectsSegment]
 
    // [dart_GeometryUtils_segmentIntersectionSegment]
    // Calculate intersection point
    Point intersection = GeometryUtils.segmentIntersectionSegment(segment1, segment2);
    print("Intersection point: (${intersection.x.toStringAsFixed(2)}, ${intersection.y.toStringAsFixed(2)})");
    // [dart_GeometryUtils_segmentIntersectionSegment]
 
    // [dart_GeometryUtils_divisionRatioBySegment]
    // Calculate division ratio
    double divisionRatio = GeometryUtils.divisionRatioBySegment(segment1, segment2);
    print("Division ratio: ${divisionRatio.toStringAsFixed(2)}");
    // [dart_GeometryUtils_divisionRatioBySegment]
 
    // [dart_GeometryUtils_getRatioPoint]
    // Get point at specific ratio
    double ratio = 0.5;
    Point ratioPoint = GeometryUtils.getRatioPoint(segment1, ratio);
    print("Point at ratio $ratio: (${ratioPoint.x.toStringAsFixed(2)}, ${ratioPoint.y.toStringAsFixed(2)})");
    // [dart_GeometryUtils_getRatioPoint]
 
    // [dart_GeometryUtils_getProjectionRatio]
    // Calculate projection ratio
    double projectionRatio = GeometryUtils.getProjectionRatio(segment1, testPoint);
    print("Projection ratio: ${projectionRatio.toStringAsFixed(2)}");
    // [dart_GeometryUtils_getProjectionRatio]
  }

  void _demonstratePolygonOperations() {
    print("--- Polygon Operations ---");
 
    // Create points for polygon
    List<Point> polygonPoints = [
      Point(0.0, 0.0),
      Point(10.0, 0.0),
      Point(10.0, 10.0),
      Point(0.0, 10.0),
    ];
 
    // [dart_Polygon_constructor]
    // Create polygon
    Polygon polygon = Polygon(polygonPoints);
    print("Created polygon with ${polygon.points.length} points");
    // [dart_Polygon_constructor]
 
    // [dart_Polygon_getPoints]
    // Get polygon points
    List<Point> points = polygon.points;
    print("Polygon points: ${points.map((p) => "(${p.x}, ${p.y})").join(", ")}");
    // [dart_Polygon_getPoints]
 
    // [dart_GeometryUtils_polygonArea]
    // Calculate polygon area
    double area = GeometryUtils.polygonArea(polygon);
    print("Polygon area: ${area.toStringAsFixed(2)} square meters");
    // [dart_GeometryUtils_polygonArea]
 
    // [dart_GeometryUtils_polygonCenter]
    // Calculate polygon center
    Point center = GeometryUtils.polygonCenter(polygon);
    print("Polygon center: (${center.x.toStringAsFixed(2)}, ${center.y.toStringAsFixed(2)})");
    // [dart_GeometryUtils_polygonCenter]
 
    // [dart_GeometryUtils_polygonContainsPoint]
    // Check if polygon contains point
    Point insidePoint = Point(5.0, 5.0);
    Point outsidePoint = Point(15.0, 15.0);
    
    bool containsInside = GeometryUtils.polygonContainsPoint(polygon, insidePoint);
    bool containsOutside = GeometryUtils.polygonContainsPoint(polygon, outsidePoint);
    
    print("Polygon contains inside point: $containsInside");
    print("Polygon contains outside point: $containsOutside");
    // [dart_GeometryUtils_polygonContainsPoint]
 
    // Create complex polygon
    List<Point> complexPolygonPoints = [
      Point(0.0, 0.0),
      Point(20.0, 0.0),
      Point(20.0, 20.0),
      Point(10.0, 10.0),
      Point(0.0, 20.0),
    ];
    Polygon complexPolygon = Polygon(complexPolygonPoints);
    
    double complexArea = GeometryUtils.polygonArea(complexPolygon);
    Point complexCenter = GeometryUtils.polygonCenter(complexPolygon);
    
    print("Complex polygon area: ${complexArea.toStringAsFixed(2)} square meters");
    print("Complex polygon center: (${complexCenter.x.toStringAsFixed(2)}, ${complexCenter.y.toStringAsFixed(2)})");
  }

  void _demonstrateLineOperations() {
    print("--- Line Operations ---");
 
    // Create segments for line
    List<Segment> lineSegments = [
      Segment(Point(0.0, 0.0), Point(10.0, 10.0)),
      Segment(Point(10.0, 10.0), Point(20.0, 5.0)),
      Segment(Point(20.0, 5.0), Point(30.0, 15.0)),
    ];
 
    // [dart_Line_constructor]
    // Create line
    Line line = Line(lineSegments);
    print("Created line with ${line.segments.length} segments");
    // [dart_Line_constructor]
 
    // [dart_Line_getSegments]
    // Get line segments
    List<Segment> segments = line.segments;
    print("Line segments: ${segments.length} segments");
    // [dart_Line_getSegments]
 
    // Calculate total length of line
    double totalLength = 0.0;
    for (Segment segment in segments) {
      totalLength += GeometryUtils.segmentLength(segment);
    }
    print("Total line length: ${totalLength.toStringAsFixed(2)} meters");
 
    // Create complex line
    List<Segment> complexLineSegments = [
      Segment(Point(0.0, 0.0), Point(5.0, 5.0)),
      Segment(Point(5.0, 5.0), Point(10.0, 0.0)),
      Segment(Point(10.0, 0.0), Point(15.0, 10.0)),
      Segment(Point(15.0, 10.0), Point(20.0, 5.0)),
    ];
    Line complexLine = Line(complexLineSegments);
    
    double complexTotalLength = 0.0;
    for (Segment segment in complexLine.segments) {
      complexTotalLength += GeometryUtils.segmentLength(segment);
    }
    print("Complex line total length: ${complexTotalLength.toStringAsFixed(2)} meters");
  }

  void _demonstrateAdvancedGeometryOperations() {
    print("--- 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();
  }

  void _demonstrateDistanceCalculations() {
    print("--- Distance Calculations ---");
 
    // Test point distances
    Point origin = Point(0.0, 0.0);
    List<Point> testPoints = [
      Point(3.0, 4.0),  // Should be 5.0 distance
      Point(6.0, 8.0),  // Should be 10.0 distance
      Point(1.0, 1.0),  // Should be sqrt(2) distance
    ];
 
    for (Point testPoint in testPoints) {
      double distance = GeometryUtils.distanceBetweenPoints(origin, testPoint);
      print("Distance from origin to (${testPoint.x}, ${testPoint.y}): ${distance.toStringAsFixed(2)} meters");
    }
 
    // Test global point distances
    GlobalPoint moscow = GlobalPoint(55.7558, 37.6176);
    GlobalPoint london = GlobalPoint(51.5074, -0.1278);
    GlobalPoint tokyo = GlobalPoint(35.6762, 139.6503);
 
    double moscowLondon = GeometryUtils.distanceBetweenGlobalPoints(moscow, london);
    double moscowTokyo = GeometryUtils.distanceBetweenGlobalPoints(moscow, tokyo);
    
    print("Moscow to London: ${(moscowLondon / 1000).toStringAsFixed(2)} km");
    print("Moscow to Tokyo: ${(moscowTokyo / 1000).toStringAsFixed(2)} km");
  }

  void _demonstrateIntersectionScenarios() {
    print("--- Intersection Scenarios ---");
 
    // Parallel segments (should not intersect)
    Segment parallel1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0));
    Segment parallel2 = Segment(Point(0.0, 5.0), Point(10.0, 5.0));
    
    bool parallelIntersects = GeometryUtils.segmentIntersectsSegment(parallel1, parallel2);
    print("Parallel segments intersect: $parallelIntersects");
 
    // Perpendicular segments (should intersect)
    Segment perpendicular1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0));
    Segment perpendicular2 = Segment(Point(5.0, -5.0), Point(5.0, 5.0));
    
    bool perpendicularIntersects = GeometryUtils.segmentIntersectsSegment(perpendicular1, perpendicular2);
    print("Perpendicular segments intersect: $perpendicularIntersects");
    
    if (perpendicularIntersects) {
      Point intersection = GeometryUtils.segmentIntersectionSegment(perpendicular1, perpendicular2);
      print("Intersection point: (${intersection.x.toStringAsFixed(2)}, ${intersection.y.toStringAsFixed(2)})");
    }
 
    // Overlapping segments
    Segment overlap1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0));
    Segment overlap2 = Segment(Point(5.0, 0.0), Point(15.0, 0.0));
    
    bool overlapIntersects = GeometryUtils.segmentIntersectsSegment(overlap1, overlap2);
    print("Overlapping segments intersect: $overlapIntersects");
  }

  void _demonstratePolygonScenarios() {
    print("--- Polygon Scenarios ---");
 
    // Regular square
    List<Point> square = [
      Point(0.0, 0.0),
      Point(10.0, 0.0),
      Point(10.0, 10.0),
      Point(0.0, 10.0),
    ];
    Polygon squarePolygon = Polygon(square);
    
    double squareArea = GeometryUtils.polygonArea(squarePolygon);
    Point squareCenter = GeometryUtils.polygonCenter(squarePolygon);
    
    print("Square area: ${squareArea.toStringAsFixed(2)} square meters");
    print("Square center: (${squareCenter.x.toStringAsFixed(2)}, ${squareCenter.y.toStringAsFixed(2)})");
 
    // Triangle
    List<Point> triangle = [
      Point(0.0, 0.0),
      Point(10.0, 0.0),
      Point(5.0, 10.0),
    ];
    Polygon trianglePolygon = Polygon(triangle);
    
    double triangleArea = GeometryUtils.polygonArea(trianglePolygon);
    Point triangleCenter = GeometryUtils.polygonCenter(trianglePolygon);
    
    print("Triangle area: ${triangleArea.toStringAsFixed(2)} square meters");
    print("Triangle center: (${triangleCenter.x.toStringAsFixed(2)}, ${triangleCenter.y.toStringAsFixed(2)})");
 
    // Test point containment
    Point insideSquare = Point(5.0, 5.0);
    Point outsideSquare = Point(15.0, 15.0);
    
    bool containsInside = GeometryUtils.polygonContainsPoint(squarePolygon, insideSquare);
    bool containsOutside = GeometryUtils.polygonContainsPoint(squarePolygon, outsideSquare);
    
    print("Square contains (5,5): $containsInside");
    print("Square contains (15,15): $containsOutside");
  }

  void _demonstrateProjectionCalculations() {
    print("--- Projection Calculations ---");
 
    Segment segment = Segment(Point(0.0, 0.0), Point(10.0, 10.0));
    
    // Test different ratio points
    List<double> ratios = [0.0, 0.25, 0.5, 0.75, 1.0];
    
    for (double ratio in ratios) {
      Point ratioPoint = GeometryUtils.getRatioPoint(segment, ratio);
      print("Ratio $ratio: (${ratioPoint.x.toStringAsFixed(2)}, ${ratioPoint.y.toStringAsFixed(2)})");
    }
 
    // Test projection ratio calculation
    Point testPoint = Point(5.0, 5.0);
    double projectionRatio = GeometryUtils.getProjectionRatio(segment, testPoint);
    print("Projection ratio for point (5,5): ${projectionRatio.toStringAsFixed(2)}");
 
    // Test distance from segment to point
    Point offSegmentPoint = Point(5.0, 0.0);
    double distanceToOffPoint = GeometryUtils.segmentPointDistance(segment, offSegmentPoint);
    print("Distance from segment to point (5,0): ${distanceToOffPoint.toStringAsFixed(2)} meters");
  }

  Future<void> runExample() async {
    print("=== GeometryUtils Example ===");
    
    // Wait a bit for processing
    await Future.delayed(Duration(seconds: 1));
    
    print("=== Example completed ===");
  }
}

Future<void> main() async {
  GeometryUtilsExample example = GeometryUtilsExample();
  await example.runExample();
}