OpenGeodeWeb-Back 5.10.4__py3-none-any.whl → 5.14.1__py3-none-any.whl

opengeodeweb_back/geode_objects/geode_light_regular_grid2d.py

@@ -0,0 +1,72 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_grid2d import GeodeGrid2D
+
+
+class GeodeLightRegularGrid2D(GeodeGrid2D):
+    light_regular_grid: og.LightRegularGrid2D
+
+    def __init__(self, light_regular_grid: og.LightRegularGrid2D) -> None:
+        self.light_regular_grid = light_regular_grid
+        super().__init__(self.light_regular_grid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "LightRegularGrid2D"
+
+    def native_extension(self) -> str:
+        return self.light_regular_grid.native_extension()
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeLightRegularGrid2D:
+        return GeodeLightRegularGrid2D(og.load_light_regular_grid2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.light_regular_grid_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_light_regular_grid_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.LightRegularGridInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.LightRegularGridOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.light_regular_grid_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_light_regular_grid_saveable2D(self.light_regular_grid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_light_regular_grid2D(self.light_regular_grid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_light_regular_grid2D(
+            self.light_regular_grid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_light_regular_grid2D(
+            self.light_regular_grid, filename_without_extension
+        )
+
+    def vertex_attribute_manager(self) -> og.AttributeManager:
+        return self.light_regular_grid.grid_vertex_attribute_manager()
+
+    def cell_attribute_manager(self) -> og.AttributeManager:
+        return self.light_regular_grid.cell_attribute_manager()

opengeodeweb_back/geode_objects/geode_light_regular_grid3d.py

@@ -0,0 +1,72 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_grid3d import GeodeGrid3D
+
+
+class GeodeLightRegularGrid3D(GeodeGrid3D):
+    light_regular_grid: og.LightRegularGrid3D
+
+    def __init__(self, light_regular_grid: og.LightRegularGrid3D) -> None:
+        self.light_regular_grid = light_regular_grid
+        super().__init__(self.light_regular_grid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "LightRegularGrid3D"
+
+    def native_extension(self) -> str:
+        return self.light_regular_grid.native_extension()
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeLightRegularGrid3D:
+        return GeodeLightRegularGrid3D(og.load_light_regular_grid3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.light_regular_grid_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_light_regular_grid_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.LightRegularGridInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.LightRegularGridOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.light_regular_grid_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_light_regular_grid_saveable3D(self.light_regular_grid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_light_regular_grid3D(self.light_regular_grid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_light_regular_grid3D(
+            self.light_regular_grid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_light_regular_grid3D(
+            self.light_regular_grid, filename_without_extension
+        )
+
+    def vertex_attribute_manager(self) -> og.AttributeManager:
+        return self.light_regular_grid.grid_vertex_attribute_manager()
+
+    def cell_attribute_manager(self) -> og.AttributeManager:
+        return self.light_regular_grid.cell_attribute_manager()

opengeodeweb_back/geode_objects/geode_mesh.py

@@ -0,0 +1,19 @@
+# Standard library imports
+from __future__ import annotations
+from abc import abstractmethod
+
+# Third party imports
+import opengeode as og
+
+# Local application imports
+from .types import GeodeObjectType, ViewerType
+from .geode_object import GeodeObject
+
+
+class GeodeMesh(GeodeObject):
+    @classmethod
+    def viewer_type(cls) -> ViewerType:
+        return "mesh"
+
+    @abstractmethod
+    def vertex_attribute_manager(self) -> og.AttributeManager: ...

opengeodeweb_back/geode_objects/geode_model.py

@@ -0,0 +1,22 @@
+# Standard library imports
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Literal, Any, get_args, cast
+
+# Third party imports
+import opengeode as og
+
+# Local application imports
+from .types import GeodeObjectType, GeodeModelType, ViewerType
+from .geode_object import GeodeObject
+
+ComponentRegistry = dict[og.ComponentType, list[og.uuid]]
+
+
+class GeodeModel(GeodeObject):
+    @classmethod
+    def viewer_type(cls) -> ViewerType:
+        return "model"
+
+    @abstractmethod
+    def mesh_components(self) -> ComponentRegistry: ...

opengeodeweb_back/geode_objects/geode_object.py

@@ -0,0 +1,78 @@
+# Standard library imports
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Literal, Any, get_args, cast
+
+# Third party imports
+import opengeode as og
+
+# Local application imports
+from .types import GeodeObjectType, ViewerType
+
+
+class GeodeObject(ABC):
+    identifier: og.Identifier
+
+    def __init__(self, identifier: og.Identifier | None = None) -> None:
+        self.identifier = identifier if identifier is not None else og.Identifier()
+
+    @classmethod
+    @abstractmethod
+    def geode_object_type(cls) -> GeodeObjectType: ...
+
+    @classmethod
+    @abstractmethod
+    def viewer_type(cls) -> ViewerType: ...
+
+    @classmethod
+    @abstractmethod
+    def is_3D(cls) -> bool: ...
+
+    @classmethod
+    @abstractmethod
+    def is_viewable(cls) -> bool: ...
+
+    @abstractmethod
+    def builder(self) -> Any: ...
+
+    @classmethod
+    @abstractmethod
+    def is_loadable(cls, filename: str) -> og.Percentage: ...
+
+    @classmethod
+    @abstractmethod
+    def load(cls, filename: str) -> GeodeObject: ...
+
+    @classmethod
+    @abstractmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles: ...
+
+    @abstractmethod
+    def native_extension(cls) -> str: ...
+
+    @classmethod
+    @abstractmethod
+    def input_extensions(cls) -> list[str]: ...
+
+    @classmethod
+    @abstractmethod
+    def object_priority(cls, filename: str) -> int: ...
+
+    @classmethod
+    @abstractmethod
+    def output_extensions(cls) -> list[str]: ...
+
+    @abstractmethod
+    def is_saveable(self, filename: str) -> bool: ...
+
+    @abstractmethod
+    def save(self, filename: str) -> list[str]: ...
+
+    @abstractmethod
+    def save_viewable(self, filename_without_extension: str) -> str: ...
+
+    @abstractmethod
+    def save_light_viewable(self, filename_without_extension: str) -> str: ...
+
+    @abstractmethod
+    def inspect(self) -> Any: ...

opengeodeweb_back/geode_objects/geode_point_set2d.py

@@ -0,0 +1,105 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_vertex_set import GeodeVertexSet
+
+
+class GeodePointSet2D(GeodeVertexSet):
+    point_set: og.PointSet2D
+
+    def __init__(self, point_set: og.PointSet2D | None = None) -> None:
+        self.point_set = point_set if point_set is not None else og.PointSet2D.create()
+        super().__init__(self.point_set)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "PointSet2D"
+
+    def native_extension(self) -> str:
+        return self.point_set.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.PointSetBuilder2D:
+        return og.PointSetBuilder2D.create(self.point_set)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodePointSet2D:
+        return GeodePointSet2D(og.load_point_set2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.point_set_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_point_set_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.PointSetInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.PointSetOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.point_set_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_point_set_saveable2D(self.point_set, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_point_set2D(self.point_set, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_point_set2D(
+            self.point_set, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_point_set2D(
+            self.point_set, filename_without_extension
+        )
+
+    def inspect(self) -> og_inspector.PointSetInspectionResult:
+        return og_inspector.inspect_point_set2D(self.point_set)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_point_set_geographic_coordinate_system_info2D(
+            self.point_set, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_point_set_coordinate_reference_system2D(
+            self.point_set, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_point_set_coordinate_system2D(
+            self.point_set, builder, crs_name, input, output
+        )

opengeodeweb_back/geode_objects/geode_point_set3d.py

@@ -0,0 +1,105 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_vertex_set import GeodeVertexSet
+
+
+class GeodePointSet3D(GeodeVertexSet):
+    point_set: og.PointSet3D
+
+    def __init__(self, point_set: og.PointSet3D | None = None) -> None:
+        self.point_set = point_set if point_set is not None else og.PointSet3D.create()
+        super().__init__(self.point_set)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "PointSet3D"
+
+    def native_extension(self) -> str:
+        return self.point_set.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.PointSetBuilder3D:
+        return og.PointSetBuilder3D.create(self.point_set)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodePointSet3D:
+        return GeodePointSet3D(og.load_point_set3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.point_set_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_point_set_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.PointSetInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.PointSetOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.point_set_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_point_set_saveable3D(self.point_set, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_point_set3D(self.point_set, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_point_set3D(
+            self.point_set, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_point_set3D(
+            self.point_set, filename_without_extension
+        )
+
+    def inspect(self) -> og_inspector.PointSetInspectionResult:
+        return og_inspector.inspect_point_set3D(self.point_set)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_point_set_geographic_coordinate_system_info3D(
+            self.point_set, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_point_set_coordinate_reference_system3D(
+            self.point_set, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_point_set_coordinate_system3D(
+            self.point_set, builder, crs_name, input, output
+        )

opengeodeweb_back/geode_objects/geode_polygonal_surface2d.py

@@ -0,0 +1,73 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_surface_mesh2d import GeodeSurfaceMesh2D
+
+
+class GeodePolygonalSurface2D(GeodeSurfaceMesh2D):
+    polygonal_surface: og.PolygonalSurface2D
+
+    def __init__(self, polygonal_surface: og.PolygonalSurface2D | None = None) -> None:
+        self.polygonal_surface = (
+            polygonal_surface
+            if polygonal_surface is not None
+            else og.PolygonalSurface2D.create()
+        )
+        super().__init__(self.polygonal_surface)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "PolygonalSurface2D"
+
+    def native_extension(self) -> str:
+        return self.polygonal_surface.native_extension()
+
+    def builder(self) -> og.PolygonalSurfaceBuilder2D:
+        return og.PolygonalSurfaceBuilder2D.create(self.polygonal_surface)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodePolygonalSurface2D:
+        return GeodePolygonalSurface2D(og.load_polygonal_surface2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.polygonal_surface_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_polygonal_surface_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.PolygonalSurfaceInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.PolygonalSurfaceOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.polygonal_surface_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_polygonal_surface_saveable2D(self.polygonal_surface, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_polygonal_surface2D(self.polygonal_surface, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_polygonal_surface2D(
+            self.polygonal_surface, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_polygonal_surface2D(
+            self.polygonal_surface, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_polygonal_surface3d.py

@@ -0,0 +1,73 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_surface_mesh3d import GeodeSurfaceMesh3D
+
+
+class GeodePolygonalSurface3D(GeodeSurfaceMesh3D):
+    polygonal_surface: og.PolygonalSurface3D
+
+    def __init__(self, polygonal_surface: og.PolygonalSurface3D | None = None) -> None:
+        self.polygonal_surface = (
+            polygonal_surface
+            if polygonal_surface is not None
+            else og.PolygonalSurface3D.create()
+        )
+        super().__init__(self.polygonal_surface)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "PolygonalSurface3D"
+
+    def native_extension(self) -> str:
+        return self.polygonal_surface.native_extension()
+
+    def builder(self) -> og.PolygonalSurfaceBuilder3D:
+        return og.PolygonalSurfaceBuilder3D.create(self.polygonal_surface)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodePolygonalSurface3D:
+        return GeodePolygonalSurface3D(og.load_polygonal_surface3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.polygonal_surface_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_polygonal_surface_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.PolygonalSurfaceInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.PolygonalSurfaceOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.polygonal_surface_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_polygonal_surface_saveable3D(self.polygonal_surface, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_polygonal_surface3D(self.polygonal_surface, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_polygonal_surface3D(
+            self.polygonal_surface, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_polygonal_surface3D(
+            self.polygonal_surface, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_polyhedral_solid3d.py

@@ -0,0 +1,73 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_inspector as og_inspector
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_solid_mesh3d import GeodeSolidMesh3D
+
+
+class GeodePolyhedralSolid3D(GeodeSolidMesh3D):
+    polyhedral_solid: og.PolyhedralSolid3D
+
+    def __init__(self, polyhedral_solid: og.PolyhedralSolid3D | None = None) -> None:
+        self.polyhedral_solid = (
+            polyhedral_solid
+            if polyhedral_solid is not None
+            else og.PolyhedralSolid3D.create()
+        )
+        super().__init__(self.polyhedral_solid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "PolyhedralSolid3D"
+
+    def native_extension(self) -> str:
+        return self.polyhedral_solid.native_extension()
+
+    def builder(self) -> og.PolyhedralSolidBuilder3D:
+        return og.PolyhedralSolidBuilder3D.create(self.polyhedral_solid)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodePolyhedralSolid3D:
+        return GeodePolyhedralSolid3D(og.load_polyhedral_solid3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.polyhedral_solid_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_polyhedral_solid_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.PolyhedralSolidInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.PolyhedralSolidOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.polyhedral_solid_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_polyhedral_solid_saveable3D(self.polyhedral_solid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_polyhedral_solid3D(self.polyhedral_solid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_polyhedral_solid3D(
+            self.polyhedral_solid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_polyhedral_solid3D(
+            self.polyhedral_solid, filename_without_extension
+        )