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

opengeodeweb_back/geode_objects/geode_raster_image2d.py

@@ -0,0 +1,83 @@
+# 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_mesh import GeodeMesh
+
+
+class GeodeRasterImage2D(GeodeMesh):
+    raster_image: og.RasterImage2D
+
+    def __init__(self, raster_image: og.RasterImage2D) -> None:
+        self.raster_image = raster_image
+        super().__init__(self.raster_image)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "RasterImage2D"
+
+    def native_extension(self) -> str:
+        return self.raster_image.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> None:
+        return None
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeRasterImage2D:
+        return GeodeRasterImage2D(og.load_raster_image2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.raster_image_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_raster_image_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.RasterImageInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.RasterImageOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.raster_image_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_raster_image_saveable2D(self.raster_image, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_raster_image2D(self.raster_image, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_raster_image2D(
+            self.raster_image, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_raster_image2D(
+            self.raster_image, filename_without_extension
+        )
+
+    def inspect(self) -> None:
+        return None
+
+    def vertex_attribute_manager(self) -> og.AttributeManager:
+        return og.AttributeManager()

opengeodeweb_back/geode_objects/geode_raster_image3d.py

@@ -0,0 +1,83 @@
+# 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_mesh import GeodeMesh
+
+
+class GeodeRasterImage3D(GeodeMesh):
+    raster_image: og.RasterImage3D
+
+    def __init__(self, raster_image: og.RasterImage3D) -> None:
+        self.raster_image = raster_image
+        super().__init__(self.raster_image)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "RasterImage3D"
+
+    def native_extension(self) -> str:
+        return self.raster_image.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> None:
+        return None
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeRasterImage3D:
+        return GeodeRasterImage3D(og.load_raster_image3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.raster_image_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_raster_image_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.RasterImageInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.RasterImageOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.raster_image_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_raster_image_saveable3D(self.raster_image, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_raster_image3D(self.raster_image, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_raster_image3D(
+            self.raster_image, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_raster_image3D(
+            self.raster_image, filename_without_extension
+        )
+
+    def inspect(self) -> None:
+        return None
+
+    def vertex_attribute_manager(self) -> og.AttributeManager:
+        return og.AttributeManager()

opengeodeweb_back/geode_objects/geode_regular_grid2d.py

@@ -0,0 +1,78 @@
+# 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
+from .geode_grid2d import GeodeGrid2D
+
+
+class GeodeRegularGrid2D(GeodeSurfaceMesh2D, GeodeGrid2D):
+    regular_grid: og.RegularGrid2D
+
+    def __init__(self, regular_grid: og.RegularGrid2D | None = None) -> None:
+        self.regular_grid = (
+            regular_grid if regular_grid is not None else og.RegularGrid2D.create()
+        )
+        super().__init__(self.regular_grid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "RegularGrid2D"
+
+    def inspect(self) -> og_inspector.SurfaceInspectionResult:
+        return super().inspect()
+
+    def native_extension(self) -> str:
+        return self.regular_grid.native_extension()
+
+    def builder(self) -> og.RegularGridBuilder2D:
+        return og.RegularGridBuilder2D.create(self.regular_grid)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeRegularGrid2D:
+        return GeodeRegularGrid2D(og.load_regular_grid2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.regular_grid_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_regular_grid_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.RegularGridInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.RegularGridOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.regular_grid_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_regular_grid_saveable2D(self.regular_grid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_regular_grid2D(self.regular_grid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_regular_grid2D(
+            self.regular_grid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_regular_grid2D(
+            self.regular_grid, filename_without_extension
+        )
+
+    def cell_attribute_manager(self) -> og.AttributeManager:
+        return self.regular_grid.cell_attribute_manager()

opengeodeweb_back/geode_objects/geode_regular_grid3d.py

@@ -0,0 +1,78 @@
+# 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
+from .geode_grid3d import GeodeGrid3D
+
+
+class GeodeRegularGrid3D(GeodeSolidMesh3D, GeodeGrid3D):
+    regular_grid: og.RegularGrid3D
+
+    def __init__(self, regular_grid: og.RegularGrid3D | None = None) -> None:
+        self.regular_grid = (
+            regular_grid if regular_grid is not None else og.RegularGrid3D.create()
+        )
+        super().__init__(self.regular_grid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "RegularGrid3D"
+
+    def native_extension(self) -> str:
+        return self.regular_grid.native_extension()
+
+    def builder(self) -> og.RegularGridBuilder3D:
+        return og.RegularGridBuilder3D.create(self.regular_grid)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeRegularGrid3D:
+        return GeodeRegularGrid3D(og.load_regular_grid3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.regular_grid_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_regular_grid_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.RegularGridInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.RegularGridOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.regular_grid_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_regular_grid_saveable3D(self.regular_grid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_regular_grid3D(self.regular_grid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_regular_grid3D(
+            self.regular_grid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_regular_grid3D(
+            self.regular_grid, filename_without_extension
+        )
+
+    def cell_attribute_manager(self) -> og.AttributeManager:
+        return self.regular_grid.cell_attribute_manager()
+
+    def inspect(self) -> og_inspector.SolidInspectionResult:
+        return super().inspect()

opengeodeweb_back/geode_objects/geode_section.py

@@ -0,0 +1,106 @@
+# 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, ViewerType
+from .geode_model import GeodeModel, ComponentRegistry
+
+
+class GeodeSection(GeodeModel):
+    section: og.Section
+
+    def __init__(self, section: og.Section | None = None) -> None:
+        self.section = section if section is not None else og.Section()
+        super().__init__(self.section)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "Section"
+
+    def native_extension(self) -> str:
+        return self.section.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.SectionBuilder:
+        return og.SectionBuilder(self.section)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeSection:
+        return GeodeSection(og.load_section(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.section_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_section_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.SectionInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.SectionOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.section_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_section_saveable(self.section, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_section(self.section, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_section(self.section, filename_without_extension)
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_section(
+            self.section, filename_without_extension
+        )
+
+    def mesh_components(self) -> ComponentRegistry:
+        return self.section.mesh_components()
+
+    def inspect(self) -> og_inspector.SectionInspectionResult:
+        return og_inspector.inspect_section(self.section)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_section_geographic_coordinate_system_info(
+            self.section, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_section_coordinate_reference_system(
+            self.section, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_section_coordinate_system(
+            self.section, builder, crs_name, input, output
+        )

opengeodeweb_back/geode_objects/geode_solid_mesh3d.py

@@ -0,0 +1,61 @@
+# 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 GeodeSolidMesh3D(GeodeVertexSet):
+    solid_mesh: og.SolidMesh3D
+
+    def __init__(self, solid_mesh: og.SolidMesh3D | None = None) -> None:
+        self.solid_mesh = solid_mesh if solid_mesh is not None else og.SolidMesh3D()
+        super().__init__(self.solid_mesh)
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.SolidMeshBuilder3D:
+        return og.SolidMeshBuilder3D.create(self.solid_mesh)
+
+    def inspect(self) -> og_inspector.SolidInspectionResult:
+        return og_inspector.inspect_solid3D(self.solid_mesh)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_solid_mesh_geographic_coordinate_system_info3D(
+            self.solid_mesh, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_solid_mesh_coordinate_reference_system3D(
+            self.solid_mesh, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_solid_mesh_coordinate_system3D(
+            self.solid_mesh, builder, crs_name, input, output
+        )
+
+    def polyhedron_attribute_manager(self) -> og.AttributeManager:
+        return self.solid_mesh.polyhedron_attribute_manager()

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()