GeometryUtilsExample.swift

Go to the documentation of this file.

import Foundation
 
/**
 * GeometryUtils usage example for Swift
 * Demonstrates working with geometric calculations, points, segments, polygons, and lines
 */
class GeometryUtilsExample: NSObject {
    
    override init() {
        super.init()
        demonstrateGeometryUtilsMethods()
    }
 
    /**
     * Demonstrate GeometryUtils methods
     */
    func demonstrateGeometryUtilsMethods() {
        print("=== GeometryUtils Methods ===")
        
        demonstratePointOperations()
        demonstrateGlobalPointOperations()
        demonstrateBoundingBoxOperations()
        demonstrateSegmentOperations()
        demonstratePolygonOperations()
        demonstrateLineOperations()
        demonstrateAdvancedGeometryOperations()
    }
 
    /**
     * Demonstrate Point operations
     */
    func demonstratePointOperations() {
        print("--- Point Operations ---")
 
        // [swift_Point_constructor]
        // Create points with x, y coordinates
        let point1 = Point(x: 10.0, y: 20.0)
        let point2 = Point(x: 30.0, y: 40.0)
        let point3 = Point(x: 50.0, y: 60.0)
        print("Created points: P1(\‍(point1.x), \‍(point1.y)), P2(\‍(point2.x), \‍(point2.y)), P3(\‍(point3.x), \‍(point3.y))")
        // [swift_Point_constructor]
 
        // [swift_Point_getX]
        // Get X coordinate
        let x1 = point1.x
        print("Point1 X coordinate: \‍(x1)")
        // [swift_Point_getX]
 
        // [swift_Point_getY]
        // Get Y coordinate
        let y1 = point1.y
        print("Point1 Y coordinate: \‍(y1)")
        // [swift_Point_getY]
 
        // [swift_GeometryUtils_distanceBetweenPoints]
        // Calculate distance between points
        let distance = GeometryUtils.distanceBetweenPoints(from: point1, to: point2)
        print("Distance between P1 and P2: \‍(String(format: "%.2f", distance)) meters")
        // [swift_GeometryUtils_distanceBetweenPoints]
 
        // Create more points for testing
        let testPoints = [
            Point(x: 0.0, y: 0.0),
            Point(x: 10.0, y: 0.0),
            Point(x: 10.0, y: 10.0),
            Point(x: 0.0, y: 10.0),
            Point(x: 5.0, y: 5.0)
        ]
 
        print("Test points created for further calculations")
    }
 
    /**
     * Demonstrate BoundingBox operations
     */
    func demonstrateBoundingBoxOperations() {
        print("--- BoundingBox Operations ---")
 
        let bottomLeft = Point(x: 0.0, y: 0.0)
        let topRight = Point(x: 10.0, y: 20.0)
 
        // [swift_BoundingBox_constructor]
        let boundingBox = BoundingBox(bottomLeft: bottomLeft, topRight: topRight)
        print("Created bounding box: bottomLeft(\‍(boundingBox.bottomLeft.x), \‍(boundingBox.bottomLeft.y)), topRight(\‍(boundingBox.topRight.x), \‍(boundingBox.topRight.y))")
        // [swift_BoundingBox_constructor]
 
        // [swift_BoundingBox_getBottomLeft]
        let leftCorner = boundingBox.bottomLeft
        print("Bottom-left corner: (\‍(leftCorner.x), \‍(leftCorner.y))")
        // [swift_BoundingBox_getBottomLeft]
 
        // [swift_BoundingBox_getTopRight]
        let rightCorner = boundingBox.topRight
        print("Top-right corner: (\‍(rightCorner.x), \‍(rightCorner.y))")
        // [swift_BoundingBox_getTopRight]
    }
 
    /**
     * Demonstrate GlobalPoint operations
     */
    func demonstrateGlobalPointOperations() {
        print("--- GlobalPoint Operations ---")
 
        // [swift_GlobalPoint_constructor]
        // Create global points with latitude, longitude
        let globalPoint1 = GlobalPoint(latitude: 55.7558, longitude: 37.6176) // Moscow
        let globalPoint2 = GlobalPoint(latitude: 59.9311, longitude: 30.3609) // St. Petersburg
        let globalPoint3 = GlobalPoint(latitude: 55.7522, longitude: 37.6156) // Moscow center
        print("Created global points: GP1(\‍(globalPoint1.latitude), \‍(globalPoint1.longitude)), GP2(\‍(globalPoint2.latitude), \‍(globalPoint2.longitude))")
        // [swift_GlobalPoint_constructor]
 
        // [swift_GlobalPoint_getLatitude]
        // Get latitude
        let lat1 = globalPoint1.latitude
        print("GlobalPoint1 latitude: \‍(lat1)")
        // [swift_GlobalPoint_getLatitude]
 
        // [swift_GlobalPoint_getLongitude]
        // Get longitude
        let lon1 = globalPoint1.longitude
        print("GlobalPoint1 longitude: \‍(lon1)")
        // [swift_GlobalPoint_getLongitude]
 
        // [swift_GeometryUtils_distanceBetweenGlobalPoints]
        // Calculate distance between global points
        let globalDistance = GeometryUtils.distanceBetweenGlobalPoints(from: globalPoint1, to: globalPoint2)
        print("Distance between Moscow and St. Petersburg: \‍(String(format: "%.2f", globalDistance)) meters")
        // [swift_GeometryUtils_distanceBetweenGlobalPoints]
 
        // Calculate distance between nearby points
        let nearbyDistance = GeometryUtils.distanceBetweenGlobalPoints(from: globalPoint1, to: globalPoint3)
        print("Distance between Moscow points: \‍(String(format: "%.2f", nearbyDistance)) meters")
    }
 
    /**
     * Demonstrate Segment operations
     */
    func demonstrateSegmentOperations() {
        print("--- Segment Operations ---")
 
        // Create points for segments
        let start1 = Point(x: 0.0, y: 0.0)
        let end1 = Point(x: 10.0, y: 10.0)
        let start2 = Point(x: 0.0, y: 10.0)
        let end2 = Point(x: 10.0, y: 0.0)
        let testPoint = Point(x: 5.0, y: 5.0)
 
        // [swift_Segment_constructor]
        // Create segments
        let segment1 = Segment(start: start1, end: end1)
        let segment2 = Segment(start: start2, end: 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)))")
        // [swift_Segment_constructor]
 
        // [swift_Segment_getStart]
        // Get start point
        let segment1Start = segment1.start
        print("Segment1 start point: (\‍(segment1Start.x), \‍(segment1Start.y))")
        // [swift_Segment_getStart]
 
        // [swift_Segment_getEnd]
        // Get end point
        let segment1End = segment1.end
        print("Segment1 end point: (\‍(segment1End.x), \‍(segment1End.y))")
        // [swift_Segment_getEnd]
 
        // [swift_GeometryUtils_segmentLength]
        // Calculate segment length
        let length1 = GeometryUtils.segmentLength(segment: segment1)
        let length2 = GeometryUtils.segmentLength(segment: segment2)
        print("Segment1 length: \‍(String(format: "%.2f", length1)) meters")
        print("Segment2 length: \‍(String(format: "%.2f", length2)) meters")
        // [swift_GeometryUtils_segmentLength]
 
        // [swift_GeometryUtils_segmentPointDistance]
        // Calculate distance from segment to point
        let distanceToPoint = GeometryUtils.segmentPointDistance(segment: segment1, point: testPoint)
        print("Distance from segment1 to test point: \‍(String(format: "%.2f", distanceToPoint)) meters")
        // [swift_GeometryUtils_segmentPointDistance]
 
        // [swift_GeometryUtils_segmentIntersectsSegment]
        // Check if segments intersect
        let intersects = GeometryUtils.segmentIntersectsSegment(segment1: segment1, segment2: segment2)
        print("Segments intersect: \‍(intersects)")
        // [swift_GeometryUtils_segmentIntersectsSegment]
 
        // [swift_GeometryUtils_segmentIntersectionSegment]
        // Calculate intersection point
        let intersection = GeometryUtils.segmentIntersectionSegment(segment1: segment1, segment2: segment2)
        print("Intersection point: (\‍(String(format: "%.2f", intersection.x)), \‍(String(format: "%.2f", intersection.y)))")
        // [swift_GeometryUtils_segmentIntersectionSegment]
 
        // [swift_GeometryUtils_divisionRatioBySegment]
        // Calculate division ratio
        let divisionRatio = GeometryUtils.divisionRatioBySegment(segment1: segment1, segment2: segment2)
        print("Division ratio: \‍(String(format: "%.2f", divisionRatio))")
        // [swift_GeometryUtils_divisionRatioBySegment]
 
        // [swift_GeometryUtils_getRatioPoint]
        // Get point at specific ratio
        let ratio = 0.5
        let ratioPoint = GeometryUtils.getRatioPoint(segment: segment1, r: ratio)
        print("Point at ratio \‍(ratio): (\‍(String(format: "%.2f", ratioPoint.x)), \‍(String(format: "%.2f", ratioPoint.y)))")
        // [swift_GeometryUtils_getRatioPoint]
 
        // [swift_GeometryUtils_getProjectionRatio]
        // Calculate projection ratio
        let projectionRatio = GeometryUtils.getProjectionRatio(segment: segment1, point: testPoint)
        print("Projection ratio: \‍(String(format: "%.2f", projectionRatio))")
        // [swift_GeometryUtils_getProjectionRatio]
    }
 
    /**
     * Demonstrate Polygon operations
     */
    func demonstratePolygonOperations() {
        print("--- Polygon Operations ---")
 
        // Create points for polygon
        let polygonPoints = [
            Point(x: 0.0, y: 0.0),
            Point(x: 10.0, y: 0.0),
            Point(x: 10.0, y: 10.0),
            Point(x: 0.0, y: 10.0)
        ]
 
        // [swift_Polygon_constructor]
        // Create polygon
        let polygon = Polygon(points: polygonPoints)
        print("Created polygon with \‍(polygon.points.count) points")
        // [swift_Polygon_constructor]
 
        // [swift_Polygon_getPoints]
        // Get polygon points
        let points = polygon.points
        let pointsString = points.map { "(\‍($0.x), \‍($0.y))" }.joined(separator: ", ")
        print("Polygon points: \‍(pointsString)")
        // [swift_Polygon_getPoints]
 
        // [swift_GeometryUtils_polygonArea]
        // Calculate polygon area
        let area = GeometryUtils.polygonArea(polygon: polygon)
        print("Polygon area: \‍(String(format: "%.2f", area)) square meters")
        // [swift_GeometryUtils_polygonArea]
 
        // [swift_GeometryUtils_polygonCenter]
        // Calculate polygon center
        let center = GeometryUtils.polygonCenter(polygon: polygon)
        print("Polygon center: (\‍(String(format: "%.2f", center.x)), \‍(String(format: "%.2f", center.y)))")
        // [swift_GeometryUtils_polygonCenter]
 
        // [swift_GeometryUtils_polygonContainsPoint]
        // Check if polygon contains point
        let insidePoint = Point(x: 5.0, y: 5.0)
        let outsidePoint = Point(x: 15.0, y: 15.0)
        
        let containsInside = GeometryUtils.polygonContainsPoint(polygon: polygon, point: insidePoint)
        let containsOutside = GeometryUtils.polygonContainsPoint(polygon: polygon, point: outsidePoint)
        
        print("Polygon contains inside point: \‍(containsInside)")
        print("Polygon contains outside point: \‍(containsOutside)")
        // [swift_GeometryUtils_polygonContainsPoint]
 
        // Create complex polygon
        let complexPolygonPoints = [
            Point(x: 0.0, y: 0.0),
            Point(x: 20.0, y: 0.0),
            Point(x: 20.0, y: 20.0),
            Point(x: 10.0, y: 10.0),
            Point(x: 0.0, y: 20.0)
        ]
        let complexPolygon = Polygon(points: complexPolygonPoints)
        
        let complexArea = GeometryUtils.polygonArea(polygon: complexPolygon)
        let complexCenter = GeometryUtils.polygonCenter(polygon: complexPolygon)
        
        print("Complex polygon area: \‍(String(format: "%.2f", complexArea)) square meters")
        print("Complex polygon center: (\‍(String(format: "%.2f", complexCenter.x)), \‍(String(format: "%.2f", complexCenter.y)))")
    }
 
    /**
     * Demonstrate Line operations
     */
    func demonstrateLineOperations() {
        print("--- Line Operations ---")
 
        // Create segments for line
        let lineSegments = [
            Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 10.0, y: 10.0)),
            Segment(start: Point(x: 10.0, y: 10.0), end: Point(x: 20.0, y: 5.0)),
            Segment(start: Point(x: 20.0, y: 5.0), end: Point(x: 30.0, y: 15.0))
        ]
 
        // [swift_Line_constructor]
        // Create line
        let line = Line(segments: lineSegments)
        print("Created line with \‍(line.segments.count) segments")
        // [swift_Line_constructor]
 
        // [swift_Line_getSegments]
        // Get line segments
        let segments = line.segments
        print("Line segments: \‍(segments.count) segments")
        // [swift_Line_getSegments]
 
        // Calculate total length of line
        var totalLength = 0.0
        for segment in segments {
            totalLength += GeometryUtils.segmentLength(segment: segment)
        }
        print("Total line length: \‍(String(format: "%.2f", totalLength)) meters")
 
        // Create complex line
        let complexLineSegments = [
            Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 5.0, y: 5.0)),
            Segment(start: Point(x: 5.0, y: 5.0), end: Point(x: 10.0, y: 0.0)),
            Segment(start: Point(x: 10.0, y: 0.0), end: Point(x: 15.0, y: 10.0)),
            Segment(start: Point(x: 15.0, y: 10.0), end: Point(x: 20.0, y: 5.0))
        ]
        let complexLine = Line(segments: complexLineSegments)
        
        var complexTotalLength = 0.0
        for segment in complexLine.segments {
            complexTotalLength += GeometryUtils.segmentLength(segment: segment)
        }
        print("Complex line total length: \‍(String(format: "%.2f", complexTotalLength)) meters")
    }
 
    /**
     * Demonstrate advanced geometry operations
     */
    func 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()
    }
 
    /**
     * Demonstrate distance calculations
     */
    func demonstrateDistanceCalculations() {
        print("--- Distance Calculations ---")
 
        // Test point distances
        let origin = Point(x: 0.0, y: 0.0)
        let testPoints = [
            Point(x: 3.0, y: 4.0),  // Should be 5.0 distance
            Point(x: 6.0, y: 8.0),  // Should be 10.0 distance
            Point(x: 1.0, y: 1.0)   // Should be sqrt(2) distance
        ]
 
        for testPoint in testPoints {
            let distance = GeometryUtils.distanceBetweenPoints(from: origin, to: testPoint)
            print("Distance from origin to (\‍(testPoint.x), \‍(testPoint.y)): \‍(String(format: "%.2f", distance)) meters")
        }
 
        // Test global point distances
        let moscow = GlobalPoint(latitude: 55.7558, longitude: 37.6176)
        let london = GlobalPoint(latitude: 51.5074, longitude: -0.1278)
        let tokyo = GlobalPoint(latitude: 35.6762, longitude: 139.6503)
 
        let moscowLondon = GeometryUtils.distanceBetweenGlobalPoints(from: moscow, to: london)
        let moscowTokyo = GeometryUtils.distanceBetweenGlobalPoints(from: moscow, to: tokyo)
        
        print("Moscow to London: \‍(String(format: "%.2f", moscowLondon / 1000)) km")
        print("Moscow to Tokyo: \‍(String(format: "%.2f", moscowTokyo / 1000)) km")
    }
 
    /**
     * Demonstrate intersection scenarios
     */
    func demonstrateIntersectionScenarios() {
        print("--- Intersection Scenarios ---")
 
        // Parallel segments (should not intersect)
        let parallel1 = Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 10.0, y: 0.0))
        let parallel2 = Segment(start: Point(x: 0.0, y: 5.0), end: Point(x: 10.0, y: 5.0))
        
        let parallelIntersects = GeometryUtils.segmentIntersectsSegment(segment1: parallel1, segment2: parallel2)
        print("Parallel segments intersect: \‍(parallelIntersects)")
 
        // Perpendicular segments (should intersect)
        let perpendicular1 = Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 10.0, y: 0.0))
        let perpendicular2 = Segment(start: Point(x: 5.0, y: -5.0), end: Point(x: 5.0, y: 5.0))
        
        let perpendicularIntersects = GeometryUtils.segmentIntersectsSegment(segment1: perpendicular1, segment2: perpendicular2)
        print("Perpendicular segments intersect: \‍(perpendicularIntersects)")
        
        if perpendicularIntersects {
            let intersection = GeometryUtils.segmentIntersectionSegment(segment1: perpendicular1, segment2: perpendicular2)
            print("Intersection point: (\‍(String(format: "%.2f", intersection.x)), \‍(String(format: "%.2f", intersection.y)))")
        }
 
        // Overlapping segments
        let overlap1 = Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 10.0, y: 0.0))
        let overlap2 = Segment(start: Point(x: 5.0, y: 0.0), end: Point(x: 15.0, y: 0.0))
        
        let overlapIntersects = GeometryUtils.segmentIntersectsSegment(segment1: overlap1, segment2: overlap2)
        print("Overlapping segments intersect: \‍(overlapIntersects)")
    }
 
    /**
     * Demonstrate polygon scenarios
     */
    func demonstratePolygonScenarios() {
        print("--- Polygon Scenarios ---")
 
        // Regular square
        let square = [
            Point(x: 0.0, y: 0.0),
            Point(x: 10.0, y: 0.0),
            Point(x: 10.0, y: 10.0),
            Point(x: 0.0, y: 10.0)
        ]
        let squarePolygon = Polygon(points: square)
        
        let squareArea = GeometryUtils.polygonArea(polygon: squarePolygon)
        let squareCenter = GeometryUtils.polygonCenter(polygon: squarePolygon)
        
        print("Square area: \‍(String(format: "%.2f", squareArea)) square meters")
        print("Square center: (\‍(String(format: "%.2f", squareCenter.x)), \‍(String(format: "%.2f", squareCenter.y)))")
 
        // Triangle
        let triangle = [
            Point(x: 0.0, y: 0.0),
            Point(x: 10.0, y: 0.0),
            Point(x: 5.0, y: 10.0)
        ]
        let trianglePolygon = Polygon(points: triangle)
        
        let triangleArea = GeometryUtils.polygonArea(polygon: trianglePolygon)
        let triangleCenter = GeometryUtils.polygonCenter(polygon: trianglePolygon)
        
        print("Triangle area: \‍(String(format: "%.2f", triangleArea)) square meters")
        print("Triangle center: (\‍(String(format: "%.2f", triangleCenter.x)), \‍(String(format: "%.2f", triangleCenter.y)))")
 
        // Test point containment
        let insideSquare = Point(x: 5.0, y: 5.0)
        let outsideSquare = Point(x: 15.0, y: 15.0)
        
        let containsInside = GeometryUtils.polygonContainsPoint(polygon: squarePolygon, point: insideSquare)
        let containsOutside = GeometryUtils.polygonContainsPoint(polygon: squarePolygon, point: outsideSquare)
        
        print("Square contains (5,5): \‍(containsInside)")
        print("Square contains (15,15): \‍(containsOutside)")
    }
 
    /**
     * Demonstrate projection calculations
     */
    func demonstrateProjectionCalculations() {
        print("--- Projection Calculations ---")
 
        let segment = Segment(start: Point(x: 0.0, y: 0.0), end: Point(x: 10.0, y: 10.0))
        
        // Test different ratio points
        let ratios = [0.0, 0.25, 0.5, 0.75, 1.0]
        
        for ratio in ratios {
            let ratioPoint = GeometryUtils.getRatioPoint(segment: segment, r: ratio)
            print("Ratio \‍(ratio): (\‍(String(format: "%.2f", ratioPoint.x)), \‍(String(format: "%.2f", ratioPoint.y)))")
        }
 
        // Test projection ratio calculation
        let testPoint = Point(x: 5.0, y: 5.0)
        let projectionRatio = GeometryUtils.getProjectionRatio(segment: segment, point: testPoint)
        print("Projection ratio for point (5,5): \‍(String(format: "%.2f", projectionRatio))")
 
        // Test distance from segment to point
        let offSegmentPoint = Point(x: 5.0, y: 0.0)
        let distanceToOffPoint = GeometryUtils.segmentPointDistance(segment: segment, point: offSegmentPoint)
        print("Distance from segment to point (5,0): \‍(String(format: "%.2f", distanceToOffPoint)) meters")
    }
 
    /**
     * Main demonstration method
     */
    func runExample() {
        print("=== GeometryUtils Example ===")
        
        // Wait a bit for processing
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
            print("=== Example completed ===")
        }
    }
}
 
/**
 * Function to run the example
 */
func main() {
    let example = GeometryUtilsExample()
    example.runExample()
    
    // Keep the app running for a while to see the output
    RunLoop.main.run(until: Date().addingTimeInterval(10.0))
}
 
// Run the example
main()