OpenGeodeWeb-Back 5.10.0rc22__py3-none-any.whl → 5.14.1__py3-none-any.whl

opengeodeweb_back/geode_objects/geode_structural_model.py

@@ -0,0 +1,78 @@
+# 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 GeodeModelType
+from .geode_brep import GeodeBRep
+
+
+class GeodeStructuralModel(GeodeBRep):
+    structural_model: og_geosciences.StructuralModel
+
+    def __init__(
+        self, structural_model: og_geosciences.StructuralModel | None = None
+    ) -> None:
+        self.structural_model = (
+            structural_model
+            if structural_model is not None
+            else og_geosciences.StructuralModel()
+        )
+        super().__init__(self.structural_model)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "StructuralModel"
+
+    def native_extension(self) -> str:
+        return self.structural_model.native_extension()
+
+    def builder(self) -> og_geosciences.StructuralModelBuilder:
+        return og_geosciences.StructuralModelBuilder(self.structural_model)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeStructuralModel:
+        return GeodeStructuralModel(og_geosciences.load_structural_model(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og_geosciences.structural_model_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og_geosciences.is_structural_model_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og_geosciences.StructuralModelInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og_geosciences.StructuralModelOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og_geosciences.structural_model_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og_geosciences.is_structural_model_saveable(
+            self.structural_model, filename
+        )
+
+    def save(self, filename: str) -> list[str]:
+        return og_geosciences.save_structural_model(self.structural_model, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_structural_model(
+            self.structural_model, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_structural_model(
+            self.structural_model, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_surface_mesh2d.py

@@ -0,0 +1,66 @@
+# 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 GeodeSurfaceMesh2D(GeodeVertexSet):
+    surface_mesh: og.SurfaceMesh2D
+
+    def __init__(self, surface_mesh: og.SurfaceMesh2D | None = None) -> None:
+        self.surface_mesh = (
+            surface_mesh if surface_mesh is not None else og.SurfaceMesh2D.create()
+        )
+        super().__init__(self.surface_mesh)
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.SurfaceMeshBuilder2D:
+        return og.SurfaceMeshBuilder2D.create(self.surface_mesh)
+
+    def inspect(self) -> og_inspector.SurfaceInspectionResult:
+        return og_inspector.inspect_surface2D(self.surface_mesh)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_surface_mesh_geographic_coordinate_system_info2D(
+            self.surface_mesh, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_surface_mesh_coordinate_reference_system2D(
+            self.surface_mesh, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_surface_mesh_coordinate_system2D(
+            self.surface_mesh, builder, crs_name, input, output
+        )
+
+    def polygon_attribute_manager(self) -> og.AttributeManager:
+        return self.surface_mesh.polygon_attribute_manager()
+
+    def texture_manager(self) -> og.TextureManager2D:
+        return self.surface_mesh.texture_manager()

opengeodeweb_back/geode_objects/geode_surface_mesh3d.py

@@ -0,0 +1,66 @@
+# 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 GeodeSurfaceMesh3D(GeodeVertexSet):
+    surface_mesh: og.SurfaceMesh3D
+
+    def __init__(self, surface_mesh: og.SurfaceMesh3D | None = None) -> None:
+        self.surface_mesh = (
+            surface_mesh if surface_mesh is not None else og.SurfaceMesh3D.create()
+        )
+        super().__init__(self.surface_mesh)
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.SurfaceMeshBuilder3D:
+        return og.SurfaceMeshBuilder3D.create(self.surface_mesh)
+
+    def inspect(self) -> og_inspector.SurfaceInspectionResult:
+        return og_inspector.inspect_surface3D(self.surface_mesh)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_surface_mesh_geographic_coordinate_system_info3D(
+            self.surface_mesh, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_surface_mesh_coordinate_reference_system3D(
+            self.surface_mesh, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_surface_mesh_coordinate_system3D(
+            self.surface_mesh, builder, crs_name, input, output
+        )
+
+    def polygon_attribute_manager(self) -> og.AttributeManager:
+        return self.surface_mesh.polygon_attribute_manager()
+
+    def texture_manager(self) -> og.TextureManager2D:
+        return self.surface_mesh.texture_manager()

opengeodeweb_back/geode_objects/geode_tetrahedral_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 GeodeTetrahedralSolid3D(GeodeSolidMesh3D):
+    tetrahedral_solid: og.TetrahedralSolid3D
+
+    def __init__(self, tetrahedral_solid: og.TetrahedralSolid3D | None = None) -> None:
+        self.tetrahedral_solid = (
+            tetrahedral_solid
+            if tetrahedral_solid is not None
+            else og.TetrahedralSolid3D.create()
+        )
+        super().__init__(self.tetrahedral_solid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "TetrahedralSolid3D"
+
+    def native_extension(self) -> str:
+        return self.tetrahedral_solid.native_extension()
+
+    def builder(self) -> og.TetrahedralSolidBuilder3D:
+        return og.TetrahedralSolidBuilder3D.create(self.tetrahedral_solid)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeTetrahedralSolid3D:
+        return GeodeTetrahedralSolid3D(og.load_tetrahedral_solid3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.tetrahedral_solid_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_tetrahedral_solid_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.TetrahedralSolidInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.TetrahedralSolidOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.tetrahedral_solid_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_tetrahedral_solid_saveable3D(self.tetrahedral_solid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_tetrahedral_solid3D(self.tetrahedral_solid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_tetrahedral_solid3D(
+            self.tetrahedral_solid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_tetrahedral_solid3D(
+            self.tetrahedral_solid, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_triangulated_surface2d.py

@@ -0,0 +1,77 @@
+# 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 GeodeTriangulatedSurface2D(GeodeSurfaceMesh2D):
+    triangulated_surface: og.TriangulatedSurface2D
+
+    def __init__(
+        self, triangulated_surface: og.TriangulatedSurface2D | None = None
+    ) -> None:
+        self.triangulated_surface = (
+            triangulated_surface
+            if triangulated_surface is not None
+            else og.TriangulatedSurface2D.create()
+        )
+        super().__init__(self.triangulated_surface)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "TriangulatedSurface2D"
+
+    def native_extension(self) -> str:
+        return self.triangulated_surface.native_extension()
+
+    def builder(self) -> og.TriangulatedSurfaceBuilder2D:
+        return og.TriangulatedSurfaceBuilder2D.create(self.triangulated_surface)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeTriangulatedSurface2D:
+        return GeodeTriangulatedSurface2D(og.load_triangulated_surface2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.triangulated_surface_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_triangulated_surface_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.TriangulatedSurfaceInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.TriangulatedSurfaceOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.triangulated_surface_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_triangulated_surface_saveable2D(
+            self.triangulated_surface, filename
+        )
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_triangulated_surface2D(self.triangulated_surface, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_triangulated_surface2D(
+            self.triangulated_surface, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_triangulated_surface2D(
+            self.triangulated_surface, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_triangulated_surface3d.py

@@ -0,0 +1,77 @@
+# 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 GeodeTriangulatedSurface3D(GeodeSurfaceMesh3D):
+    triangulated_surface: og.TriangulatedSurface3D
+
+    def __init__(
+        self, triangulated_surface: og.TriangulatedSurface3D | None = None
+    ) -> None:
+        self.triangulated_surface = (
+            triangulated_surface
+            if triangulated_surface is not None
+            else og.TriangulatedSurface3D.create()
+        )
+        super().__init__(self.triangulated_surface)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "TriangulatedSurface3D"
+
+    def native_extension(self) -> str:
+        return self.triangulated_surface.native_extension()
+
+    def builder(self) -> og.TriangulatedSurfaceBuilder3D:
+        return og.TriangulatedSurfaceBuilder3D.create(self.triangulated_surface)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeTriangulatedSurface3D:
+        return GeodeTriangulatedSurface3D(og.load_triangulated_surface3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.triangulated_surface_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_triangulated_surface_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.TriangulatedSurfaceInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.TriangulatedSurfaceOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.triangulated_surface_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_triangulated_surface_saveable3D(
+            self.triangulated_surface, filename
+        )
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_triangulated_surface3D(self.triangulated_surface, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_triangulated_surface3D(
+            self.triangulated_surface, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_triangulated_surface3D(
+            self.triangulated_surface, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_vertex_set.py

@@ -0,0 +1,81 @@
+# 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, ViewerType
+from .geode_mesh import GeodeMesh
+
+
+class GeodeVertexSet(GeodeMesh):
+    vertex_set: og.VertexSet
+
+    def __init__(self, vertex_set: og.VertexSet | None = None) -> None:
+        self.vertex_set = (
+            vertex_set if vertex_set is not None else og.VertexSet.create()
+        )
+        super().__init__(self.vertex_set)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "VertexSet"
+
+    def native_extension(self) -> str:
+        return self.vertex_set.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return False
+
+    def builder(self) -> og.VertexSetBuilder:
+        return og.VertexSetBuilder.create(self.vertex_set)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeVertexSet:
+        return GeodeVertexSet(og.load_vertex_set(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.vertex_set_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_vertex_set_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.VertexSetInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.VertexSetOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.vertex_set_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_vertex_set_saveable(self.vertex_set, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_vertex_set(self.vertex_set, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return ""
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return ""
+
+    def inspect(self) -> object:
+        return None
+
+    def vertex_attribute_manager(self) -> og.AttributeManager:
+        return self.vertex_set.vertex_attribute_manager()

opengeodeweb_back/geode_objects/types.py

@@ -0,0 +1,75 @@
+# Standard library imports
+from typing import Literal, get_args, cast
+
+# Third party imports
+
+# Local application imports
+
+GeodePointMeshType = Literal[
+    "PointSet2D",
+    "PointSet3D",
+]
+GeodeEdgeMeshType = Literal[
+    "EdgedCurve2D",
+    "EdgedCurve3D",
+]
+GeodePolygonMeshType = Literal[
+    "RasterImage2D",
+    "PolygonalSurface2D",
+    "PolygonalSurface3D",
+    "TriangulatedSurface2D",
+    "TriangulatedSurface3D",
+    "RegularGrid2D",
+    "LightRegularGrid2D",
+]
+GeodePolyhedronMeshType = Literal[
+    "RasterImage3D",
+    "PolyhedralSolid3D",
+    "TetrahedralSolid3D",
+    "HybridSolid3D",
+    "RegularGrid3D",
+    "LightRegularGrid3D",
+]
+GeodeMeshType = (
+    Literal[
+        "VertexSet",
+        "Graph",
+    ]
+    | GeodePointMeshType
+    | GeodeEdgeMeshType
+    | GeodePolygonMeshType
+    | GeodePolyhedronMeshType
+)
+GeodeModelType = Literal[
+    "BRep",
+    "Section",
+    "StructuralModel",
+    "CrossSection",
+    "ImplicitStructuralModel",
+    "ImplicitCrossSection",
+]
+GeodeObjectType = GeodeMeshType | GeodeModelType
+
+
+def _flatten_literal_args(literal: object) -> tuple[str, ...]:
+    flattened: list[str] = []
+    for arg in get_args(literal):
+        if isinstance(arg, str):
+            flattened.append(arg)
+        else:
+            flattened.extend(_flatten_literal_args(arg))
+    return tuple(flattened)
+
+
+GeodeObjectType_values = _flatten_literal_args(GeodeObjectType)
+
+
+def geode_object_type(value: str) -> GeodeObjectType:
+    if value not in GeodeObjectType_values:
+        raise ValueError(
+            f"Invalid GeodeObjectType: {value!r}. Must be one of {GeodeObjectType_values}"
+        )
+    return cast(GeodeObjectType, value)
+
+
+ViewerType = Literal["mesh", "model"]