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

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

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