GeometryUtilsExample.kt

Go to the documentation of this file.

import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
 
/**
 * GeometryUtils usage example for Kotlin
 * Demonstrates working with geometric calculations, points, segments, polygons, and lines
 */
class GeometryUtilsExample {
    
    init {
        demonstrateGeometryUtilsMethods()
    }
 
    /**
     * Demonstrate GeometryUtils methods
     */
    fun demonstrateGeometryUtilsMethods() {
        println("=== GeometryUtils Methods ===")
        
        demonstratePointOperations()
        demonstrateGlobalPointOperations()
        demonstrateSegmentOperations()
        demonstratePolygonOperations()
        demonstrateLineOperations()
        demonstrateAdvancedGeometryOperations()
    }
 
    /**
     * Demonstrate Point operations
     */
    fun demonstratePointOperations() {
        println("--- Point Operations ---")
 
        // [kotlin_Point_constructor]
        // Create points with x, y coordinates
        val point1 = Point(10.0, 20.0)
        val point2 = Point(30.0, 40.0)
        val point3 = Point(50.0, 60.0)
        println("Created points: P1(${point1.x}, ${point1.y}), P2(${point2.x}, ${point2.y}), P3(${point3.x}, ${point3.y})")
        // [kotlin_Point_constructor]
 
        // [kotlin_Point_getX]
        // Get X coordinate
        val x1 = point1.x
        println("Point1 X coordinate: $x1")
        // [kotlin_Point_getX]
 
        // [kotlin_Point_getY]
        // Get Y coordinate
        val y1 = point1.y
        println("Point1 Y coordinate: $y1")
        // [kotlin_Point_getY]
 
        // [kotlin_GeometryUtils_distanceBetweenPoints]
        // Calculate distance between points
        val distance = GeometryUtils.distanceBetweenPoints(point1, point2)
        println("Distance between P1 and P2: ${"%.2f".format(distance)} meters")
        // [kotlin_GeometryUtils_distanceBetweenPoints]
 
        // Create more points for testing
        val testPoints = listOf(
            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)
        )
 
        println("Test points created for further calculations")
    }
 
    /**
     * Demonstrate GlobalPoint operations
     */
    fun demonstrateGlobalPointOperations() {
        println("--- GlobalPoint Operations ---")
 
        // [kotlin_GlobalPoint_constructor]
        // Create global points with latitude, longitude
        val globalPoint1 = GlobalPoint(55.7558, 37.6176) // Moscow
        val globalPoint2 = GlobalPoint(59.9311, 30.3609) // St. Petersburg
        val globalPoint3 = GlobalPoint(55.7522, 37.6156) // Moscow center
        println("Created global points: GP1(${globalPoint1.latitude}, ${globalPoint1.longitude}), GP2(${globalPoint2.latitude}, ${globalPoint2.longitude})")
        // [kotlin_GlobalPoint_constructor]
 
        // [kotlin_GlobalPoint_getLatitude]
        // Get latitude
        val lat1 = globalPoint1.latitude
        println("GlobalPoint1 latitude: $lat1")
        // [kotlin_GlobalPoint_getLatitude]
 
        // [kotlin_GlobalPoint_getLongitude]
        // Get longitude
        val lon1 = globalPoint1.longitude
        println("GlobalPoint1 longitude: $lon1")
        // [kotlin_GlobalPoint_getLongitude]
 
        // [kotlin_GeometryUtils_distanceBetweenGlobalPoints]
        // Calculate distance between global points
        val globalDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint2)
        println("Distance between Moscow and St. Petersburg: ${"%.2f".format(globalDistance)} meters")
        // [kotlin_GeometryUtils_distanceBetweenGlobalPoints]
 
        // Calculate distance between nearby points
        val nearbyDistance = GeometryUtils.distanceBetweenGlobalPoints(globalPoint1, globalPoint3)
        println("Distance between Moscow points: ${"%.2f".format(nearbyDistance)} meters")
    }
 
    /**
     * Demonstrate Segment operations
     */
    fun demonstrateSegmentOperations() {
        println("--- Segment Operations ---")
 
        // Create points for segments
        val start1 = Point(0.0, 0.0)
        val end1 = Point(10.0, 10.0)
        val start2 = Point(0.0, 10.0)
        val end2 = Point(10.0, 0.0)
        val testPoint = Point(5.0, 5.0)
 
        // [kotlin_Segment_constructor]
        // Create segments
        val segment1 = Segment(start1, end1)
        val segment2 = Segment(start2, end2)
        println("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}))")
        // [kotlin_Segment_constructor]
 
        // [kotlin_Segment_getStart]
        // Get start point
        val segment1Start = segment1.start
        println("Segment1 start point: (${segment1Start.x}, ${segment1Start.y})")
        // [kotlin_Segment_getStart]
 
        // [kotlin_Segment_getEnd]
        // Get end point
        val segment1End = segment1.end
        println("Segment1 end point: (${segment1End.x}, ${segment1End.y})")
        // [kotlin_Segment_getEnd]
 
        // [kotlin_GeometryUtils_segmentLength]
        // Calculate segment length
        val length1 = GeometryUtils.segmentLength(segment1)
        val length2 = GeometryUtils.segmentLength(segment2)
        println("Segment1 length: ${"%.2f".format(length1)} meters")
        println("Segment2 length: ${"%.2f".format(length2)} meters")
        // [kotlin_GeometryUtils_segmentLength]
 
        // [kotlin_GeometryUtils_segmentPointDistance]
        // Calculate distance from segment to point
        val distanceToPoint = GeometryUtils.segmentPointDistance(segment1, testPoint)
        println("Distance from segment1 to test point: ${"%.2f".format(distanceToPoint)} meters")
        // [kotlin_GeometryUtils_segmentPointDistance]
 
        // [kotlin_GeometryUtils_segmentIntersectsSegment]
        // Check if segments intersect
        val intersects = GeometryUtils.segmentIntersectsSegment(segment1, segment2)
        println("Segments intersect: $intersects")
        // [kotlin_GeometryUtils_segmentIntersectsSegment]
 
        // [kotlin_GeometryUtils_segmentIntersectionSegment]
        // Calculate intersection point
        val intersection = GeometryUtils.segmentIntersectionSegment(segment1, segment2)
        println("Intersection point: (${"%.2f".format(intersection.x)}, ${"%.2f".format(intersection.y)})")
        // [kotlin_GeometryUtils_segmentIntersectionSegment]
 
        // [kotlin_GeometryUtils_divisionRatioBySegment]
        // Calculate division ratio
        val divisionRatio = GeometryUtils.divisionRatioBySegment(segment1, segment2)
        println("Division ratio: ${"%.2f".format(divisionRatio)}")
        // [kotlin_GeometryUtils_divisionRatioBySegment]
 
        // [kotlin_GeometryUtils_getRatioPoint]
        // Get point at specific ratio
        val ratio = 0.5
        val ratioPoint = GeometryUtils.getRatioPoint(segment1, ratio)
        println("Point at ratio $ratio: (${"%.2f".format(ratioPoint.x)}, ${"%.2f".format(ratioPoint.y)})")
        // [kotlin_GeometryUtils_getRatioPoint]
 
        // [kotlin_GeometryUtils_getProjectionRatio]
        // Calculate projection ratio
        val projectionRatio = GeometryUtils.getProjectionRatio(segment1, testPoint)
        println("Projection ratio: ${"%.2f".format(projectionRatio)}")
        // [kotlin_GeometryUtils_getProjectionRatio]
    }
 
    /**
     * Demonstrate Polygon operations
     */
    fun demonstratePolygonOperations() {
        println("--- Polygon Operations ---")
 
        // Create points for polygon
        val polygonPoints = listOf(
            Point(0.0, 0.0),
            Point(10.0, 0.0),
            Point(10.0, 10.0),
            Point(0.0, 10.0)
        )
 
        // [kotlin_Polygon_constructor]
        // Create polygon
        val polygon = Polygon(polygonPoints)
        println("Created polygon with ${polygon.points.size} points")
        // [kotlin_Polygon_constructor]
 
        // [kotlin_Polygon_getPoints]
        // Get polygon points
        val points = polygon.points
        println("Polygon points: ${points.joinToString(", ") { "(${it.x}, ${it.y})" }}")
        // [kotlin_Polygon_getPoints]
 
        // [kotlin_GeometryUtils_polygonArea]
        // Calculate polygon area
        val area = GeometryUtils.polygonArea(polygon)
        println("Polygon area: ${"%.2f".format(area)} square meters")
        // [kotlin_GeometryUtils_polygonArea]
 
        // [kotlin_GeometryUtils_polygonCenter]
        // Calculate polygon center
        val center = GeometryUtils.polygonCenter(polygon)
        println("Polygon center: (${"%.2f".format(center.x)}, ${"%.2f".format(center.y)})")
        // [kotlin_GeometryUtils_polygonCenter]
 
        // [kotlin_GeometryUtils_polygonContainsPoint]
        // Check if polygon contains point
        val insidePoint = Point(5.0, 5.0)
        val outsidePoint = Point(15.0, 15.0)
        
        val containsInside = GeometryUtils.polygonContainsPoint(polygon, insidePoint)
        val containsOutside = GeometryUtils.polygonContainsPoint(polygon, outsidePoint)
        
        println("Polygon contains inside point: $containsInside")
        println("Polygon contains outside point: $containsOutside")
        // [kotlin_GeometryUtils_polygonContainsPoint]
 
        // Create complex polygon
        val complexPolygonPoints = listOf(
            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)
        )
        val complexPolygon = Polygon(complexPolygonPoints)
        
        val complexArea = GeometryUtils.polygonArea(complexPolygon)
        val complexCenter = GeometryUtils.polygonCenter(complexPolygon)
        
        println("Complex polygon area: ${"%.2f".format(complexArea)} square meters")
        println("Complex polygon center: (${"%.2f".format(complexCenter.x)}, ${"%.2f".format(complexCenter.y)})")
    }
 
    /**
     * Demonstrate Line operations
     */
    fun demonstrateLineOperations() {
        println("--- Line Operations ---")
 
        // Create segments for line
        val lineSegments = listOf(
            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))
        )
 
        // [kotlin_Line_constructor]
        // Create line
        val line = Line(lineSegments)
        println("Created line with ${line.segments.size} segments")
        // [kotlin_Line_constructor]
 
        // [kotlin_Line_getSegments]
        // Get line segments
        val segments = line.segments
        println("Line segments: ${segments.size} segments")
        // [kotlin_Line_getSegments]
 
        // Calculate total length of line
        var totalLength = 0.0
        for (segment in segments) {
            totalLength += GeometryUtils.segmentLength(segment)
        }
        println("Total line length: ${"%.2f".format(totalLength)} meters")
 
        // Create complex line
        val complexLineSegments = listOf(
            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))
        )
        val complexLine = Line(complexLineSegments)
        
        var complexTotalLength = 0.0
        for (segment in complexLine.segments) {
            complexTotalLength += GeometryUtils.segmentLength(segment)
        }
        println("Complex line total length: ${"%.2f".format(complexTotalLength)} meters")
    }
 
    /**
     * Demonstrate advanced geometry operations
     */
    fun demonstrateAdvancedGeometryOperations() {
        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()
    }
 
    /**
     * Demonstrate distance calculations
     */
    fun demonstrateDistanceCalculations() {
        println("--- Distance Calculations ---")
 
        // Test point distances
        val origin = Point(0.0, 0.0)
        val testPoints = listOf(
            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 (testPoint in testPoints) {
            val distance = GeometryUtils.distanceBetweenPoints(origin, testPoint)
            println("Distance from origin to (${testPoint.x}, ${testPoint.y}): ${"%.2f".format(distance)} meters")
        }
 
        // Test global point distances
        val moscow = GlobalPoint(55.7558, 37.6176)
        val london = GlobalPoint(51.5074, -0.1278)
        val tokyo = GlobalPoint(35.6762, 139.6503)
 
        val moscowLondon = GeometryUtils.distanceBetweenGlobalPoints(moscow, london)
        val moscowTokyo = GeometryUtils.distanceBetweenGlobalPoints(moscow, tokyo)
        
        println("Moscow to London: ${"%.2f".format(moscowLondon / 1000)} km")
        println("Moscow to Tokyo: ${"%.2f".format(moscowTokyo / 1000)} km")
    }
 
    /**
     * Demonstrate intersection scenarios
     */
    fun demonstrateIntersectionScenarios() {
        println("--- Intersection Scenarios ---")
 
        // Parallel segments (should not intersect)
        val parallel1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0))
        val parallel2 = Segment(Point(0.0, 5.0), Point(10.0, 5.0))
        
        val parallelIntersects = GeometryUtils.segmentIntersectsSegment(parallel1, parallel2)
        println("Parallel segments intersect: $parallelIntersects")
 
        // Perpendicular segments (should intersect)
        val perpendicular1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0))
        val perpendicular2 = Segment(Point(5.0, -5.0), Point(5.0, 5.0))
        
        val perpendicularIntersects = GeometryUtils.segmentIntersectsSegment(perpendicular1, perpendicular2)
        println("Perpendicular segments intersect: $perpendicularIntersects")
        
        if (perpendicularIntersects) {
            val intersection = GeometryUtils.segmentIntersectionSegment(perpendicular1, perpendicular2)
            println("Intersection point: (${"%.2f".format(intersection.x)}, ${"%.2f".format(intersection.y)})")
        }
 
        // Overlapping segments
        val overlap1 = Segment(Point(0.0, 0.0), Point(10.0, 0.0))
        val overlap2 = Segment(Point(5.0, 0.0), Point(15.0, 0.0))
        
        val overlapIntersects = GeometryUtils.segmentIntersectsSegment(overlap1, overlap2)
        println("Overlapping segments intersect: $overlapIntersects")
    }
 
    /**
     * Demonstrate polygon scenarios
     */
    fun demonstratePolygonScenarios() {
        println("--- Polygon Scenarios ---")
 
        // Regular square
        val square = listOf(
            Point(0.0, 0.0),
            Point(10.0, 0.0),
            Point(10.0, 10.0),
            Point(0.0, 10.0)
        )
        val squarePolygon = Polygon(square)
        
        val squareArea = GeometryUtils.polygonArea(squarePolygon)
        val squareCenter = GeometryUtils.polygonCenter(squarePolygon)
        
        println("Square area: ${"%.2f".format(squareArea)} square meters")
        println("Square center: (${"%.2f".format(squareCenter.x)}, ${"%.2f".format(squareCenter.y)})")
 
        // Triangle
        val triangle = listOf(
            Point(0.0, 0.0),
            Point(10.0, 0.0),
            Point(5.0, 10.0)
        )
        val trianglePolygon = Polygon(triangle)
        
        val triangleArea = GeometryUtils.polygonArea(trianglePolygon)
        val triangleCenter = GeometryUtils.polygonCenter(trianglePolygon)
        
        println("Triangle area: ${"%.2f".format(triangleArea)} square meters")
        println("Triangle center: (${"%.2f".format(triangleCenter.x)}, ${"%.2f".format(triangleCenter.y)})")
 
        // Test point containment
        val insideSquare = Point(5.0, 5.0)
        val outsideSquare = Point(15.0, 15.0)
        
        val containsInside = GeometryUtils.polygonContainsPoint(squarePolygon, insideSquare)
        val containsOutside = GeometryUtils.polygonContainsPoint(squarePolygon, outsideSquare)
        
        println("Square contains (5,5): $containsInside")
        println("Square contains (15,15): $containsOutside")
    }
 
    /**
     * Demonstrate projection calculations
     */
    fun demonstrateProjectionCalculations() {
        println("--- Projection Calculations ---")
 
        val segment = Segment(Point(0.0, 0.0), Point(10.0, 10.0))
        
        // Test different ratio points
        val ratios = listOf(0.0, 0.25, 0.5, 0.75, 1.0)
        
        for (ratio in ratios) {
            val ratioPoint = GeometryUtils.getRatioPoint(segment, ratio)
            println("Ratio $ratio: (${"%.2f".format(ratioPoint.x)}, ${"%.2f".format(ratioPoint.y)})")
        }
 
        // Test projection ratio calculation
        val testPoint = Point(5.0, 5.0)
        val projectionRatio = GeometryUtils.getProjectionRatio(segment, testPoint)
        println("Projection ratio for point (5,5): ${"%.2f".format(projectionRatio)}")
 
        // Test distance from segment to point
        val offSegmentPoint = Point(5.0, 0.0)
        val distanceToOffPoint = GeometryUtils.segmentPointDistance(segment, offSegmentPoint)
        println("Distance from segment to point (5,0): ${"%.2f".format(distanceToOffPoint)} meters")
    }
 
    /**
     * Main demonstration method
     */
    suspend fun runExample() {
        println("=== GeometryUtils Example ===")
        
        // Wait a bit for processing
        delay(1000)
        
        println("=== Example completed ===")
    }
}
 
/**
 * Function to run the example
 */
fun main() = runBlocking {
    val example = GeometryUtilsExample()
    example.runExample()
}