OpenGeodeWeb-Back 6.16.1__tar.gz → 6.17.0rc1__tar.gz

{opengeodeweb_back-6.16.1 → opengeodeweb_back-6.17.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.16.1
+Version: 6.17.0rc1
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.16.1 → opengeodeweb_back-6.17.0rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.16.1"
+version = "6.17.0-rc.1"
 dynamic = ["dependencies"]
 authors = [{ name = "Geode-solutions", email = "team-web@geode-solutions.com" }]
 description = "OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"
@@ -33,4 +33,5 @@ where = ["src"]
 "opengeodeweb_back.routes.schemas" = ["*.json"]
 "opengeodeweb_back.routes.models.schemas" = ["*.json"]
 "opengeodeweb_back.routes.create.schemas" = ["*.json"]
+"opengeodeweb_back.routes.crs.schemas" = ["*.json"]
 "opengeodeweb_back" = ["py.typed"]

{opengeodeweb_back-6.16.1 → opengeodeweb_back-6.17.0rc1}/src/OpenGeodeWeb_Back.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.16.1
+Version: 6.17.0rc1
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.16.1 → opengeodeweb_back-6.17.0rc1}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -16,7 +16,12 @@ src/opengeodeweb_back/py.typed
 src/opengeodeweb_back/test_utils.py
 src/opengeodeweb_back/typed_route.py
 src/opengeodeweb_back/utils_functions.py
+src/opengeodeweb_back/crs/__init__.py
+src/opengeodeweb_back/crs/crs_alignment.py
+src/opengeodeweb_back/crs/crs_assignment.py
+src/opengeodeweb_back/crs/crs_functions.py
 src/opengeodeweb_back/geode_objects/__init__.py
+src/opengeodeweb_back/geode_objects/crs_coordinates.py
 src/opengeodeweb_back/geode_objects/geode_brep.py
 src/opengeodeweb_back/geode_objects/geode_cross_section.py
 src/opengeodeweb_back/geode_objects/geode_edged_curve2d.py
@@ -62,6 +67,19 @@ src/opengeodeweb_back/routes/create/schemas/point_set.json
 src/opengeodeweb_back/routes/create/schemas/point_set.py
 src/opengeodeweb_back/routes/create/schemas/polygonal_surface.json
 src/opengeodeweb_back/routes/create/schemas/polygonal_surface.py
+src/opengeodeweb_back/routes/crs/__init__.py
+src/opengeodeweb_back/routes/crs/blueprint_crs.py
+src/opengeodeweb_back/routes/crs/schemas/__init__.py
+src/opengeodeweb_back/routes/crs/schemas/active.json
+src/opengeodeweb_back/routes/crs/schemas/active.py
+src/opengeodeweb_back/routes/crs/schemas/align.json
+src/opengeodeweb_back/routes/crs/schemas/align.py
+src/opengeodeweb_back/routes/crs/schemas/assign_geographic.json
+src/opengeodeweb_back/routes/crs/schemas/assign_geographic.py
+src/opengeodeweb_back/routes/crs/schemas/convert_geographic.json
+src/opengeodeweb_back/routes/crs/schemas/convert_geographic.py
+src/opengeodeweb_back/routes/crs/schemas/geographic_list.json
+src/opengeodeweb_back/routes/crs/schemas/geographic_list.py
 src/opengeodeweb_back/routes/schemas/__init__.py
 src/opengeodeweb_back/routes/schemas/allowed_files.json
 src/opengeodeweb_back/routes/schemas/allowed_files.py
@@ -85,8 +103,6 @@ src/opengeodeweb_back/routes/schemas/geode_object_inheritance.json
 src/opengeodeweb_back/routes/schemas/geode_object_inheritance.py
 src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json
 src/opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py
-src/opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json
-src/opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py
 src/opengeodeweb_back/routes/schemas/import_project.json
 src/opengeodeweb_back/routes/schemas/import_project.py
 src/opengeodeweb_back/routes/schemas/kill.json
@@ -134,6 +150,7 @@ src/opengeodeweb_back/routes/schemas/vertex_attribute_names.py
 src/opengeodeweb_back/routes/schemas/vertex_attribute_range.json
 src/opengeodeweb_back/routes/schemas/vertex_attribute_range.py
 tests/test_create_routes.py
+tests/test_crs_routes.py
 tests/test_events.py
 tests/test_geode_functions.py
 tests/test_routes.py

{opengeodeweb_back-6.16.1 → opengeodeweb_back-6.17.0rc1}/src/opengeodeweb_back/app.py

@@ -20,6 +20,7 @@ from werkzeug.exceptions import HTTPException
 from opengeodeweb_back import app_config, utils_functions
 from opengeodeweb_back.routes import blueprint_routes
 from opengeodeweb_back.routes.create import blueprint_create
+from opengeodeweb_back.routes.crs import blueprint_crs
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -171,6 +172,11 @@ def register_ogw_back_blueprints(app: flask.Flask) -> None:
         url_prefix="/opengeodeweb_back/create",
         name="opengeodeweb_create",
     )
+    app.register_blueprint(
+        blueprint_crs.routes,
+        url_prefix="/opengeodeweb_back/crs",
+        name="opengeodeweb_crs",
+    )
 
 
 def run_server(app: Flask) -> None:

opengeodeweb_back-6.17.0rc1/src/opengeodeweb_back/crs/crs_alignment.py

@@ -0,0 +1,197 @@
+"""Georeferencing data from control points: similarity or affine alignment."""
+
+from __future__ import annotations
+
+# Standard library imports
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol
+
+# Third party imports
+import opengeode as og
+
+# Local application imports
+from opengeodeweb_back.crs.crs_functions import (
+    CRS_GEODE_OBJECTS_3D,
+    ORIGINAL_CRS,
+    CrsError,
+    coordinate_system,
+    geographic_info,
+    original_coordinates,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import opengeode_geosciences as og_geosciences
+
+    from opengeodeweb_back.crs.crs_functions import CrsGeodeObject
+
+SIMILARITY = "similarity"
+AFFINE = "affine"
+SIMILARITY_PAIRS = (1, 2)
+AFFINE_PAIRS = 3
+
+
+class ControlPoint(Protocol):
+    x: float
+    y: float
+
+
+class SourcePoint(ControlPoint, Protocol):
+    # Picked on the displayed data rather than typed
+    picked: bool | None
+
+
+@dataclass(frozen=True)
+class Alignment:
+    source: og.CoordinateSystem2D
+    target: og.CoordinateSystem2D
+    scale: float | None
+    info: og_geosciences.GeographicCoordinateSystemInfo
+
+
+def points(control_points: Sequence[ControlPoint]) -> list[og.Point2D]:
+    return [og.Point2D([point.x, point.y]) for point in control_points]
+
+
+def check_pair_count(mode: str, source_count: int, target_count: int) -> None:
+    if source_count != target_count:
+        msg = "Source and target points must come in pairs"
+        raise CrsError(msg)
+    if mode == AFFINE and source_count != AFFINE_PAIRS:
+        msg = "Affine alignment needs 3 pairs of points"
+        raise CrsError(msg)
+    if mode == SIMILARITY and source_count not in SIMILARITY_PAIRS:
+        msg = "Alignment without distortion needs 1 or 2 pairs of points"
+        raise CrsError(msg)
+
+
+def _crs_names(geode_object: CrsGeodeObject) -> set[str]:
+    # Model components may hold different CRS: gather them all
+    managers = [
+        mesh.main_coordinate_reference_system_manager() for mesh in geode_object.crs_meshes()
+    ]
+    return {name for manager in managers for name in manager.coordinate_reference_system_names()}
+
+
+def has_original_coordinates(geode_object: CrsGeodeObject) -> bool:
+    # Assigning a geographic CRS renames the "points" CRS: the assigned coordinates are the base
+    return all(
+        mesh.main_coordinate_reference_system_manager().coordinate_reference_system_exists(
+            ORIGINAL_CRS
+        )
+        for mesh in geode_object.crs_meshes()
+    )
+
+
+def _delete_other_crs(geode_object: CrsGeodeObject, *kept: str) -> None:
+    for crs_name in _crs_names(geode_object):
+        if crs_name not in kept:
+            geode_object.delete_crs(crs_name)
+
+
+def source_points_in_original_coordinates(
+    geode_object: CrsGeodeObject, source_points: Sequence[SourcePoint]
+) -> list[og.Point2D]:
+    """Source points in the loaded coordinates: alignments must not stack.
+
+    Picked points lie on the displayed data: they are mapped back.
+    Typed points are already original coordinates.
+    """
+    typed = points(source_points)
+    if geographic_info(geode_object.crs_manager()) is None or not has_original_coordinates(
+        geode_object
+    ):
+        return typed
+    original_points = original_coordinates(geode_object, typed)
+    if original_points is None:
+        if any(point.picked for point in source_points):
+            msg = "Data has no three non-colinear vertices to re-align"
+            raise CrsError(msg)
+        return typed
+    return [
+        original if source.picked else point
+        for source, original, point in zip(source_points, original_points, typed, strict=True)
+    ]
+
+
+def _restart_alignment(geode_object: CrsGeodeObject) -> bool:
+    """Go back to the loaded coordinates. True when only the active ones can be aligned."""
+    if geographic_info(geode_object.crs_manager()) is None:
+        return False
+    if not has_original_coordinates(geode_object):
+        return True
+    geode_object.set_active_crs(ORIGINAL_CRS)
+    _delete_other_crs(geode_object, ORIGINAL_CRS)
+    return False
+
+
+def _frame(origin: og.Point2D, x: float, y: float) -> og.CoordinateSystem2D:
+    # Perpendicular axes of equal length: going from one frame to another is a similarity
+    return og.CoordinateSystem2D([og.Vector2D([x, y]), og.Vector2D([-y, x])], origin)
+
+
+def _similarity_coordinate_systems(
+    source: list[og.Point2D], target: list[og.Point2D]
+) -> tuple[og.CoordinateSystem2D, og.CoordinateSystem2D, float, float]:
+    """Frames moving source onto target without distortion, with the scale and rotation."""
+    if len(source) == 1:
+        return _frame(source[0], 1, 0), _frame(target[0], 1, 0), 1.0, 0.0
+    source_x = source[1].value(0) - source[0].value(0)
+    source_y = source[1].value(1) - source[0].value(1)
+    target_x = target[1].value(0) - target[0].value(0)
+    target_y = target[1].value(1) - target[0].value(1)
+    source_length = math.hypot(source_x, source_y)
+    target_length = math.hypot(target_x, target_y)
+    if source_length == 0 or target_length == 0:
+        msg = "The two points of the source or of the target must differ"
+        raise CrsError(msg)
+    rotation = math.degrees(
+        math.atan2(
+            source_x * target_y - source_y * target_x, source_x * target_x + source_y * target_y
+        )
+    )
+    return (
+        _frame(source[0], source_x, source_y),
+        _frame(target[0], target_x, target_y),
+        target_length / source_length,
+        rotation,
+    )
+
+
+def colinear(frame_points: list[og.Point2D]) -> bool:
+    origin, first, second = frame_points
+    first_x = first.value(0) - origin.value(0)
+    first_y = first.value(1) - origin.value(1)
+    second_x = second.value(0) - origin.value(0)
+    second_y = second.value(1) - origin.value(1)
+    # Relative to the size of the triangle: coordinates may be in metres or millions of metres
+    scale = max(math.hypot(first_x, first_y), math.hypot(second_x, second_y)) ** 2
+    return scale == 0 or abs(first_x * second_y - first_y * second_x) <= 1e-12 * scale
+
+
+def coordinate_systems(
+    mode: str, source_points: list[og.Point2D], target_points: list[og.Point2D]
+) -> tuple[og.CoordinateSystem2D, og.CoordinateSystem2D, float | None, float | None]:
+    """Frames moving source onto target, with the scale and rotation without distortion."""
+    if mode == SIMILARITY:
+        return _similarity_coordinate_systems(source_points, target_points)
+    # Checked here: any other error of OpenGeode is not the user's and is not hidden
+    if colinear(source_points) or colinear(target_points):
+        msg = "Points must not be colinear"
+        raise CrsError(msg)
+    return coordinate_system(source_points), coordinate_system(target_points), None, None
+
+
+def apply_alignment(geode_object: CrsGeodeObject, alignment: Alignment) -> None:
+    from_active = _restart_alignment(geode_object)
+    geode_object.create_crs("aligned", alignment.source, alignment.target)
+    # The aligned CRS is active: scale its Z so the data keeps its proportions
+    scale = alignment.scale
+    if scale is not None and scale != 1 and isinstance(geode_object, CRS_GEODE_OBJECTS_3D):
+        geode_object.scale_z(scale)
+    if from_active:
+        # The previous geographic CRS and its coordinates would clash with the new assignment
+        _delete_other_crs(geode_object, "aligned", ORIGINAL_CRS)
+    geode_object.assign_crs(alignment.info.authority_code(), alignment.info)

opengeodeweb_back-6.17.0rc1/src/opengeodeweb_back/crs/crs_assignment.py

@@ -0,0 +1,117 @@
+"""Assigning a geographic CRS to data, and converting data to another one."""
+
+from __future__ import annotations
+
+# Standard library imports
+import logging
+from typing import TYPE_CHECKING, Any
+
+# Third party imports
+import opengeode as og
+
+# Local application imports
+from opengeodeweb_back import geode_functions
+from opengeodeweb_back.crs.crs_functions import (
+    ORIGINAL_CRS,
+    CrsError,
+    active_crs,
+    coordinate_system,
+    coordinates_implausible,
+    geographic_info,
+    known_info,
+)
+
+if TYPE_CHECKING:
+    import opengeode_geosciences as og_geosciences
+    from opengeodeweb_microservice.database.data import Data
+
+    from opengeodeweb_back.crs.crs_functions import CrsGeodeObject
+
+logger = logging.getLogger(__name__)
+
+
+def prepare_crs_name(geode_object: CrsGeodeObject, crs_name: str) -> None:
+    crs_manager = geode_object.crs_manager()
+    info = geographic_info(crs_manager)
+    if info is not None and info.authority_code() == crs_name:
+        msg = f"{crs_name} is already the active CRS"
+        raise CrsError(msg)
+    # A registered inactive CRS may hold coordinates derived from an outdated label: recompute it
+    if crs_manager.coordinate_reference_system_exists(crs_name):
+        geode_object.delete_crs(crs_name)
+
+
+def _keep_original_coordinates(geode_object: CrsGeodeObject) -> None:
+    """Assigning renames the active CRS: assign a copy so "points" survives for re-align."""
+    if not all(
+        mesh.main_coordinate_reference_system_manager().active_coordinate_reference_system_name()
+        == ORIGINAL_CRS
+        for mesh in geode_object.crs_meshes()
+    ):
+        return
+    identity = coordinate_system([og.Point2D([0, 0]), og.Point2D([1, 0]), og.Point2D([0, 1])])
+    geode_object.create_crs("assigned", identity, identity)
+
+
+def _assign(
+    geode_object: CrsGeodeObject, authority: str, code: str
+) -> og_geosciences.GeographicCoordinateSystemInfo:
+    info = known_info(geode_object, authority, code)
+    prepare_crs_name(geode_object, info.authority_code())
+    _keep_original_coordinates(geode_object)
+    geode_object.assign_crs(info.authority_code(), info)
+    return info
+
+
+def assign_all(
+    targets: list[tuple[str, Data, CrsGeodeObject]],
+    authority: str,
+    code: str,
+    *,
+    only_plausible: bool,
+) -> dict[str, dict[str, Any]]:
+    """Assign the CRS to every target and save them. Per id: implausible, and crs if assigned.
+
+    Without only_plausible, the plausibility is a warning only: the label is kept.
+    """
+    # Checked before any change: with only_plausible, an implausible data is left as it is
+    implausible = {
+        target_id: coordinates_implausible(
+            target_object, known_info(target_object, authority, code)
+        )
+        for target_id, _, target_object in targets
+    }
+    assigned = {
+        target_id for target_id, _, _ in targets if not (only_plausible and implausible[target_id])
+    }
+    # Every data is assigned in memory before any file is written
+    for target_id, _, target_object in targets:
+        if target_id in assigned:
+            _assign(target_object, authority, code)
+    # Assigning only relabels the coordinates: the viewables are unchanged
+    for target_id, target_data, target_object in targets:
+        if target_id in assigned:
+            target_object.save(geode_functions.data_file_path(target_id, target_data.native_file))
+    entries: dict[str, dict[str, Any]] = {}
+    for target_id, _, target_object in targets:
+        entry: dict[str, Any] = {"implausible": implausible[target_id]}
+        if target_id in assigned:
+            entry["crs"] = active_crs(target_object)
+        entries[target_id] = entry
+    return entries
+
+
+def convert(geode_object: CrsGeodeObject, authority: str, code: str) -> None:
+    if geographic_info(geode_object.crs_manager()) is None:
+        msg = "Assign a geographic CRS before converting"
+        raise CrsError(msg)
+    info = known_info(geode_object, authority, code)
+    prepare_crs_name(geode_object, info.authority_code())
+    try:
+        geode_object.convert_crs(info.authority_code(), info)
+    except RuntimeError as error:
+        # Usually PROJ rejecting coordinates outside the source or target CRS domain: the
+        # Message tells, and the log keeps the trace for any other OpenGeode error
+        logger.exception("Conversion to %s failed", info.authority_code())
+        msg = f"Coordinates cannot be converted to {info.authority_code()}: {error}"
+        raise CrsError(msg) from error