LocationWindowCameraExample.swift

Go to the documentation of this file.

import Foundation
import NavigineSDK
 
/**
 * LocationWindowCamera usage example for Swift
 * Demonstrates specific methods: getCamera, setCamera, addCameraListener, removeCameraListener,
 * flyTo, moveTo, zoomFactor, minZoomFactor, maxZoomFactor
 */
class LocationWindowCameraExample {
    private var locationWindow: NCLocationWindow?
    private var cameraListener: CameraListenerImpl?
    
    init() {
        demonstrateLocationWindowCameraMethods()
    }
    
    /**
     * Demonstrate LocationWindowCamera methods
     */
    private func demonstrateLocationWindowCameraMethods() {
        print("=== LocationWindowCamera Methods ===")
        
        demonstrateCameraProperties()
        demonstrateGetSetCamera()
        demonstrateCameraListeners()
        demonstrateFlyToMethod()
        demonstrateMoveToMethod()
        demonstrateZoomProperties()
        demonstrateCameraScenarios()
    }
    
    /**
     * Demonstrate camera properties setup
     */
    private func demonstrateCameraProperties() {
        print("--- Camera Properties Setup ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_minZoomFactor]
        // Set minimum zoom factor
        locationWindow.minZoomFactor = 10.0
        print("Set minimum zoom factor to 10.0 pixels per meter")
        // [swift_LocationWindow_minZoomFactor]
 
        // [swift_LocationWindow_maxZoomFactor]
        // Set maximum zoom factor
        locationWindow.maxZoomFactor = 1000.0
        print("Set maximum zoom factor to 1000.0 pixels per meter")
        // [swift_LocationWindow_maxZoomFactor]
    }
    
    /**
     * Demonstrate getCamera and setCamera methods
     */
    private func demonstrateGetSetCamera() {
        print("--- getCamera and setCamera Methods ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_getCamera]
        // Get current camera position
        let currentCamera = locationWindow.camera
        print("Current camera position:")
        print("  Point: (\‍(currentCamera.point.x), \‍(currentCamera.point.y))")
        print("  Zoom: \‍(currentCamera.zoom)")
        print("  Rotation: \‍(currentCamera.rotation)°")
        // [swift_LocationWindow_getCamera]
 
        // [swift_Camera_constructor]
        // Create camera with constructor
        let newPoint = NCPoint(x: 100.0, y: 200.0)
        let newCamera = NCCamera(point: newPoint, zoom: 50.0, rotation: 0.0)
        print("Created camera with point (\‍(newPoint.x), \‍(newPoint.y)), zoom 50.0, rotation 0°")
        // [swift_Camera_constructor]
 
        // [swift_Camera_access]
        // Access camera properties
        print("Camera properties:")
        print("  Point: (\‍(newCamera.point.x), \‍(newCamera.point.y))")
        print("  Zoom: \‍(newCamera.zoom)")
        print("  Rotation: \‍(newCamera.rotation)°")
        // [swift_Camera_access]
 
        // [swift_LocationWindow_setCamera]
        // Set camera position without animation
        locationWindow.camera = newCamera
        print("Set camera position to (\‍(newPoint.x), \‍(newPoint.y)) with zoom 50.0 and rotation 0°")
        // [swift_LocationWindow_setCamera]
 
        // [swift_LocationWindow_setCamera_2]
        // Set camera position with rotation
        let rotatedPoint = NCPoint(x: 150.0, y: 250.0)
        let rotatedCamera = NCCamera(point: rotatedPoint, zoom: 75.0, rotation: 45.0)
        locationWindow.camera = rotatedCamera
        print("Set camera position to (\‍(rotatedPoint.x), \‍(rotatedPoint.y)) with zoom 75.0 and rotation 45°")
        // [swift_LocationWindow_setCamera_2]
 
        // Test different camera positions
        let testCameras = [
            NCCamera(point: NCPoint(x: 0.0, y: 0.0), zoom: 10.0, rotation: 0.0),    // Overview camera
            NCCamera(point: NCPoint(x: 50.0, y: 75.0), zoom: 500.0, rotation: 0.0), // Detail camera
            NCCamera(point: NCPoint(x: 100.0, y: 150.0), zoom: 100.0, rotation: 30.0), // Angled camera
        ]
 
        for (i, camera) in testCameras.enumerated() {
            locationWindow.camera = camera
            print("Test camera \‍(i): Point (\‍(camera.point.x), \‍(camera.point.y)), Zoom \‍(camera.zoom), Rotation \‍(camera.rotation)°")
        }
    }
    
    /**
     * Demonstrate camera listener methods
     */
    private func demonstrateCameraListeners() {
        print("--- Camera Listener Methods ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_addCameraListener]
        // Add camera listener
        cameraListener = CameraListenerImpl()
        locationWindow.addCameraListener(cameraListener!)
        print("Added camera listener")
        // [swift_LocationWindow_addCameraListener]
 
        // [swift_LocationWindow_removeCameraListener]
        // Remove camera listener
        locationWindow.removeCameraListener(cameraListener!)
        cameraListener = nil
        print("Removed camera listener")
        // [swift_LocationWindow_removeCameraListener]
 
        // Test multiple listeners
        let listeners = [
            CameraListenerImpl(),
            CameraListenerImpl(),
            CameraListenerImpl(),
        ]
 
        for (i, listener) in listeners.enumerated() {
            locationWindow.addCameraListener(listener)
            print("Added camera listener \‍(i)")
        }
 
        for (i, listener) in listeners.enumerated() {
            locationWindow.removeCameraListener(listener)
            print("Removed camera listener \‍(i)")
        }
    }
    
    /**
     * Demonstrate flyTo method
     */
    private func demonstrateFlyToMethod() {
        print("--- flyTo Method ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_flyTo]
        // Fly to position with smooth animation
        let targetPoint = NCPoint(x: 150.0, y: 250.0)
        let targetCamera = NCCamera(point: targetPoint, zoom: 75.0, rotation: 45.0)
        let callback = CameraCallbackImpl()
        locationWindow.flyTo(camera: targetCamera, duration: 2000, callback: callback)
        print("Started fly to animation to point (\‍(targetPoint.x), \‍(targetPoint.y))")
        // [swift_LocationWindow_flyTo]
 
        // [swift_LocationWindow_flyTo_2]
        // Fly to another position with different duration
        let targetPoint2 = NCPoint(x: 300.0, y: 400.0)
        let targetCamera2 = NCCamera(point: targetPoint2, zoom: 25.0, rotation: 180.0)
        let callback2 = CameraCallbackImpl()
        locationWindow.flyTo(camera: targetCamera2, duration: 3000, callback: callback2)
        print("Started fly to animation to point (\‍(targetPoint2.x), \‍(targetPoint2.y)) with 3 second duration")
        // [swift_LocationWindow_flyTo_2]
 
        // Test fly to with different parameters
        let flyToTests = [
            ["point": NCPoint(x: 50.0, y: 50.0), "zoom": 100.0, "rotation": 0.0, "duration": 1000],
            ["point": NCPoint(x: 200.0, y: 300.0), "zoom": 200.0, "rotation": 90.0, "duration": 1500],
            ["point": NCPoint(x: 400.0, y: 100.0), "zoom": 50.0, "rotation": 270.0, "duration": 2500],
        ]
 
        for (i, test) in flyToTests.enumerated() {
            let point = test["point"] as! NCPoint
            let zoom = test["zoom"] as! Double
            let rotation = test["rotation"] as! Double
            let duration = test["duration"] as! Int
            
            let camera = NCCamera(point: point, zoom: zoom, rotation: rotation)
            let testCallback = CameraCallbackImpl()
            locationWindow.flyTo(camera: camera, duration: duration, callback: testCallback)
            print("Fly to test \‍(i): Point (\‍(point.x), \‍(point.y)), Zoom \‍(zoom), Rotation \‍(rotation)°, Duration \‍(duration)ms")
        }
    }
    
    /**
     * Demonstrate moveTo method
     */
    private func demonstrateMoveToMethod() {
        print("--- moveTo Method ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_moveTo]
        // Move to position with linear animation
        let targetPoint = NCPoint(x: 200.0, y: 300.0)
        let targetCamera = NCCamera(point: targetPoint, zoom: 100.0, rotation: 90.0)
        let callback = CameraCallbackImpl()
        locationWindow.moveTo(camera: targetCamera, duration: 1500, animationType: .linear, callback: callback)
        print("Started move to with linear animation")
        // [swift_LocationWindow_moveTo]
 
        // [swift_LocationWindow_moveTo_2]
        // Move to position with cubic animation
        let callback2 = CameraCallbackImpl()
        locationWindow.moveTo(camera: targetCamera, duration: 1500, animationType: .cubic, callback: callback2)
        print("Started move to with cubic animation")
        // [swift_LocationWindow_moveTo_2]
 
        // [swift_LocationWindow_moveTo_3]
        // Move to position with sine animation
        let callback3 = CameraCallbackImpl()
        locationWindow.moveTo(camera: targetCamera, duration: 1500, animationType: .sine, callback: callback3)
        print("Started move to with sine animation")
        // [swift_LocationWindow_moveTo_3]
 
        // [swift_LocationWindow_moveTo_4]
        // Move to position without animation
        let instantPoint = NCPoint(x: 300.0, y: 400.0)
        let instantCamera = NCCamera(point: instantPoint, zoom: 25.0, rotation: 180.0)
        let instantCallback = CameraCallbackImpl()
        locationWindow.moveTo(camera: instantCamera, duration: 0, animationType: .none, callback: instantCallback)
        print("Executed instant move to position (\‍(instantPoint.x), \‍(instantPoint.y))")
        // [swift_LocationWindow_moveTo_4]
 
        // Test move to with different animation types
        let animationTypes: [NCAnimationType] = [
            .linear,
            .cubic,
            .quint,
            .sine,
            .none,
        ]
 
        for (i, animationType) in animationTypes.enumerated() {
            let testPoint = NCPoint(x: 100.0 + Double(i) * 50.0, y: 200.0 + Double(i) * 50.0)
            let testCamera = NCCamera(point: testPoint, zoom: 50.0 + Double(i) * 10.0, rotation: Double(i) * 30.0)
            let testCallback = CameraCallbackImpl()
            locationWindow.moveTo(camera: testCamera, duration: 1000, animationType: animationType, callback: testCallback)
            print("Move to test \‍(i): Animation \‍(animationType), Point (\‍(testPoint.x), \‍(testPoint.y))")
        }
    }
    
    /**
     * Demonstrate zoom properties
     */
    private func demonstrateZoomProperties() {
        print("--- Zoom Properties ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_getZoomFactor]
        // Get current zoom factor
        let currentZoom = locationWindow.zoomFactor
        print("Current zoom factor: \‍(currentZoom) pixels per meter")
        // [swift_LocationWindow_getZoomFactor]
 
        // [swift_LocationWindow_setZoomFactor]
        // Set new zoom factor
        locationWindow.zoomFactor = 200.0
        print("Set zoom factor to 200.0 pixels per meter")
        // [swift_LocationWindow_setZoomFactor]
 
        // [swift_LocationWindow_getMinZoomFactor]
        // Get minimum zoom factor
        let minZoom = locationWindow.minZoomFactor
        print("Minimum zoom factor: \‍(minZoom) pixels per meter")
        // [swift_LocationWindow_getMinZoomFactor]
 
        // [swift_LocationWindow_getMaxZoomFactor]
        // Get maximum zoom factor
        let maxZoom = locationWindow.maxZoomFactor
        print("Maximum zoom factor: \‍(maxZoom) pixels per meter")
        // [swift_LocationWindow_getMaxZoomFactor]
 
        // Test zoom factor changes
        let zoomLevels: [Double] = [50.0, 100.0, 150.0, 300.0, 500.0, 800.0]
        
        for zoom in zoomLevels {
            locationWindow.zoomFactor = zoom
            print("Set zoom factor to \‍(zoom) pixels per meter")
            
            // Verify the change
            let actualZoom = locationWindow.zoomFactor
            print("Actual zoom factor: \‍(actualZoom) pixels per meter")
        }
    }
    
    /**
     * Demonstrate camera scenarios
     */
    private func demonstrateCameraScenarios() {
        print("--- Camera Scenarios ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_camera_scenarios]
        // Create cameras for different scenarios
        let overviewCamera = NCCamera(point: NCPoint(x: 0.0, y: 0.0), zoom: 10.0, rotation: 0.0)
        let detailCamera = NCCamera(point: NCPoint(x: 50.0, y: 75.0), zoom: 500.0, rotation: 0.0)
        let angledCamera = NCCamera(point: NCPoint(x: 100.0, y: 150.0), zoom: 100.0, rotation: 30.0)
        
        print("Created cameras for different scenarios:")
        print("  Overview camera: zoom \‍(overviewCamera.zoom)")
        print("  Detail camera: zoom \‍(detailCamera.zoom)")
        print("  Angled camera: rotation \‍(angledCamera.rotation)°")
        // [swift_LocationWindow_camera_scenarios]
 
        // Test scenario transitions
        let scenarios = [overviewCamera, detailCamera, angledCamera]
        let scenarioNames = ["Overview", "Detail", "Angled"]
        
        for (i, scenario) in scenarios.enumerated() {
            let name = scenarioNames[i]
            let scenarioCallback = CameraCallbackImpl()
            locationWindow.moveTo(camera: scenario, duration: 2000, animationType: .cubic, callback: scenarioCallback)
            print("Transitioning to \‍(name) scenario")
        }
    }
    
    /**
     * Cleanup resources
     */
    func cleanup() {
        if let cameraListener = cameraListener, let locationWindow = locationWindow {
            locationWindow.removeCameraListener(cameraListener)
            self.cameraListener = nil
            print("Camera listener removed")
        }
    }
}
 
/**
 * Camera listener implementation
 */
class CameraListenerImpl: NSObject, NCCameraListener {
    // [swift_CameraListener_onCameraPositionChanged]
    func onCameraPositionChanged(reason: NCCameraUpdateReason, finished: Bool) {
        let reasonText = (reason == .gestures) ? "user gestures" : "application"
        let statusText = finished ? "finished" : "in progress"
        
        print("Camera position changed: \‍(reasonText), status: \‍(statusText)")
        
        if finished {
            print("Camera movement completed")
        }
    }
    // [swift_CameraListener_onCameraPositionChanged]
}
 
/**
 * Camera callback implementation
 */
class CameraCallbackImpl: NSObject, NCCameraCallback {
    func onMoveFinished(completed: Bool) {
        if completed {
            print("Camera movement completed successfully")
        } else {
            print("Camera movement was cancelled")
        }
    }
}
 
/**
 * Camera utilities
 */
class CameraUtils {
    /**
     * Create camera for centered point with given zoom
     */
    static func createCenteredCamera(x: Double, y: Double, zoom: Double) -> NCCamera {
        let point = NCPoint(x: x, y: y)
        return NCCamera(point: point, zoom: zoom, rotation: 0.0)
    }
    
    /**
     * Create camera with rotation
     */
    static func createRotatedCamera(x: Double, y: Double, zoom: Double, rotation: Double) -> NCCamera {
        let point = NCPoint(x: x, y: y)
        return NCCamera(point: point, zoom: zoom, rotation: rotation)
    }
    
    /**
     * Validate camera position
     */
    static func isValidCamera(_ camera: NCCamera) -> Bool {
        return camera.zoom > 0 && 
               camera.rotation >= 0 && camera.rotation < 360
    }
    
    /**
     * Create camera for showing area
     */
    static func createAreaCamera(centerX: Double, centerY: Double, width: Double, height: Double) -> NCCamera {
        // Calculate zoom based on area size
        let zoom = 100.0 / max(width, height)
        let point = NCPoint(x: centerX, y: centerY)
        return NCCamera(point: point, zoom: zoom, rotation: 0.0)
    }
    
    /**
     * Create camera for showing path
     */
    static func createPathCamera(points: [NCPoint]) -> NCCamera {
        if points.isEmpty {
            let point = NCPoint(x: 0.0, y: 0.0)
            return NCCamera(point: point, zoom: 100.0, rotation: 0.0)
        }
        
        // Find path center
        let centerX = points.map { $0.x }.reduce(0, +) / Double(points.count)
        let centerY = points.map { $0.y }.reduce(0, +) / Double(points.count)
        
        // Calculate area size
        let minX = points.map { $0.x }.min()!
        let minY = points.map { $0.y }.min()!
        let maxX = points.map { $0.x }.max()!
        let maxY = points.map { $0.y }.max()!
        
        let width = maxX - minX
        let height = maxY - minY
        
        return createAreaCamera(centerX: centerX, centerY: centerY, width: width, height: height)
    }
    
    /**
     * Create camera for showing multiple points
     */
    static func createMultiPointCamera(points: [NCPoint], padding: Double = 10.0) -> NCCamera {
        if points.isEmpty {
            let point = NCPoint(x: 0.0, y: 0.0)
            return NCCamera(point: point, zoom: 100.0, rotation: 0.0)
        }
        
        // Find center
        let centerX = points.map { $0.x }.reduce(0, +) / Double(points.count)
        let centerY = points.map { $0.y }.reduce(0, +) / Double(points.count)
        
        // Calculate area size with padding
        let minX = points.map { $0.x }.min()! - padding
        let minY = points.map { $0.y }.min()! - padding
        let maxX = points.map { $0.x }.max()! + padding
        let maxY = points.map { $0.y }.max()! + padding
        
        let width = maxX - minX
        let height = maxY - minY
        
        return createAreaCamera(centerX: centerX, centerY: centerY, width: width, height: height)
    }
}
 
/**
 * Extensions for convenient camera operations
 */
extension NCLocationWindow {
    /**
     * Zoom to point
     */
    func zoomTo(point: NCPoint, zoom: Double, duration: Int = 1000) {
        let camera = NCCamera(point: point, zoom: zoom, rotation: 0.0)
        let callback = CameraCallbackImpl()
        moveTo(camera: camera, duration: duration, animationType: .cubic, callback: callback)
    }
    
    /**
     * Pan to point
     */
    func panTo(point: NCPoint, duration: Int = 1000) {
        let currentCamera = camera
        let newCamera = NCCamera(point: point, zoom: currentCamera.zoom, rotation: currentCamera.rotation)
        let callback = CameraCallbackImpl()
        moveTo(camera: newCamera, duration: duration, animationType: .linear, callback: callback)
    }
    
    /**
     * Rotate camera
     */
    func rotateTo(rotation: Double, duration: Int = 1000) {
        let currentCamera = camera
        let newCamera = NCCamera(point: currentCamera.point, zoom: currentCamera.zoom, rotation: rotation)
        let callback = CameraCallbackImpl()
        moveTo(camera: newCamera, duration: duration, animationType: .sine, callback: callback)
    }
    
    /**
     * Fly to point with automatic zoom
     */
    func flyToPoint(point: NCPoint, duration: Int = 2000) {
        let currentCamera = camera
        let distance = sqrt(pow(point.x - currentCamera.point.x, 2) + pow(point.y - currentCamera.point.y, 2))
        let newZoom = max(currentCamera.zoom * 0.8, min(currentCamera.zoom * 1.2, 100.0 / distance))
        
        let targetCamera = NCCamera(point: point, zoom: newZoom, rotation: currentCamera.rotation)
        let callback = CameraCallbackImpl()
        flyTo(camera: targetCamera, duration: duration, callback: callback)
    }
}
 
/**
 * Usage example
 */
func main() {
    // Create example instance
    let example = LocationWindowCameraExample()
    
    // Assume we have NCLocationWindow
    // let locationWindow: NCLocationWindow = getLocationWindow()
    // example.locationWindow = locationWindow
    
    // Demonstrate methods
    print("=== LocationWindowCamera Examples ===")
    
    // Cleanup
    example.cleanup()
    
    print("Examples ready to use!")
}
 
// Run example
main()