LocationWindowCameraExample.kt

Go to the documentation of this file.

package com.navigine.examples
 
import com.navigine.idl.java.LocationWindow
import com.navigine.idl.java.Camera
import com.navigine.idl.java.CameraListener
import com.navigine.idl.java.CameraCallback
import com.navigine.idl.java.AnimationType
import com.navigine.idl.java.CameraUpdateReason
import com.navigine.idl.java.Point
 
/**
 * LocationWindowCamera usage example for Kotlin
 * Demonstrates specific methods: getCamera, setCamera, addCameraListener, removeCameraListener,
 * flyTo, moveTo, zoomFactor, minZoomFactor, maxZoomFactor
 */
class LocationWindowCameraExample {
    private var locationWindow: LocationWindow? = null
    private var cameraListener: CameraListener? = null
 
    constructor() {
        demonstrateLocationWindowCameraMethods()
    }
 
    /**
     * Demonstrate LocationWindowCamera methods
     */
    private fun demonstrateLocationWindowCameraMethods() {
        println("=== LocationWindowCamera Methods ===")
 
        demonstrateCameraProperties()
        demonstrateGetSetCamera()
        demonstrateCameraListeners()
        demonstrateFlyToMethod()
        demonstrateMoveToMethod()
        demonstrateZoomProperties()
        demonstrateCameraScenarios()
    }
 
    /**
     * Demonstrate camera properties setup
     */
    private fun demonstrateCameraProperties() {
        println("--- Camera Properties Setup ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_minZoomFactor]
        // Set minimum zoom factor
        locationWindow!!.minZoomFactor = 10.0f
        println("Set minimum zoom factor to 10.0 pixels per meter")
        // [kotlin_LocationWindow_minZoomFactor]
 
        // [kotlin_LocationWindow_maxZoomFactor]
        // Set maximum zoom factor
        locationWindow!!.maxZoomFactor = 1000.0f
        println("Set maximum zoom factor to 1000.0 pixels per meter")
        // [kotlin_LocationWindow_maxZoomFactor]
    }
 
    /**
     * Demonstrate getCamera and setCamera methods
     */
    private fun demonstrateGetSetCamera() {
        println("--- getCamera and setCamera Methods ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_getCamera]
        // Get current camera position
        val currentCamera = locationWindow!!.camera
        println("Current camera position:")
        println("  Point: (${currentCamera.point.x}, ${currentCamera.point.y})")
        println("  Zoom: ${currentCamera.zoom}")
        println("  Rotation: ${currentCamera.rotation}°")
        println("  Tilt: ${currentCamera.tilt}° (0° = straight downward / map from above)")
        // [kotlin_LocationWindow_getCamera]
 
        // [kotlin_Camera_constructor]
        // Create camera with constructor
        val newPoint = Point(100.0, 200.0)
        val newCamera = Camera(newPoint, 50.0, 0.0, 0.0)
        println("Created camera with point (${newPoint.x}, ${newPoint.y}), zoom 50.0, rotation 0°, tilt 0°")
        // [kotlin_Camera_constructor]
 
        // [kotlin_Camera_access]
        // Access camera properties
        println("Camera properties:")
        println("  Point: (${newCamera.point.x}, ${newCamera.point.y})")
        println("  Zoom: ${newCamera.zoom}")
        println("  Rotation: ${newCamera.rotation}°")
        println("  Tilt: ${newCamera.tilt}°")
        // [kotlin_Camera_access]
 
        // [kotlin_LocationWindow_setCamera]
        // Set camera position without animation
        locationWindow!!.camera = newCamera
        println("Set camera position to (${newPoint.x}, ${newPoint.y}) with zoom 50.0, rotation 0°, tilt 0°")
        // [kotlin_LocationWindow_setCamera]
 
        // [kotlin_LocationWindow_setCamera_2]
        // Set camera position with rotation
        val rotatedPoint = Point(150.0, 250.0)
        val rotatedCamera = Camera(rotatedPoint, 75.0, 45.0, 0.0)
        locationWindow!!.camera = rotatedCamera
        println("Set camera position to (${rotatedPoint.x}, ${rotatedPoint.y}) with zoom 75.0 and rotation 45°")
        // [kotlin_LocationWindow_setCamera_2]
 
        val tiltedCamera = Camera(rotatedPoint, 75.0, 45.0, 40.0)
        locationWindow!!.camera = tiltedCamera
        println("Set camera with tilt ${tiltedCamera.tilt}° for a perspective view")
 
        // Test different camera positions
        val testCameras = listOf(
            Camera(Point(0.0, 0.0), 10.0, 0.0, 0.0),    // Overview camera
            Camera(Point(50.0, 75.0), 500.0, 0.0, 0.0), // Detail camera
            Camera(Point(100.0, 150.0), 100.0, 30.0, 0.0), // Angled camera
        )
 
        testCameras.forEachIndexed { i, camera ->
            locationWindow!!.camera = camera
            println("Test camera $i: Point (${camera.point.x}, ${camera.point.y}), Zoom ${camera.zoom}, Rotation ${camera.rotation}°, Tilt ${camera.tilt}°")
        }
    }
 
    /**
     * Demonstrate camera listener methods
     */
    private fun demonstrateCameraListeners() {
        println("--- Camera Listener Methods ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_addCameraListener]
        // Add camera listener
        cameraListener = CameraListenerImpl()
        locationWindow!!.addCameraListener(cameraListener!!)
        println("Added camera listener")
        // [kotlin_LocationWindow_addCameraListener]
 
        // [kotlin_LocationWindow_removeCameraListener]
        // Remove camera listener
        locationWindow!!.removeCameraListener(cameraListener!!)
        cameraListener = null
        println("Removed camera listener")
        // [kotlin_LocationWindow_removeCameraListener]
 
        // Test multiple listeners
        val listeners = listOf(
            CameraListenerImpl(),
            CameraListenerImpl(),
            CameraListenerImpl(),
        )
 
        listeners.forEachIndexed { i, listener ->
            locationWindow!!.addCameraListener(listener)
            println("Added camera listener $i")
        }
 
        listeners.forEachIndexed { i, listener ->
            locationWindow!!.removeCameraListener(listener)
            println("Removed camera listener $i")
        }
    }
 
    /**
     * Demonstrate flyTo method
     */
    private fun demonstrateFlyToMethod() {
        println("--- flyTo Method ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_flyTo]
        // Fly to position with smooth animation
        val targetPoint = Point(150.0, 250.0)
        val targetCamera = Camera(targetPoint, 75.0, 45.0, 30.0)
        val callback = CameraCallbackImpl()
        locationWindow!!.flyTo(targetCamera, 2000, callback)
        println("Started fly to animation to point (${targetPoint.x}, ${targetPoint.y})")
        // [kotlin_LocationWindow_flyTo]
 
        // [kotlin_LocationWindow_flyTo_2]
        // Fly to another position with different duration
        val targetPoint2 = Point(300.0, 400.0)
        val targetCamera2 = Camera(targetPoint2, 25.0, 180.0, 0.0)
        val callback2 = CameraCallbackImpl()
        locationWindow!!.flyTo(targetCamera2, 3000, callback2)
        println("Started fly to animation to point (${targetPoint2.x}, ${targetPoint2.y}) with 3 second duration")
        // [kotlin_LocationWindow_flyTo_2]
 
        // Test fly to with different parameters
        val flyToTests = listOf(
            mapOf("point" to Point(50.0, 50.0), "zoom" to 100.0, "rotation" to 0.0, "duration" to 1000),
            mapOf("point" to Point(200.0, 300.0), "zoom" to 200.0, "rotation" to 90.0, "duration" to 1500),
            mapOf("point" to Point(400.0, 100.0), "zoom" to 50.0, "rotation" to 270.0, "duration" to 2500),
        )
 
        flyToTests.forEachIndexed { i, test ->
            val point = test["point"] as Point
            val zoom = test["zoom"] as Double
            val rotation = test["rotation"] as Double
            val duration = test["duration"] as Int
 
            val camera = Camera(point, zoom, rotation, 0.0)
            val testCallback = CameraCallbackImpl()
            locationWindow!!.flyTo(camera, duration, testCallback)
            println("Fly to test $i: Point (${point.x}, ${point.y}), Zoom $zoom, Rotation ${rotation}°, Duration ${duration}ms")
        }
    }
 
    /**
     * Demonstrate moveTo method
     */
    private fun demonstrateMoveToMethod() {
        println("--- moveTo Method ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_moveTo]
        // Move to position with linear animation
        val targetPoint = Point(200.0, 300.0)
        val targetCamera = Camera(targetPoint, 100.0, 90.0, 0.0)
        val callback = CameraCallbackImpl()
        locationWindow!!.moveTo(targetCamera, 1500, AnimationType.LINEAR, callback)
        println("Started move to with linear animation")
        // [kotlin_LocationWindow_moveTo]
 
        // [kotlin_LocationWindow_moveTo_2]
        // Move to position with cubic animation
        val callback2 = CameraCallbackImpl()
        locationWindow!!.moveTo(targetCamera, 1500, AnimationType.CUBIC, callback2)
        println("Started move to with cubic animation")
        // [kotlin_LocationWindow_moveTo_2]
 
        // [kotlin_LocationWindow_moveTo_3]
        // Move to position with sine animation
        val callback3 = CameraCallbackImpl()
        locationWindow!!.moveTo(targetCamera, 1500, AnimationType.SINE, callback3)
        println("Started move to with sine animation")
        // [kotlin_LocationWindow_moveTo_3]
 
        // [kotlin_LocationWindow_moveTo_4]
        // Move to position without animation
        val instantPoint = Point(300.0, 400.0)
        val instantCamera = Camera(instantPoint, 25.0, 180.0, 0.0)
        val instantCallback = CameraCallbackImpl()
        locationWindow!!.moveTo(instantCamera, 0, AnimationType.NONE, instantCallback)
        println("Executed instant move to position (${instantPoint.x}, ${instantPoint.y})")
        // [kotlin_LocationWindow_moveTo_4]
 
        // Test move to with different animation types
        // [kotlin_AnimationType_enum]
        val animationTypes = listOf(
            AnimationType.LINEAR,
            AnimationType.CUBIC,
            AnimationType.QUINT,
            AnimationType.SINE,
            AnimationType.NONE,
        )
        // [kotlin_AnimationType_enum]
 
        animationTypes.forEachIndexed { i, animationType ->
            val testPoint = Point(100.0 + i * 50.0, 200.0 + i * 50.0)
            val testCamera = Camera(testPoint, 50.0 + i * 10.0, i * 30.0, 0.0)
            val testCallback = CameraCallbackImpl()
            locationWindow!!.moveTo(testCamera, 1000, animationType, testCallback)
            println("Move to test $i: Animation ${animationType.name}, Point (${testPoint.x}, ${testPoint.y})")
        }
    }
 
    /**
     * Demonstrate zoom properties
     */
    private fun demonstrateZoomProperties() {
        println("--- Zoom Properties ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_getZoomFactor]
        // Get current zoom factor
        val currentZoom = locationWindow!!.zoomFactor
        println("Current zoom factor: $currentZoom pixels per meter")
        // [kotlin_LocationWindow_getZoomFactor]
 
        // [kotlin_LocationWindow_setZoomFactor]
        // Set new zoom factor
        locationWindow!!.zoomFactor = 200.0f
        println("Set zoom factor to 200.0 pixels per meter")
        // [kotlin_LocationWindow_setZoomFactor]
 
        // [kotlin_LocationWindow_getMinZoomFactor]
        // Get minimum zoom factor
        val minZoom = locationWindow!!.minZoomFactor
        println("Minimum zoom factor: $minZoom pixels per meter")
        // [kotlin_LocationWindow_getMinZoomFactor]
 
        // [kotlin_LocationWindow_getMaxZoomFactor]
        // Get maximum zoom factor
        val maxZoom = locationWindow!!.maxZoomFactor
        println("Maximum zoom factor: $maxZoom pixels per meter")
        // [kotlin_LocationWindow_getMaxZoomFactor]
 
        // Test zoom factor changes
        val zoomLevels = listOf(50.0f, 100.0f, 150.0f, 300.0f, 500.0f, 800.0f)
 
        zoomLevels.forEach { zoom ->
            locationWindow!!.zoomFactor = zoom
            println("Set zoom factor to $zoom pixels per meter")
 
            // Verify the change
            val actualZoom = locationWindow!!.zoomFactor
            println("Actual zoom factor: $actualZoom pixels per meter")
        }
    }
 
    /**
     * Demonstrate camera scenarios
     */
    private fun demonstrateCameraScenarios() {
        println("--- Camera Scenarios ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_camera_scenarios]
        // Create cameras for different scenarios
        val overviewCamera = Camera(Point(0.0, 0.0), 10.0, 0.0, 0.0)
        val detailCamera = Camera(Point(50.0, 75.0), 500.0, 0.0, 0.0)
        val angledCamera = Camera(Point(100.0, 150.0), 100.0, 30.0, 25.0)
 
        println("Created cameras for different scenarios:")
        println("  Overview camera: zoom ${overviewCamera.zoom}")
        println("  Detail camera: zoom ${detailCamera.zoom}")
        println("  Angled camera: rotation ${angledCamera.rotation}°, tilt ${angledCamera.tilt}°")
        // [kotlin_LocationWindow_camera_scenarios]
 
        // Test scenario transitions
        val scenarios = listOf(overviewCamera, detailCamera, angledCamera)
        val scenarioNames = listOf("Overview", "Detail", "Angled")
 
        scenarios.forEachIndexed { i, scenario ->
            val name = scenarioNames[i]
            val scenarioCallback = CameraCallbackImpl()
            locationWindow!!.moveTo(scenario, 2000, AnimationType.CUBIC, scenarioCallback)
            println("Transitioning to $name scenario")
        }
    }
 
    /**
     * Cleanup resources
     */
    fun cleanup() {
        cameraListener?.let { listener ->
            locationWindow?.removeCameraListener(listener)
            cameraListener = null
            println("Camera listener removed")
        }
    }
}
 
/**
 * Camera listener implementation
 */
class CameraListenerImpl : CameraListener {
    // [kotlin_CameraListener_onCameraPositionChanged]
    override fun onCameraPositionChanged(reason: CameraUpdateReason, finished: Boolean) {
        val reasonText = if (reason == CameraUpdateReason.GESTURES) "user gestures" else "application"
        val statusText = if (finished) "finished" else "in progress"
 
        println("Camera position changed: $reasonText, status: $statusText")
 
        if (finished) {
            println("Camera movement completed")
        }
    }
    // [kotlin_CameraListener_onCameraPositionChanged]
}
 
/**
 * Camera callback implementation
 */
class CameraCallbackImpl : CameraCallback {
    // [kotlin_CameraCallback_onMoveFinished]
    override fun onMoveFinished(completed: Boolean) {
        if (completed) {
            println("Camera movement completed successfully")
        } else {
            println("Camera movement was cancelled")
        }
    }
    // [kotlin_CameraCallback_onMoveFinished]
}
 
/**
 * Camera utilities
 */
object CameraUtils {
    /**
     * Create camera for centered point with given zoom
     */
    fun createCenteredCamera(x: Double, y: Double, zoom: Double): Camera {
        return Camera(Point(x, y), zoom, 0.0, 0.0)
    }
 
    /**
     * Create camera with rotation
     */
    fun createRotatedCamera(x: Double, y: Double, zoom: Double, rotation: Double): Camera {
        return Camera(Point(x, y), zoom, rotation, 0.0)
    }
 
    /**
     * Create camera with tilt in degrees (see [Camera.tilt]).
     */
    fun createTiltedCamera(x: Double, y: Double, zoom: Double, rotation: Double, tilt: Double): Camera {
        return Camera(Point(x, y), zoom, rotation, tilt)
    }
 
    /**
     * Validate camera position
     */
    fun isValidCamera(camera: Camera): Boolean {
        return camera.zoom > 0 &&
               camera.rotation >= 0 && camera.rotation < 360 &&
               camera.tilt >= 0
    }
 
    /**
     * Create camera for showing area
     */
    fun createAreaCamera(centerX: Double, centerY: Double, width: Double, height: Double): Camera {
        // Calculate zoom based on area size
        val zoom = 100.0 / maxOf(width, height)
        return Camera(Point(centerX, centerY), zoom, 0.0, 0.0)
    }
 
    /**
     * Create camera for showing path
     */
    fun createPathCamera(points: List<Point>): Camera {
        if (points.isEmpty()) {
            return Camera(Point(0.0, 0.0), 100.0, 0.0, 0.0)
        }
 
        // Find path center
        val centerX = points.map { it.x }.average()
        val centerY = points.map { it.y }.average()
 
        // Calculate area size
        val minX = points.minOf { it.x }
        val minY = points.minOf { it.y }
        val maxX = points.maxOf { it.x }
        val maxY = points.maxOf { it.y }
 
        val width = maxX - minX
        val height = maxY - minY
 
        return createAreaCamera(centerX, centerY, width, height)
    }
 
    /**
     * Create camera for showing multiple points
     */
    fun createMultiPointCamera(points: List<Point>, padding: Double = 10.0): Camera {
        if (points.isEmpty()) {
            return Camera(Point(0.0, 0.0), 100.0, 0.0, 0.0)
        }
 
        // Find center
        val centerX = points.map { it.x }.average()
        val centerY = points.map { it.y }.average()
 
        // Calculate area size with padding
        val minX = points.minOf { it.x } - padding
        val minY = points.minOf { it.y } - padding
        val maxX = points.maxOf { it.x } + padding
        val maxY = points.maxOf { it.y } + padding
 
        val width = maxX - minX
        val height = maxY - minY
 
        return createAreaCamera(centerX, centerY, width, height)
    }
}
 
/**
 * Extensions for convenient camera operations
 */
fun LocationWindow.zoomTo(point: Point, zoom: Double, duration: Int = 1000) {
    val c = camera
    val nextCamera = Camera(point, zoom, c.rotation, c.tilt)
    val callback = CameraCallbackImpl()
    moveTo(nextCamera, duration, AnimationType.CUBIC, callback)
}
 
fun LocationWindow.panTo(point: Point, duration: Int = 1000) {
    val currentCamera = camera
    val newCamera = Camera(point, currentCamera.zoom, currentCamera.rotation, currentCamera.tilt)
    val callback = CameraCallbackImpl()
    moveTo(newCamera, duration, AnimationType.LINEAR, callback)
}
 
fun LocationWindow.rotateTo(rotation: Double, duration: Int = 1000) {
    val currentCamera = camera
    val newCamera = Camera(currentCamera.point, currentCamera.zoom, rotation, currentCamera.tilt)
    val callback = CameraCallbackImpl()
    moveTo(newCamera, duration, AnimationType.SINE, callback)
}
 
/**
 * Usage example
 */
fun main() {
    // Create example instance
    val example = LocationWindowCameraExample()
 
    // Assume we have LocationWindow
    // val locationWindow: LocationWindow = getLocationWindow()
    // example.locationWindow = locationWindow
 
    // Demonstrate methods
    println("=== LocationWindowCamera Examples ===")
 
    // Cleanup
    example.cleanup()
 
    println("Examples ready to use!")
}