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)°")
        print("  Tilt: \‍(currentCamera.tilt)° (0° = straight downward / map from above)")
        // [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, tilt: 0.0)
        print("Created camera with point (\‍(newPoint.x), \‍(newPoint.y)), zoom 50.0, rotation 0°, tilt 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)°")
        print("  Tilt: \‍(newCamera.tilt)°")
        // [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, rotation 0°, tilt 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, tilt: 0.0)
        locationWindow.camera = rotatedCamera
        print("Set camera position to (\‍(rotatedPoint.x), \‍(rotatedPoint.y)) with zoom 75.0 and rotation 45°")
        // [swift_LocationWindow_setCamera_2]
 
        let tiltedCamera = NCCamera(point: rotatedPoint, zoom: 75.0, rotation: 45.0, tilt: 40.0)
        locationWindow.camera = tiltedCamera
        print("Set camera with tilt \‍(tiltedCamera.tilt)° for a perspective view")
 
        // Test different camera positions
        let testCameras = [
            NCCamera(point: NCPoint(x: 0.0, y: 0.0), zoom: 10.0, rotation: 0.0, tilt: 0.0),    // Overview camera
            NCCamera(point: NCPoint(x: 50.0, y: 75.0), zoom: 500.0, rotation: 0.0, tilt: 0.0), // Detail camera
            NCCamera(point: NCPoint(x: 100.0, y: 150.0), zoom: 100.0, rotation: 30.0, tilt: 0.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)°, Tilt \‍(camera.tilt)°")
        }
    }
 
    /**
     * 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, tilt: 30.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, tilt: 0.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, tilt: 0.0)
            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, tilt: 0.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, tilt: 0.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
        // [swift_AnimationType_enum]
        let animationTypes: [NCAnimationType] = [
            .linear,
            .cubic,
            .quint,
            .sine,
            .none,
        ]
        // [swift_AnimationType_enum]
 
        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, tilt: 0.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, tilt: 0.0)
        let detailCamera = NCCamera(point: NCPoint(x: 50.0, y: 75.0), zoom: 500.0, rotation: 0.0, tilt: 0.0)
        let angledCamera = NCCamera(point: NCPoint(x: 100.0, y: 150.0), zoom: 100.0, rotation: 30.0, tilt: 25.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)°, tilt \‍(angledCamera.tilt)°")
        // [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 {
    // [swift_CameraCallback_onMoveFinished]
    func onMoveFinished(completed: Bool) {
        if completed {
            print("Camera movement completed successfully")
        } else {
            print("Camera movement was cancelled")
        }
    }
    // [swift_CameraCallback_onMoveFinished]
}
 
/**
 * 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, tilt: 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, tilt: 0.0)
    }
 
    /** Camera tilt in degrees (see `NCCamera.tilt`). */
    static func createTiltedCamera(x: Double, y: Double, zoom: Double, rotation: Double, tilt: Double) -> NCCamera {
        let point = NCPoint(x: x, y: y)
        return NCCamera(point: point, zoom: zoom, rotation: rotation, tilt: tilt)
    }
 
    /**
     * Validate camera position
     */
    static func isValidCamera(_ camera: NCCamera) -> Bool {
        return camera.zoom > 0 &&
               camera.rotation >= 0 && camera.rotation < 360 &&
               camera.tilt >= 0
    }
 
    /**
     * 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, tilt: 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, tilt: 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, tilt: 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 currentCamera = camera
        let nextCamera = NCCamera(
            point: point,
            zoom: zoom,
            rotation: currentCamera.rotation,
            tilt: currentCamera.tilt)
        let callback = CameraCallbackImpl()
        moveTo(camera: nextCamera, 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, tilt: currentCamera.tilt)
        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, tilt: currentCamera.tilt)
        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, tilt: currentCamera.tilt)
        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()