GeometryUtilsExample.m

Go to the documentation of this file.

#import "GeometryUtilsExample.h"

@implementation GeometryUtilsExample
 
- (instancetype)init {
    self = [super init];
    if (self) {
        [self demonstrateGeometryUtilsMethods];
    }
    return self;
}

- (void)demonstrateGeometryUtilsMethods {
    NSLog(@"=== GeometryUtils Methods ===");
    
    [self demonstratePointOperations];
    [self demonstrateGlobalPointOperations];
    [self demonstrateBoundingBoxOperations];
    [self demonstrateSegmentOperations];
    [self demonstratePolygonOperations];
    [self demonstrateLineOperations];
    [self demonstrateAdvancedGeometryOperations];
}

- (void)demonstratePointOperations {
    NSLog(@"--- Point Operations ---");
 
    // [objc_Point_constructor]
    // Create points with x, y coordinates
    NCPoint *point1 = [[NCPoint alloc] initWithX:10.0 y:20.0];
    NCPoint *point2 = [[NCPoint alloc] initWithX:30.0 y:40.0];
    NCPoint *point3 = [[NCPoint alloc] initWithX:50.0 y:60.0];
    NSLog(@"Created points: P1(%.1f, %.1f), P2(%.1f, %.1f), P3(%.1f, %.1f)", 
          point1.x, point1.y, point2.x, point2.y, point3.x, point3.y);
    // [objc_Point_constructor]
 
    // [objc_Point_getX]
    // Get X coordinate
    double x1 = point1.x;
    NSLog(@"Point1 X coordinate: %.1f", x1);
    // [objc_Point_getX]
 
    // [objc_Point_getY]
    // Get Y coordinate
    double y1 = point1.y;
    NSLog(@"Point1 Y coordinate: %.1f", y1);
    // [objc_Point_getY]
 
    // [objc_GeometryUtils_distanceBetweenPoints]
    // Calculate distance between points
    double distance = [NCGeometryUtils distanceBetweenPointsWithFrom:point1 to:point2];
    NSLog(@"Distance between P1 and P2: %.2f meters", distance);
    // [objc_GeometryUtils_distanceBetweenPoints]
 
    // Create more points for testing
    NSArray<NCPoint *> *testPoints = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:10.0],
        [[NCPoint alloc] initWithX:0.0 y:10.0],
        [[NCPoint alloc] initWithX:5.0 y:5.0]
    ];
 
    NSLog(@"Test points created for further calculations");
}

- (void)demonstrateBoundingBoxOperations {
    NSLog(@"--- BoundingBox Operations ---");
 
    NCPoint *bottomLeft = [[NCPoint alloc] initWithX:0.0 y:0.0];
    NCPoint *topRight = [[NCPoint alloc] initWithX:10.0 y:20.0];
 
    // [objc_BoundingBox_constructor]
    NCBoundingBox *boundingBox = [[NCBoundingBox alloc] initWithBottomLeft:bottomLeft topRight:topRight];
    NSLog(@"Created bounding box: bottomLeft(%.1f, %.1f), topRight(%.1f, %.1f)",
          boundingBox.bottomLeft.x, boundingBox.bottomLeft.y,
          boundingBox.topRight.x, boundingBox.topRight.y);
    // [objc_BoundingBox_constructor]
 
    // [objc_BoundingBox_getBottomLeft]
    NCPoint *leftCorner = boundingBox.bottomLeft;
    NSLog(@"Bottom-left corner: (%.1f, %.1f)", leftCorner.x, leftCorner.y);
    // [objc_BoundingBox_getBottomLeft]
 
    // [objc_BoundingBox_getTopRight]
    NCPoint *rightCorner = boundingBox.topRight;
    NSLog(@"Top-right corner: (%.1f, %.1f)", rightCorner.x, rightCorner.y);
    // [objc_BoundingBox_getTopRight]
}

- (void)demonstrateGlobalPointOperations {
    NSLog(@"--- GlobalPoint Operations ---");
 
    // [objc_GlobalPoint_constructor]
    // Create global points with latitude, longitude
    NCGlobalPoint *globalPoint1 = [[NCGlobalPoint alloc] initWithLatitude:55.7558 longitude:37.6176]; // Moscow
    NCGlobalPoint *globalPoint2 = [[NCGlobalPoint alloc] initWithLatitude:59.9311 longitude:30.3609]; // St. Petersburg
    NCGlobalPoint *globalPoint3 = [[NCGlobalPoint alloc] initWithLatitude:55.7522 longitude:37.6156]; // Moscow center
    NSLog(@"Created global points: GP1(%.4f, %.4f), GP2(%.4f, %.4f)", 
          globalPoint1.latitude, globalPoint1.longitude, globalPoint2.latitude, globalPoint2.longitude);
    // [objc_GlobalPoint_constructor]
 
    // [objc_GlobalPoint_getLatitude]
    // Get latitude
    double lat1 = globalPoint1.latitude;
    NSLog(@"GlobalPoint1 latitude: %.4f", lat1);
    // [objc_GlobalPoint_getLatitude]
 
    // [objc_GlobalPoint_getLongitude]
    // Get longitude
    double lon1 = globalPoint1.longitude;
    NSLog(@"GlobalPoint1 longitude: %.4f", lon1);
    // [objc_GlobalPoint_getLongitude]
 
    // [objc_GeometryUtils_distanceBetweenGlobalPoints]
    // Calculate distance between global points
    double globalDistance = [NCGeometryUtils distanceBetweenGlobalPointsWithFrom:globalPoint1 to:globalPoint2];
    NSLog(@"Distance between Moscow and St. Petersburg: %.2f meters", globalDistance);
    // [objc_GeometryUtils_distanceBetweenGlobalPoints]
 
    // Calculate distance between nearby points
    double nearbyDistance = [NCGeometryUtils distanceBetweenGlobalPointsWithFrom:globalPoint1 to:globalPoint3];
    NSLog(@"Distance between Moscow points: %.2f meters", nearbyDistance);
}

- (void)demonstrateSegmentOperations {
    NSLog(@"--- Segment Operations ---");
 
    // Create points for segments
    NCPoint *start1 = [[NCPoint alloc] initWithX:0.0 y:0.0];
    NCPoint *end1 = [[NCPoint alloc] initWithX:10.0 y:10.0];
    NCPoint *start2 = [[NCPoint alloc] initWithX:0.0 y:10.0];
    NCPoint *end2 = [[NCPoint alloc] initWithX:10.0 y:0.0];
    NCPoint *testPoint = [[NCPoint alloc] initWithX:5.0 y:5.0];
 
    // [objc_Segment_constructor]
    // Create segments
    NCSegment *segment1 = [[NCSegment alloc] initWithStart:start1 end:end1];
    NCSegment *segment2 = [[NCSegment alloc] initWithStart:start2 end:end2];
    NSLog(@"Created segments: S1((%.1f, %.1f) -> (%.1f, %.1f)), S2((%.1f, %.1f) -> (%.1f, %.1f))", 
          segment1.start.x, segment1.start.y, segment1.end.x, segment1.end.y,
          segment2.start.x, segment2.start.y, segment2.end.x, segment2.end.y);
    // [objc_Segment_constructor]
 
    // [objc_Segment_getStart]
    // Get start point
    NCPoint *segment1Start = segment1.start;
    NSLog(@"Segment1 start point: (%.1f, %.1f)", segment1Start.x, segment1Start.y);
    // [objc_Segment_getStart]
 
    // [objc_Segment_getEnd]
    // Get end point
    NCPoint *segment1End = segment1.end;
    NSLog(@"Segment1 end point: (%.1f, %.1f)", segment1End.x, segment1End.y);
    // [objc_Segment_getEnd]
 
    // [objc_GeometryUtils_segmentLength]
    // Calculate segment length
    double length1 = [NCGeometryUtils segmentLengthWithSegment:segment1];
    double length2 = [NCGeometryUtils segmentLengthWithSegment:segment2];
    NSLog(@"Segment1 length: %.2f meters", length1);
    NSLog(@"Segment2 length: %.2f meters", length2);
    // [objc_GeometryUtils_segmentLength]
 
    // [objc_GeometryUtils_segmentPointDistance]
    // Calculate distance from segment to point
    double distanceToPoint = [NCGeometryUtils segmentPointDistanceWithSegment:segment1 point:testPoint];
    NSLog(@"Distance from segment1 to test point: %.2f meters", distanceToPoint);
    // [objc_GeometryUtils_segmentPointDistance]
 
    // [objc_GeometryUtils_segmentIntersectsSegment]
    // Check if segments intersect
    BOOL intersects = [NCGeometryUtils segmentIntersectsSegmentWithSegment1:segment1 segment2:segment2];
    NSLog(@"Segments intersect: %@", intersects ? @"YES" : @"NO");
    // [objc_GeometryUtils_segmentIntersectsSegment]
 
    // [objc_GeometryUtils_segmentIntersectionSegment]
    // Calculate intersection point
    NCPoint *intersection = [NCGeometryUtils segmentIntersectionSegmentWithSegment1:segment1 segment2:segment2];
    NSLog(@"Intersection point: (%.2f, %.2f)", intersection.x, intersection.y);
    // [objc_GeometryUtils_segmentIntersectionSegment]
 
    // [objc_GeometryUtils_divisionRatioBySegment]
    // Calculate division ratio
    double divisionRatio = [NCGeometryUtils divisionRatioBySegmentWithSegment1:segment1 segment2:segment2];
    NSLog(@"Division ratio: %.2f", divisionRatio);
    // [objc_GeometryUtils_divisionRatioBySegment]
 
    // [objc_GeometryUtils_getRatioPoint]
    // Get point at specific ratio
    double ratio = 0.5;
    NCPoint *ratioPoint = [NCGeometryUtils getRatioPointWithSegment:segment1 r:ratio];
    NSLog(@"Point at ratio %.1f: (%.2f, %.2f)", ratio, ratioPoint.x, ratioPoint.y);
    // [objc_GeometryUtils_getRatioPoint]
 
    // [objc_GeometryUtils_getProjectionRatio]
    // Calculate projection ratio
    double projectionRatio = [NCGeometryUtils getProjectionRatioWithSegment:segment1 point:testPoint];
    NSLog(@"Projection ratio: %.2f", projectionRatio);
    // [objc_GeometryUtils_getProjectionRatio]
}

- (void)demonstratePolygonOperations {
    NSLog(@"--- Polygon Operations ---");
 
    // Create points for polygon
    NSArray<NCPoint *> *polygonPoints = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:10.0],
        [[NCPoint alloc] initWithX:0.0 y:10.0]
    ];
 
    // [objc_Polygon_constructor]
    // Create polygon
    NCPolygon *polygon = [[NCPolygon alloc] initWithPoints:polygonPoints];
    NSLog(@"Created polygon with %lu points", (unsigned long)polygon.points.count);
    // [objc_Polygon_constructor]
 
    // [objc_Polygon_getPoints]
    // Get polygon points
    NSArray<NCPoint *> *points = polygon.points;
    NSMutableString *pointsString = [NSMutableString string];
    for (NCPoint *point in points) {
        if (pointsString.length > 0) {
            [pointsString appendString:@", "];
        }
        [pointsString appendFormat:@"(%.1f, %.1f)", point.x, point.y];
    }
    NSLog(@"Polygon points: %@", pointsString);
    // [objc_Polygon_getPoints]
 
    // [objc_GeometryUtils_polygonArea]
    // Calculate polygon area
    double area = [NCGeometryUtils polygonAreaWithPolygon:polygon];
    NSLog(@"Polygon area: %.2f square meters", area);
    // [objc_GeometryUtils_polygonArea]
 
    // [objc_GeometryUtils_polygonCenter]
    // Calculate polygon center
    NCPoint *center = [NCGeometryUtils polygonCenterWithPolygon:polygon];
    NSLog(@"Polygon center: (%.2f, %.2f)", center.x, center.y);
    // [objc_GeometryUtils_polygonCenter]
 
    // [objc_GeometryUtils_polygonContainsPoint]
    // Check if polygon contains point
    NCPoint *insidePoint = [[NCPoint alloc] initWithX:5.0 y:5.0];
    NCPoint *outsidePoint = [[NCPoint alloc] initWithX:15.0 y:15.0];
    
    BOOL containsInside = [NCGeometryUtils polygonContainsPointWithPolygon:polygon point:insidePoint];
    BOOL containsOutside = [NCGeometryUtils polygonContainsPointWithPolygon:polygon point:outsidePoint];
    
    NSLog(@"Polygon contains inside point: %@", containsInside ? @"YES" : @"NO");
    NSLog(@"Polygon contains outside point: %@", containsOutside ? @"YES" : @"NO");
    // [objc_GeometryUtils_polygonContainsPoint]
 
    // Create complex polygon
    NSArray<NCPoint *> *complexPolygonPoints = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:20.0 y:0.0],
        [[NCPoint alloc] initWithX:20.0 y:20.0],
        [[NCPoint alloc] initWithX:10.0 y:10.0],
        [[NCPoint alloc] initWithX:0.0 y:20.0]
    ];
    NCPolygon *complexPolygon = [[NCPolygon alloc] initWithPoints:complexPolygonPoints];
    
    double complexArea = [NCGeometryUtils polygonAreaWithPolygon:complexPolygon];
    NCPoint *complexCenter = [NCGeometryUtils polygonCenterWithPolygon:complexPolygon];
    
    NSLog(@"Complex polygon area: %.2f square meters", complexArea);
    NSLog(@"Complex polygon center: (%.2f, %.2f)", complexCenter.x, complexCenter.y);
}

- (void)demonstrateLineOperations {
    NSLog(@"--- Line Operations ---");
 
    // Create segments for line
    NSArray<NCSegment *> *lineSegments = @[
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                    end:[[NCPoint alloc] initWithX:10.0 y:10.0]],
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:10.0 y:10.0] 
                                    end:[[NCPoint alloc] initWithX:20.0 y:5.0]],
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:20.0 y:5.0] 
                                    end:[[NCPoint alloc] initWithX:30.0 y:15.0]]
    ];
 
    // [objc_Line_constructor]
    // Create line
    NCLine *line = [[NCLine alloc] initWithSegments:lineSegments];
    NSLog(@"Created line with %lu segments", (unsigned long)line.segments.count);
    // [objc_Line_constructor]
 
    // [objc_Line_getSegments]
    // Get line segments
    NSArray<NCSegment *> *segments = line.segments;
    NSLog(@"Line segments: %lu segments", (unsigned long)segments.count);
    // [objc_Line_getSegments]
 
    // Calculate total length of line
    double totalLength = 0.0;
    for (NCSegment *segment in segments) {
        totalLength += [NCGeometryUtils segmentLengthWithSegment:segment];
    }
    NSLog(@"Total line length: %.2f meters", totalLength);
 
    // Create complex line
    NSArray<NCSegment *> *complexLineSegments = @[
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                    end:[[NCPoint alloc] initWithX:5.0 y:5.0]],
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:5.0 y:5.0] 
                                    end:[[NCPoint alloc] initWithX:10.0 y:0.0]],
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:10.0 y:0.0] 
                                    end:[[NCPoint alloc] initWithX:15.0 y:10.0]],
        [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:15.0 y:10.0] 
                                    end:[[NCPoint alloc] initWithX:20.0 y:5.0]]
    ];
    NCLine *complexLine = [[NCLine alloc] initWithSegments:complexLineSegments];
    
    double complexTotalLength = 0.0;
    for (NCSegment *segment in complexLine.segments) {
        complexTotalLength += [NCGeometryUtils segmentLengthWithSegment:segment];
    }
    NSLog(@"Complex line total length: %.2f meters", complexTotalLength);
}

- (void)demonstrateAdvancedGeometryOperations {
    NSLog(@"--- Advanced Geometry Operations ---");
 
    // Test distance calculations with various scenarios
    [self demonstrateDistanceCalculations];
    
    // Test intersection scenarios
    [self demonstrateIntersectionScenarios];
    
    // Test polygon operations with different shapes
    [self demonstratePolygonScenarios];
    
    // Test projection and ratio calculations
    [self demonstrateProjectionCalculations];
}

- (void)demonstrateDistanceCalculations {
    NSLog(@"--- Distance Calculations ---");
 
    // Test point distances
    NCPoint *origin = [[NCPoint alloc] initWithX:0.0 y:0.0];
    NSArray<NCPoint *> *testPoints = @[
        [[NCPoint alloc] initWithX:3.0 y:4.0],  // Should be 5.0 distance
        [[NCPoint alloc] initWithX:6.0 y:8.0],  // Should be 10.0 distance
        [[NCPoint alloc] initWithX:1.0 y:1.0]   // Should be sqrt(2) distance
    ];
 
    for (NCPoint *testPoint in testPoints) {
        double distance = [NCGeometryUtils distanceBetweenPointsWithFrom:origin to:testPoint];
        NSLog(@"Distance from origin to (%.1f, %.1f): %.2f meters", testPoint.x, testPoint.y, distance);
    }
 
    // Test global point distances
    NCGlobalPoint *moscow = [[NCGlobalPoint alloc] initWithLatitude:55.7558 longitude:37.6176];
    NCGlobalPoint *london = [[NCGlobalPoint alloc] initWithLatitude:51.5074 longitude:-0.1278];
    NCGlobalPoint *tokyo = [[NCGlobalPoint alloc] initWithLatitude:35.6762 longitude:139.6503];
 
    double moscowLondon = [NCGeometryUtils distanceBetweenGlobalPointsWithFrom:moscow to:london];
    double moscowTokyo = [NCGeometryUtils distanceBetweenGlobalPointsWithFrom:moscow to:tokyo];
    
    NSLog(@"Moscow to London: %.2f km", moscowLondon / 1000);
    NSLog(@"Moscow to Tokyo: %.2f km", moscowTokyo / 1000);
}

- (void)demonstrateIntersectionScenarios {
    NSLog(@"--- Intersection Scenarios ---");
 
    // Parallel segments (should not intersect)
    NCSegment *parallel1 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                                        end:[[NCPoint alloc] initWithX:10.0 y:0.0]];
    NCSegment *parallel2 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:5.0] 
                                                        end:[[NCPoint alloc] initWithX:10.0 y:5.0]];
    
    BOOL parallelIntersects = [NCGeometryUtils segmentIntersectsSegmentWithSegment1:parallel1 segment2:parallel2];
    NSLog(@"Parallel segments intersect: %@", parallelIntersects ? @"YES" : @"NO");
 
    // Perpendicular segments (should intersect)
    NCSegment *perpendicular1 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                                             end:[[NCPoint alloc] initWithX:10.0 y:0.0]];
    NCSegment *perpendicular2 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:5.0 y:-5.0] 
                                                             end:[[NCPoint alloc] initWithX:5.0 y:5.0]];
    
    BOOL perpendicularIntersects = [NCGeometryUtils segmentIntersectsSegmentWithSegment1:perpendicular1 segment2:perpendicular2];
    NSLog(@"Perpendicular segments intersect: %@", perpendicularIntersects ? @"YES" : @"NO");
    
    if (perpendicularIntersects) {
        NCPoint *intersection = [NCGeometryUtils segmentIntersectionSegmentWithSegment1:perpendicular1 segment2:perpendicular2];
        NSLog(@"Intersection point: (%.2f, %.2f)", intersection.x, intersection.y);
    }
 
    // Overlapping segments
    NCSegment *overlap1 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                                      end:[[NCPoint alloc] initWithX:10.0 y:0.0]];
    NCSegment *overlap2 = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:5.0 y:0.0] 
                                                      end:[[NCPoint alloc] initWithX:15.0 y:0.0]];
    
    BOOL overlapIntersects = [NCGeometryUtils segmentIntersectsSegmentWithSegment1:overlap1 segment2:overlap2];
    NSLog(@"Overlapping segments intersect: %@", overlapIntersects ? @"YES" : @"NO");
}

- (void)demonstratePolygonScenarios {
    NSLog(@"--- Polygon Scenarios ---");
 
    // Regular square
    NSArray<NCPoint *> *square = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:10.0],
        [[NCPoint alloc] initWithX:0.0 y:10.0]
    ];
    NCPolygon *squarePolygon = [[NCPolygon alloc] initWithPoints:square];
    
    double squareArea = [NCGeometryUtils polygonAreaWithPolygon:squarePolygon];
    NCPoint *squareCenter = [NCGeometryUtils polygonCenterWithPolygon:squarePolygon];
    
    NSLog(@"Square area: %.2f square meters", squareArea);
    NSLog(@"Square center: (%.2f, %.2f)", squareCenter.x, squareCenter.y);
 
    // Triangle
    NSArray<NCPoint *> *triangle = @[
        [[NCPoint alloc] initWithX:0.0 y:0.0],
        [[NCPoint alloc] initWithX:10.0 y:0.0],
        [[NCPoint alloc] initWithX:5.0 y:10.0]
    ];
    NCPolygon *trianglePolygon = [[NCPolygon alloc] initWithPoints:triangle];
    
    double triangleArea = [NCGeometryUtils polygonAreaWithPolygon:trianglePolygon];
    NCPoint *triangleCenter = [NCGeometryUtils polygonCenterWithPolygon:trianglePolygon];
    
    NSLog(@"Triangle area: %.2f square meters", triangleArea);
    NSLog(@"Triangle center: (%.2f, %.2f)", triangleCenter.x, triangleCenter.y);
 
    // Test point containment
    NCPoint *insideSquare = [[NCPoint alloc] initWithX:5.0 y:5.0];
    NCPoint *outsideSquare = [[NCPoint alloc] initWithX:15.0 y:15.0];
    
    BOOL containsInside = [NCGeometryUtils polygonContainsPointWithPolygon:squarePolygon point:insideSquare];
    BOOL containsOutside = [NCGeometryUtils polygonContainsPointWithPolygon:squarePolygon point:outsideSquare];
    
    NSLog(@"Square contains (5,5): %@", containsInside ? @"YES" : @"NO");
    NSLog(@"Square contains (15,15): %@", containsOutside ? @"YES" : @"NO");
}

- (void)demonstrateProjectionCalculations {
    NSLog(@"--- Projection Calculations ---");
 
    NCSegment *segment = [[NCSegment alloc] initWithStart:[[NCPoint alloc] initWithX:0.0 y:0.0] 
                                                      end:[[NCPoint alloc] initWithX:10.0 y:10.0]];
    
    // Test different ratio points
    NSArray<NSNumber *> *ratios = @[@0.0, @0.25, @0.5, @0.75, @1.0];
    
    for (NSNumber *ratioNumber in ratios) {
        double ratio = ratioNumber.doubleValue;
        NCPoint *ratioPoint = [NCGeometryUtils getRatioPointWithSegment:segment r:ratio];
        NSLog(@"Ratio %.2f: (%.2f, %.2f)", ratio, ratioPoint.x, ratioPoint.y);
    }
 
    // Test projection ratio calculation
    NCPoint *testPoint = [[NCPoint alloc] initWithX:5.0 y:5.0];
    double projectionRatio = [NCGeometryUtils getProjectionRatioWithSegment:segment point:testPoint];
    NSLog(@"Projection ratio for point (5,5): %.2f", projectionRatio);
 
    // Test distance from segment to point
    NCPoint *offSegmentPoint = [[NCPoint alloc] initWithX:5.0 y:0.0];
    double distanceToOffPoint = [NCGeometryUtils segmentPointDistanceWithSegment:segment point:offSegmentPoint];
    NSLog(@"Distance from segment to point (5,0): %.2f meters", distanceToOffPoint);
}

- (void)runExample {
    NSLog(@"=== GeometryUtils Example ===");
    
    // Wait a bit for processing
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"=== Example completed ===");
    });
}
 
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        GeometryUtilsExample *example = [[GeometryUtilsExample alloc] init];
        [example runExample];
        
        // Keep the app running for a while to see the output
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:10.0]];
    }
    return 0;
}