LocationWindowCameraExample.java

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;
 
import java.util.ArrayList;

public class LocationWindowCameraExample {
    private LocationWindow locationWindow;
    private CameraListener cameraListener;
 
    public LocationWindowCameraExample() {
        demonstrateLocationWindowCameraMethods();
    }

    private void demonstrateLocationWindowCameraMethods() {
        System.out.println("=== LocationWindowCamera Methods ===");
 
        demonstrateCameraProperties();
        demonstrateGetSetCamera();
        demonstrateCameraListeners();
        demonstrateFlyToMethod();
        demonstrateMoveToMethod();
        demonstrateZoomProperties();
        demonstrateCameraScenarios();
    }

    private void demonstrateCameraProperties() {
        System.out.println("--- Camera Properties Setup ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_minZoomFactor]
        // Set minimum zoom factor
        locationWindow.setMinZoomFactor(10.0f);
        System.out.println("Set minimum zoom factor to 10.0 pixels per meter");
        // [java_LocationWindow_minZoomFactor]
 
        // [java_LocationWindow_maxZoomFactor]
        // Set maximum zoom factor
        locationWindow.setMaxZoomFactor(1000.0f);
        System.out.println("Set maximum zoom factor to 1000.0 pixels per meter");
        // [java_LocationWindow_maxZoomFactor]
    }

    private void demonstrateGetSetCamera() {
        System.out.println("--- getCamera and setCamera Methods ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_getCamera]
        // Get current camera position
        Camera currentCamera = locationWindow.getCamera();
        System.out.println("Current camera position:");
        System.out.println("  Point: (" + currentCamera.point.x + ", " + currentCamera.point.y + ")");
        System.out.println("  Zoom: " + currentCamera.zoom);
        System.out.println("  Rotation: " + currentCamera.rotation + "°");
        // [java_LocationWindow_getCamera]
 
        // [java_Camera_constructor]
        // Create camera with constructor
        Point newPoint = new Point(100.0, 200.0);
        Camera newCamera = new Camera(newPoint, 50.0, 0.0);
        System.out.println("Created camera with point (" + newPoint.x + ", " + newPoint.y + "), zoom 50.0, rotation 0°");
        // [java_Camera_constructor]
 
        // [java_Camera_access]
        // Access camera properties
        System.out.println("Camera properties:");
        System.out.println("  Point: (" + newCamera.point.x + ", " + newCamera.point.y + ")");
        System.out.println("  Zoom: " + newCamera.zoom);
        System.out.println("  Rotation: " + newCamera.rotation + "°");
        // [java_Camera_access]
 
        // [java_LocationWindow_setCamera]
        // Set camera position without animation
        locationWindow.setCamera(newCamera);
        System.out.println("Set camera position to (" + newPoint.x + ", " + newPoint.y + ") with zoom 50.0 and rotation 0°");
        // [java_LocationWindow_setCamera]
 
        // [java_LocationWindow_setCamera_2]
        // Set camera position with rotation
        Point rotatedPoint = new Point(150.0, 250.0);
        Camera rotatedCamera = new Camera(rotatedPoint, 75.0, 45.0);
        locationWindow.setCamera(rotatedCamera);
        System.out.println("Set camera position to (" + rotatedPoint.x + ", " + rotatedPoint.y + ") with zoom 75.0 and rotation 45°");
        // [java_LocationWindow_setCamera_2]
 
        // Test different camera positions
        Camera[] testCameras = {
            new Camera(new Point(0.0, 0.0), 10.0, 0.0),    // Overview camera
            new Camera(new Point(50.0, 75.0), 500.0, 0.0), // Detail camera
            new Camera(new Point(100.0, 150.0), 100.0, 30.0), // Angled camera
        };
 
        for (int i = 0; i < testCameras.length; i++) {
            Camera camera = testCameras[i];
            locationWindow.setCamera(camera);
            System.out.println("Test camera " + i + ": Point (" + camera.point.x + ", " + camera.point.y + "), Zoom " + camera.zoom + ", Rotation " + camera.rotation + "°");
        }
    }

    private void demonstrateCameraListeners() {
        System.out.println("--- Camera Listener Methods ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_addCameraListener]
        // Add camera listener
        cameraListener = new CameraListenerImpl();
        locationWindow.addCameraListener(cameraListener);
        System.out.println("Added camera listener");
        // [java_LocationWindow_addCameraListener]
 
        // [java_LocationWindow_removeCameraListener]
        // Remove camera listener
        locationWindow.removeCameraListener(cameraListener);
        cameraListener = null;
        System.out.println("Removed camera listener");
        // [java_LocationWindow_removeCameraListener]
 
        // Test multiple listeners
        CameraListener[] listeners = {
            new CameraListenerImpl(),
            new CameraListenerImpl(),
            new CameraListenerImpl(),
        };
 
        for (int i = 0; i < listeners.length; i++) {
            locationWindow.addCameraListener(listeners[i]);
            System.out.println("Added camera listener " + i);
        }
 
        for (int i = 0; i < listeners.length; i++) {
            locationWindow.removeCameraListener(listeners[i]);
            System.out.println("Removed camera listener " + i);
        }
    }

    private void demonstrateFlyToMethod() {
        System.out.println("--- flyTo Method ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_flyTo]
        // Fly to position with smooth animation
        Point targetPoint = new Point(150.0, 250.0);
        Camera targetCamera = new Camera(targetPoint, 75.0, 45.0);
        CameraCallback callback = new CameraCallbackImpl();
        locationWindow.flyTo(targetCamera, 2000, callback);
        System.out.println("Started fly to animation to point (" + targetPoint.x + ", " + targetPoint.y + ")");
        // [java_LocationWindow_flyTo]
 
        // [java_LocationWindow_flyTo_2]
        // Fly to another position with different duration
        Point targetPoint2 = new Point(300.0, 400.0);
        Camera targetCamera2 = new Camera(targetPoint2, 25.0, 180.0);
        CameraCallback callback2 = new CameraCallbackImpl();
        locationWindow.flyTo(targetCamera2, 3000, callback2);
        System.out.println("Started fly to animation to point (" + targetPoint2.x + ", " + targetPoint2.y + ") with 3 second duration");
        // [java_LocationWindow_flyTo_2]
 
        // Test fly to with different parameters
        Object[][] flyToTests = {
            {new Point(50.0, 50.0), 100.0, 0.0, 1000},
            {new Point(200.0, 300.0), 200.0, 90.0, 1500},
            {new Point(400.0, 100.0), 50.0, 270.0, 2500},
        };
 
        for (int i = 0; i < flyToTests.length; i++) {
            Point point = (Point) flyToTests[i][0];
            double zoom = (Double) flyToTests[i][1];
            double rotation = (Double) flyToTests[i][2];
            int duration = (Integer) flyToTests[i][3];
 
            Camera camera = new Camera(point, zoom, rotation);
            CameraCallback testCallback = new CameraCallbackImpl();
            locationWindow.flyTo(camera, duration, testCallback);
            System.out.println("Fly to test " + i + ": Point (" + point.x + ", " + point.y + "), Zoom " + zoom + ", Rotation " + rotation + "°, Duration " + duration + "ms");
        }
    }

    private void demonstrateMoveToMethod() {
        System.out.println("--- moveTo Method ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_moveTo]
        // Move to position with linear animation
        Point targetPoint = new Point(200.0, 300.0);
        Camera targetCamera = new Camera(targetPoint, 100.0, 90.0);
        CameraCallback callback = new CameraCallbackImpl();
        locationWindow.moveTo(targetCamera, 1500, AnimationType.LINEAR, callback);
        System.out.println("Started move to with linear animation");
        // [java_LocationWindow_moveTo]
 
        // [java_LocationWindow_moveTo_2]
        // Move to position with cubic animation
        CameraCallback callback2 = new CameraCallbackImpl();
        locationWindow.moveTo(targetCamera, 1500, AnimationType.CUBIC, callback2);
        System.out.println("Started move to with cubic animation");
        // [java_LocationWindow_moveTo_2]
 
        // [java_LocationWindow_moveTo_3]
        // Move to position with sine animation
        CameraCallback callback3 = new CameraCallbackImpl();
        locationWindow.moveTo(targetCamera, 1500, AnimationType.SINE, callback3);
        System.out.println("Started move to with sine animation");
        // [java_LocationWindow_moveTo_3]
 
        // [java_LocationWindow_moveTo_4]
        // Move to position without animation
        Point instantPoint = new Point(300.0, 400.0);
        Camera instantCamera = new Camera(instantPoint, 25.0, 180.0);
        CameraCallback instantCallback = new CameraCallbackImpl();
        locationWindow.moveTo(instantCamera, 0, AnimationType.NONE, instantCallback);
        System.out.println("Executed instant move to position (" + instantPoint.x + ", " + instantPoint.y + ")");
        // [java_LocationWindow_moveTo_4]
 
        // Test move to with different animation types
        // [java_AnimationType_enum]
        AnimationType[] animationTypes = {
            AnimationType.LINEAR,
            AnimationType.CUBIC,
            AnimationType.QUINT,
            AnimationType.SINE,
            AnimationType.NONE,
        };
        // [java_AnimationType_enum]
 
        for (int i = 0; i < animationTypes.length; i++) {
            AnimationType animationType = animationTypes[i];
            Point testPoint = new Point(100.0 + i * 50.0, 200.0 + i * 50.0);
            Camera testCamera = new Camera(testPoint, 50.0 + i * 10.0, i * 30.0);
            CameraCallback testCallback = new CameraCallbackImpl();
            locationWindow.moveTo(testCamera, 1000, animationType, testCallback);
            System.out.println("Move to test " + i + ": Animation " + animationType.name() + ", Point (" + testPoint.x + ", " + testPoint.y + ")");
        }
    }

    private void demonstrateZoomProperties() {
        System.out.println("--- Zoom Properties ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_getZoomFactor]
        // Get current zoom factor
        float currentZoom = locationWindow.getZoomFactor();
        System.out.println("Current zoom factor: " + currentZoom + " pixels per meter");
        // [java_LocationWindow_getZoomFactor]
 
        // [java_LocationWindow_setZoomFactor]
        // Set new zoom factor
        locationWindow.setZoomFactor(200.0f);
        System.out.println("Set zoom factor to 200.0 pixels per meter");
        // [java_LocationWindow_setZoomFactor]
 
        // [java_LocationWindow_getMinZoomFactor]
        // Get minimum zoom factor
        float minZoom = locationWindow.getMinZoomFactor();
        System.out.println("Minimum zoom factor: " + minZoom + " pixels per meter");
        // [java_LocationWindow_getMinZoomFactor]
 
        // [java_LocationWindow_getMaxZoomFactor]
        // Get maximum zoom factor
        float maxZoom = locationWindow.getMaxZoomFactor();
        System.out.println("Maximum zoom factor: " + maxZoom + " pixels per meter");
        // [java_LocationWindow_getMaxZoomFactor]
 
        // Test zoom factor changes
        float[] zoomLevels = {50.0f, 100.0f, 150.0f, 300.0f, 500.0f, 800.0f};
 
        for (int i = 0; i < zoomLevels.length; i++) {
            float zoom = zoomLevels[i];
            locationWindow.setZoomFactor(zoom);
            System.out.println("Set zoom factor to " + zoom + " pixels per meter");
 
            // Verify the change
            float actualZoom = locationWindow.getZoomFactor();
            System.out.println("Actual zoom factor: " + actualZoom + " pixels per meter");
        }
    }

    private void demonstrateCameraScenarios() {
        System.out.println("--- Camera Scenarios ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_camera_scenarios]
        // Create cameras for different scenarios
        Camera overviewCamera = new Camera(new Point(0.0, 0.0), 10.0, 0.0);
        Camera detailCamera = new Camera(new Point(50.0, 75.0), 500.0, 0.0);
        Camera angledCamera = new Camera(new Point(100.0, 150.0), 100.0, 30.0);
 
        System.out.println("Created cameras for different scenarios:");
        System.out.println("  Overview camera: zoom " + overviewCamera.zoom);
        System.out.println("  Detail camera: zoom " + detailCamera.zoom);
        System.out.println("  Angled camera: rotation " + angledCamera.rotation + "°");
        // [java_LocationWindow_camera_scenarios]
 
        // Test scenario transitions
        Camera[] scenarios = {overviewCamera, detailCamera, angledCamera};
        String[] scenarioNames = {"Overview", "Detail", "Angled"};
 
        for (int i = 0; i < scenarios.length; i++) {
            Camera scenario = scenarios[i];
            String name = scenarioNames[i];
 
            CameraCallback scenarioCallback = new CameraCallbackImpl();
            locationWindow.moveTo(scenario, 2000, AnimationType.CUBIC, scenarioCallback);
            System.out.println("Transitioning to " + name + " scenario");
        }
    }

    public void cleanup() {
        if (cameraListener != null && locationWindow != null) {
            locationWindow.removeCameraListener(cameraListener);
            cameraListener = null;
            System.out.println("Camera listener removed");
        }
    }
}

class CameraListenerImpl implements CameraListener {
    // [java_CameraListener_onCameraPositionChanged]
    @Override
    public void onCameraPositionChanged(CameraUpdateReason reason, boolean finished) {
        String reasonText = (reason == CameraUpdateReason.GESTURES) ? "user gestures" : "application";
        String statusText = finished ? "finished" : "in progress";
 
        System.out.println("Camera position changed: " + reasonText + ", status: " + statusText);
 
        if (finished) {
            System.out.println("Camera movement completed");
        }
    }
    // [java_CameraListener_onCameraPositionChanged]
}

class CameraCallbackImpl implements CameraCallback {
    // [java_CameraCallback_onMoveFinished]
    @Override
    public void onMoveFinished(boolean completed) {
        if (completed) {
            System.out.println("Camera movement completed successfully");
        } else {
            System.out.println("Camera movement was cancelled");
        }
    }
    // [java_CameraCallback_onMoveFinished]
}

class CameraUtils {
    public static Camera createCenteredCamera(double x, double y, double zoom) {
        return new Camera(new Point(x, y), zoom, 0.0);
    }

    public static Camera createRotatedCamera(double x, double y, double zoom, double rotation) {
        return new Camera(new Point(x, y), zoom, rotation);
    }

    public static boolean isValidCamera(Camera camera) {
        return camera.zoom > 0 &&
               camera.rotation >= 0 && camera.rotation < 360;
    }

    public static Camera createAreaCamera(double centerX, double centerY, double width, double height) {
        // Calculate zoom based on area size
        double zoom = 100.0 / Math.max(width, height);
        return new Camera(new Point(centerX, centerY), zoom, 0.0);
    }

    public static Camera createPathCamera(ArrayList<Point> points) {
        if (points.isEmpty()) {
            return new Camera(new Point(0.0, 0.0), 100.0, 0.0);
        }
 
        // Find path center
        double centerX = 0.0, centerY = 0.0;
        for (Point point : points) {
            centerX += point.x;
            centerY += point.y;
        }
        centerX /= points.size();
        centerY /= points.size();
 
        // Calculate area size
        double minX = Double.MAX_VALUE, minY = Double.MAX_VALUE;
        double maxX = Double.MIN_VALUE, maxY = Double.MIN_VALUE;
 
        for (Point point : points) {
            minX = Math.min(minX, point.x);
            minY = Math.min(minY, point.y);
            maxX = Math.max(maxX, point.x);
            maxY = Math.max(maxY, point.y);
        }
 
        double width = maxX - minX;
        double height = maxY - minY;
 
        return createAreaCamera(centerX, centerY, width, height);
    }
}

class Main {
    public static void main(String[] args) {
        // Create example instance
        LocationWindowCameraExample example = new LocationWindowCameraExample();
 
        // Assume we have LocationWindow
        // LocationWindow locationWindow = getLocationWindow();
        // example.locationWindow = locationWindow;
 
        // Demonstrate methods
        System.out.println("=== LocationWindowCamera Examples ===");
 
        // Cleanup
        example.cleanup();
 
        System.out.println("Examples ready to use!");
    }
}