geokernel 0.1.2__tar.gz → 1.0.2__tar.gz

{geokernel-0.1.2 → geokernel-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geokernel
-Version: 0.1.2
+Version: 1.0.2
 Summary: Python bindings and samples for the GeoKernel GIS SDK.
 Author-email: GeoKernel <sales@geokernel.io>
 License: Proprietary

{geokernel-0.1.2 → geokernel-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geokernel"
-version = "0.1.2"
+version = "1.0.2"
 description = "Python bindings and samples for the GeoKernel GIS SDK."
 readme = "README.md"
 requires-python = ">=3.10"

geokernel-1.0.2/src/geokernel/__init__.py

@@ -0,0 +1,45 @@
+from .crs import CrsDatabase
+from .geometry import Geometry
+from .layer import Layer
+from .types import (
+    ClassificationMethod,
+    ColorRampMode,
+    CoordinateSystemPreset,
+    Extent,
+    MeasureMode,
+    OverlayAnchor,
+    Point,
+    RenderBackendPreference,
+    RouteSummary,
+    RoutingCostMetric,
+    ScreenRectangle,
+    ShapeType,
+    SpatialIndexType,
+    SymbolStyleTarget,
+    TopologyFixOperation,
+)
+from .viewer import GeoKernelError, Viewer, ViewerTool
+
+__all__ = [
+    "ClassificationMethod",
+    "ColorRampMode",
+    "CoordinateSystemPreset",
+    "CrsDatabase",
+    "Extent",
+    "Geometry",
+    "GeoKernelError",
+    "Layer",
+    "MeasureMode",
+    "OverlayAnchor",
+    "Point",
+    "RenderBackendPreference",
+    "RouteSummary",
+    "RoutingCostMetric",
+    "ScreenRectangle",
+    "ShapeType",
+    "SpatialIndexType",
+    "SymbolStyleTarget",
+    "TopologyFixOperation",
+    "Viewer",
+    "ViewerTool",
+]

{geokernel-0.1.2 → geokernel-1.0.2}/src/geokernel/bin/license-profile.json

@@ -15,5 +15,5 @@
     "excludedPlugins":  [
 
                         ],
-    "generatedAtUtc":  "2026-07-05T18:30:19Z"
+    "generatedAtUtc":  "2026-07-10T01:16:00Z"
 }

geokernel-1.0.2/src/geokernel/controls.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from .types import MeasureMode, OverlayAnchor
+
+
+class ControlsMixin:
+    def set_scale_bar_visible(self, visible: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetScaleBarVisible(self._handle, bool(visible))
+
+    def get_scale_bar_visible(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetScaleBarVisible(self._handle))
+
+    def set_scale_bar_anchor(self, anchor: OverlayAnchor | int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetScaleBarAnchor(self._handle, int(anchor))
+
+    def set_scale_bar_colors(self, background_argb: int, line_argb: int, text_argb: int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetScaleBarColors(
+            self._handle,
+            int(background_argb),
+            int(line_argb),
+            int(text_argb),
+        )
+
+    def set_mini_map_visible(self, visible: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMiniMapVisible(self._handle, bool(visible))
+
+    def get_mini_map_visible(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetMiniMapVisible(self._handle))
+
+    def set_mini_map_anchor(self, anchor: OverlayAnchor | int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMiniMapAnchor(self._handle, int(anchor))
+
+    def set_mini_map_background_color(self, background_argb: int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMiniMapBackgroundColor(self._handle, int(background_argb))
+
+    def set_measure_tool_active(self, active: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMeasureToolActive(self._handle, bool(active))
+
+    def get_measure_tool_active(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetMeasureToolActive(self._handle))
+
+    def set_measure_mode(self, mode: MeasureMode | int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMeasureMode(self._handle, int(mode))
+
+    def get_measure_mode(self) -> MeasureMode:
+        self._require_handle()
+        return MeasureMode(int(self._dll.viewer.GeoKernelViewer_GetMeasureMode(self._handle)))
+
+    def start_measure_distance(self) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_StartMeasureDistance(self._handle)
+
+    def start_measure_area(self) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_StartMeasureArea(self._handle)
+
+    def finish_measure(self) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_FinishMeasure(self._handle)
+
+    def clear_measure(self) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_ClearMeasure(self._handle)
+
+    def get_measure_total_distance(self) -> float:
+        self._require_handle()
+        return float(self._dll.viewer.GeoKernelViewer_GetMeasureTotalDistance(self._handle))
+
+    def get_measure_area(self) -> float:
+        self._require_handle()
+        return float(self._dll.viewer.GeoKernelViewer_GetMeasureArea(self._handle))
+
+    def get_measure_result_text(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetMeasureResultText)
+
+    def set_measure_colors(self, line_argb: int, fill_argb: int, text_argb: int, label_background_argb: int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMeasureColors(
+            self._handle,
+            int(line_argb),
+            int(fill_argb),
+            int(text_argb),
+            int(label_background_argb),
+        )

geokernel-1.0.2/src/geokernel/crs.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import ctypes
+import json
+from pathlib import Path
+from typing import Any
+
+from .dll import GeoKernelDll
+from .types import CoordinateSystemPreset
+
+
+def _read_global_json(function: Any, *args: object) -> dict[str, Any]:
+    required = int(function(*args, None, 0))
+    if required <= 0:
+        return {}
+    buffer = ctypes.create_unicode_buffer(required + 1)
+    function(*args, buffer, len(buffer))
+    return json.loads(buffer.value) if buffer.value else {}
+
+
+class CrsDatabase:
+    def __init__(self, database_path: str | Path, bin_dir: str | Path | None = None) -> None:
+        self.database_path = str(database_path)
+        self._dll = GeoKernelDll(bin_dir)
+
+    def find_by_srid(self, srid: int) -> dict[str, Any]:
+        return _read_global_json(
+            self._dll.viewer.GeoKernelViewer_CrsDatabaseFindBySridJson,
+            self.database_path,
+            int(srid),
+        )
+
+    def find_by_authority(self, authority_name: str, authority_srid: int) -> dict[str, Any]:
+        return _read_global_json(
+            self._dll.viewer.GeoKernelViewer_CrsDatabaseFindByAuthorityJson,
+            self.database_path,
+            authority_name,
+            int(authority_srid),
+        )
+
+
+class CrsMixin:
+    def set_coordinate_system_preset(self, preset: CoordinateSystemPreset | int | str) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_SetCoordinateSystemPreset(self._handle, self._preset_name(preset)))
+
+    def set_layer_coordinate_system_preset(self, index: int, preset: CoordinateSystemPreset | int | str) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_SetLayerCoordinateSystemPreset(
+            self._handle,
+            int(index),
+            self._preset_name(preset),
+        ))
+
+    def _preset_name(self, preset: CoordinateSystemPreset | int | str) -> str:
+        if isinstance(preset, str):
+            return preset
+        names = {
+            CoordinateSystemPreset.WGS84: "WGS84",
+            CoordinateSystemPreset.WEB_MERCATOR: "WebMercator",
+            CoordinateSystemPreset.WORLD_MERCATOR: "WorldMercator",
+            CoordinateSystemPreset.MILLER: "Miller",
+            CoordinateSystemPreset.MOLLWEIDE: "Mollweide",
+            CoordinateSystemPreset.SINUSOIDAL: "Sinusoidal",
+            CoordinateSystemPreset.ECKERT_IV: "EckertIV",
+            CoordinateSystemPreset.ECKERT_VI: "EckertVI",
+        }
+        return names[CoordinateSystemPreset(int(preset))]

geokernel-1.0.2/src/geokernel/diagnostics.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .types import RenderBackendPreference
+
+
+class DiagnosticsMixin:
+    def set_verbose_mode(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetVerboseMode(self._handle, bool(enabled))
+
+    def get_verbose_mode(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetVerboseMode(self._handle))
+
+    def get_logging_mode_name(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetLoggingModeName)
+
+    def set_logging_mode_name(self, value: str) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetLoggingModeName(self._handle, value)
+
+    def get_render_metrics_visible(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetRenderMetricsVisible(self._handle))
+
+    def set_render_metrics_visible(self, visible: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderMetricsVisible(self._handle, bool(visible))
+
+    def get_render_metrics_log_path(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetRenderMetricsLogPath)
+
+    def set_render_metrics_log_path(self, path: str | Path) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderMetricsLogPath(self._handle, str(path))
+
+    def set_render_debug_window(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderDebugWindow(self._handle, bool(enabled))
+
+    def get_render_debug_window(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetRenderDebugWindow(self._handle))
+
+    def set_render_debug_file(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderDebugFile(self._handle, bool(enabled))
+
+    def get_render_debug_file(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetRenderDebugFile(self._handle))
+
+    def get_render_step_log(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetRenderStepLog(self._handle))
+
+    def set_render_step_log(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderStepLog(self._handle, bool(enabled))
+
+    def get_render_step_log_path(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetRenderStepLogPath)
+
+    def set_render_step_log_path(self, path: str | Path) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderStepLogPath(self._handle, str(path))
+
+    def get_fps(self) -> float:
+        self._require_handle()
+        return float(self._dll.viewer.GeoKernelViewer_GetFPS(self._handle))
+
+    def get_map_scale(self) -> float:
+        self._require_handle()
+        return float(self._dll.viewer.GeoKernelViewer_GetMapScale(self._handle))
+
+    def get_show_fps(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetShowFPS(self._handle))
+
+    def set_show_fps(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetShowFPS(self._handle, bool(enabled))
+
+    def get_show_extra_info(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetShowExtraInfo(self._handle))
+
+    def set_show_extra_info(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetShowExtraInfo(self._handle, bool(enabled))
+
+    def get_extra_info_text(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetExtraInfoText)
+
+    def set_extra_info_text(self, value: str) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetExtraInfoText(self._handle, value)
+
+    def get_use_hardware_acceleration(self) -> bool:
+        self._require_handle()
+        return bool(self._dll.viewer.GeoKernelViewer_GetUseHardwareAcceleration(self._handle))
+
+    def set_use_hardware_acceleration(self, enabled: bool) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetUseHardwareAcceleration(self._handle, bool(enabled))
+
+    def get_render_backend_preference(self) -> RenderBackendPreference:
+        self._require_handle()
+        return RenderBackendPreference(int(self._dll.viewer.GeoKernelViewer_GetRenderBackendPreference(self._handle)))
+
+    def set_render_backend_preference(self, value: RenderBackendPreference | int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderBackendPreference(self._handle, int(value))
+
+    def get_render_backend_preference_name(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetRenderBackendPreferenceName)
+
+    def set_render_backend_preference_name(self, value: str) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetRenderBackendPreferenceName(self._handle, value)
+
+    def get_current_render_backend_name(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetCurrentRenderBackendName)
+
+    def get_render_backend_diagnostics(self) -> str:
+        return self._read_wide_text(self._dll.viewer.GeoKernelViewer_GetRenderBackendDiagnostics)
+
+    def get_map_background_color(self) -> int:
+        self._require_handle()
+        return int(self._dll.viewer.GeoKernelViewer_GetMapBackgroundColor(self._handle))
+
+    def set_map_background_color(self, argb: int) -> None:
+        self._require_handle()
+        self._dll.viewer.GeoKernelViewer_SetMapBackgroundColor(self._handle, int(argb))

geokernel-1.0.2/src/geokernel/dll.py

@@ -0,0 +1,94 @@
+import ctypes
+import os
+import sys
+from pathlib import Path
+
+from .native import configure_viewer_signatures
+
+
+WINDOWS_DLL_LOAD_FLAGS = 0x00000100 | 0x00001000
+
+DEFAULT_BIN_CANDIDATES = [
+    Path(os.environ["GEOKERNEL_BIN"]) if os.environ.get("GEOKERNEL_BIN") else None,
+    Path(__file__).resolve().parent / "bin",
+    Path(r"D:\projects\GeoKernel\outputs\packages\Evaluation"),
+]
+
+
+class GeoKernelDllError(RuntimeError):
+    pass
+
+
+def load_library(path: Path) -> ctypes.CDLL:
+    if sys.platform == "win32":
+        return ctypes.CDLL(str(path), winmode=WINDOWS_DLL_LOAD_FLAGS)
+    return ctypes.CDLL(str(path))
+
+
+def find_bin_dir() -> Path:
+    for candidate in DEFAULT_BIN_CANDIDATES:
+        if candidate is None:
+            continue
+        dll_path = candidate / "GeoKernel.Viewer.dll"
+        if dll_path.exists():
+            return candidate
+    searched = ", ".join(str(path) for path in DEFAULT_BIN_CANDIDATES if path is not None)
+    raise GeoKernelDllError(f"Could not find GeoKernel.Viewer.dll. Searched: {searched}")
+
+
+class GeoKernelDll:
+    def __init__(self, bin_dir: str | Path | None = None) -> None:
+        self.bin_dir = Path(bin_dir) if bin_dir is not None else find_bin_dir()
+        if not (self.bin_dir / "GeoKernel.Viewer.dll").exists():
+            raise GeoKernelDllError(f"GeoKernel.Viewer.dll not found in {self.bin_dir}")
+
+        configure_runtime_environment(self.bin_dir)
+        configure_qt_plugin_path(self.bin_dir)
+        self._dll_directory_cookie = os.add_dll_directory(str(self.bin_dir))
+        self.viewer = load_library(self.bin_dir / "GeoKernel.Viewer.dll")
+        self._configure_signatures()
+
+    def _configure_signatures(self) -> None:
+        configure_viewer_signatures(self.viewer)
+
+
+def configure_qt_plugin_path(bin_dir: Path) -> None:
+    if os.environ.get("QT_PLUGIN_PATH") and os.environ.get("QT_QPA_PLATFORM_PLUGIN_PATH"):
+        return
+
+    candidates = [
+        bin_dir / "plugins",
+        bin_dir,
+        Path(r"C:\Qt\6.11.0\msvc2022_64\plugins"),
+    ]
+
+    for candidate in candidates:
+        platforms_dir = candidate / "platforms"
+        if platforms_dir.exists() and any(platforms_dir.glob("qwindows*.dll")):
+            os.environ.setdefault("QT_PLUGIN_PATH", str(candidate))
+            os.environ.setdefault("QT_QPA_PLATFORM_PLUGIN_PATH", str(platforms_dir))
+            return
+
+
+def configure_runtime_environment(bin_dir: Path) -> None:
+    icon_dir = Path(__file__).resolve().parent / "assets" / "images"
+    if icon_dir.exists():
+        os.environ.setdefault("GEOKERNEL_ICON_DIR", str(icon_dir))
+
+    current_path = os.environ.get("PATH", "")
+    bin_text = str(bin_dir)
+    path_parts = [part for part in current_path.split(os.pathsep) if part]
+    if bin_text.casefold() not in {part.casefold() for part in path_parts}:
+        os.environ["PATH"] = bin_text + os.pathsep + current_path
+
+    gdal_data = bin_dir / "gdal-data"
+    if gdal_data.exists():
+        os.environ.setdefault("GDAL_DATA", str(gdal_data))
+
+    proj_data = bin_dir / "proj-data"
+    if proj_data.exists():
+        os.environ.setdefault("PROJ_LIB", str(proj_data))
+
+    gdal_plugins = bin_dir / "gdalplugins"
+    if gdal_plugins.exists():
+        os.environ.setdefault("GDAL_DRIVER_PATH", str(gdal_plugins))