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

opengeodeweb_back/geode_objects/geode_brep.py

@@ -0,0 +1,102 @@
+# 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_model import GeodeModel, ComponentRegistry
+
+
+class GeodeBRep(GeodeModel):
+    brep: og.BRep
+
+    def __init__(self, brep: og.BRep | None = None) -> None:
+        self.brep = brep if brep is not None else og.BRep()
+        super().__init__(self.brep)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "BRep"
+
+    def native_extension(self) -> str:
+        return self.brep.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.BRepBuilder:
+        return og.BRepBuilder(self.brep)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeBRep:
+        return GeodeBRep(og.load_brep(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.brep_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_brep_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.BRepInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.BRepOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.brep_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_brep_saveable(self.brep, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_brep(self.brep, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_brep(self.brep, filename_without_extension)
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_brep(self.brep, filename_without_extension)
+
+    def mesh_components(self) -> ComponentRegistry:
+        return self.brep.mesh_components()
+
+    def inspect(self) -> og_inspector.BRepInspectionResult:
+        return og_inspector.inspect_brep(self.brep)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_brep_geographic_coordinate_system_info(
+            self.brep, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_brep_coordinate_reference_system(
+            self.brep, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_brep_coordinate_system(self.brep, builder, crs_name, input, output)

opengeodeweb_back/geode_objects/geode_cross_section.py

@@ -0,0 +1,75 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeModelType
+from .geode_section import GeodeSection
+
+
+class GeodeCrossSection(GeodeSection):
+    cross_section: og_geosciences.CrossSection
+
+    def __init__(
+        self, cross_section: og_geosciences.CrossSection | None = None
+    ) -> None:
+        self.cross_section = (
+            cross_section
+            if cross_section is not None
+            else og_geosciences.CrossSection()
+        )
+        super().__init__(self.cross_section)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "CrossSection"
+
+    def native_extension(self) -> str:
+        return self.cross_section.native_extension()
+
+    def builder(self) -> og_geosciences.CrossSectionBuilder:
+        return og_geosciences.CrossSectionBuilder(self.cross_section)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeCrossSection:
+        return GeodeCrossSection(og_geosciences.load_cross_section(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og_geosciences.cross_section_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og_geosciences.is_cross_section_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og_geosciences.CrossSectionInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og_geosciences.CrossSectionOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og_geosciences.cross_section_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og_geosciences.is_cross_section_saveable(self.cross_section, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og_geosciences.save_cross_section(self.cross_section, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_cross_section(
+            self.cross_section, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_cross_section(
+            self.cross_section, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_edged_curve2d.py

@@ -0,0 +1,107 @@
+# 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_graph import GeodeGraph
+
+
+class GeodeEdgedCurve2D(GeodeGraph):
+    edged_curve: og.EdgedCurve2D
+
+    def __init__(self, edged_curve: og.EdgedCurve2D | None = None) -> None:
+        self.edged_curve = (
+            edged_curve if edged_curve is not None else og.EdgedCurve2D.create()
+        )
+        super().__init__(self.edged_curve)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "EdgedCurve2D"
+
+    def native_extension(self) -> str:
+        return self.edged_curve.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.EdgedCurveBuilder2D:
+        return og.EdgedCurveBuilder2D.create(self.edged_curve)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeEdgedCurve2D:
+        return GeodeEdgedCurve2D(og.load_edged_curve2D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.edged_curve_additional_files2D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_edged_curve_loadable2D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.EdgedCurveInputFactory2D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.EdgedCurveOutputFactory2D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.edged_curve_object_priority2D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_edged_curve_saveable2D(self.edged_curve, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_edged_curve2D(self.edged_curve, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_edged_curve2D(
+            self.edged_curve, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_edged_curve2D(
+            self.edged_curve, filename_without_extension
+        )
+
+    def inspect(self) -> og_inspector.EdgedCurveInspectionResult:
+        return og_inspector.inspect_edged_curve2D(self.edged_curve)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_edged_curve_geographic_coordinate_system_info2D(
+            self.edged_curve, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_edged_curve_coordinate_reference_system2D(
+            self.edged_curve, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_edged_curve_coordinate_system2D(
+            self.edged_curve, builder, crs_name, input, output
+        )

opengeodeweb_back/geode_objects/geode_edged_curve3d.py

@@ -0,0 +1,107 @@
+# 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_graph import GeodeGraph
+
+
+class GeodeEdgedCurve3D(GeodeGraph):
+    edged_curve: og.EdgedCurve3D
+
+    def __init__(self, edged_curve: og.EdgedCurve3D | None = None) -> None:
+        self.edged_curve = (
+            edged_curve if edged_curve is not None else og.EdgedCurve3D.create()
+        )
+        super().__init__(self.edged_curve)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "EdgedCurve3D"
+
+    def native_extension(self) -> str:
+        return self.edged_curve.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> og.EdgedCurveBuilder3D:
+        return og.EdgedCurveBuilder3D.create(self.edged_curve)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeEdgedCurve3D:
+        return GeodeEdgedCurve3D(og.load_edged_curve3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.edged_curve_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_edged_curve_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.EdgedCurveInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.EdgedCurveOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.edged_curve_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_edged_curve_saveable3D(self.edged_curve, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_edged_curve3D(self.edged_curve, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_edged_curve3D(
+            self.edged_curve, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_edged_curve3D(
+            self.edged_curve, filename_without_extension
+        )
+
+    def inspect(self) -> og_inspector.EdgedCurveInspectionResult:
+        return og_inspector.inspect_edged_curve3D(self.edged_curve)
+
+    def assign_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.assign_edged_curve_geographic_coordinate_system_info3D(
+            self.edged_curve, builder, crs_name, info
+        )
+
+    def convert_crs(
+        self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo
+    ) -> None:
+        builder = self.builder()
+        og_geosciences.convert_edged_curve_coordinate_reference_system3D(
+            self.edged_curve, builder, crs_name, info
+        )
+
+    def create_crs(
+        self, crs_name: str, input: og.CoordinateSystem2D, output: og.CoordinateSystem2D
+    ) -> None:
+        builder = self.builder()
+        og.create_edged_curve_coordinate_system3D(
+            self.edged_curve, builder, crs_name, input, output
+        )

opengeodeweb_back/geode_objects/geode_graph.py

@@ -0,0 +1,76 @@
+# 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_vertex_set import GeodeVertexSet
+
+
+class GeodeGraph(GeodeVertexSet):
+    graph: og.Graph
+
+    def __init__(self, graph: og.Graph | None = None) -> None:
+        self.graph = graph if graph is not None else og.Graph.create()
+        super().__init__(self.graph)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "Graph"
+
+    def native_extension(self) -> str:
+        return self.graph.native_extension()
+
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return False
+
+    def builder(self) -> og.GraphBuilder:
+        return og.GraphBuilder.create(self.graph)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeGraph:
+        return GeodeGraph(og.load_graph(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.graph_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_graph_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.GraphInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.GraphOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.graph_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_graph_saveable(self.graph, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_graph(self.graph, 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

opengeodeweb_back/geode_objects/geode_grid2d.py

@@ -0,0 +1,30 @@
+# Standard library imports
+from __future__ import annotations
+from abc import abstractmethod
+
+# Third party imports
+import opengeode as og
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_mesh import GeodeMesh
+
+
+class GeodeGrid2D(GeodeMesh):
+    @classmethod
+    def is_3D(cls) -> bool:
+        return False
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> object:
+        return None
+
+    def inspect(self) -> object:
+        return None
+
+    @abstractmethod
+    def cell_attribute_manager(self) -> og.AttributeManager: ...

opengeodeweb_back/geode_objects/geode_grid3d.py

@@ -0,0 +1,30 @@
+# Standard library imports
+from __future__ import annotations
+from abc import abstractmethod
+
+# Third party imports
+import opengeode as og
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeMeshType
+from .geode_mesh import GeodeMesh
+
+
+class GeodeGrid3D(GeodeMesh):
+    @classmethod
+    def is_3D(cls) -> bool:
+        return True
+
+    @classmethod
+    def is_viewable(cls) -> bool:
+        return True
+
+    def builder(self) -> object:
+        return None
+
+    def inspect(self) -> object:
+        return None
+
+    @abstractmethod
+    def cell_attribute_manager(self) -> og.AttributeManager: ...

opengeodeweb_back/geode_objects/geode_hybrid_solid3d.py

@@ -0,0 +1,71 @@
+# 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 GeodeHybridSolid3D(GeodeSolidMesh3D):
+    hybrid_solid: og.HybridSolid3D
+
+    def __init__(self, hybrid_solid: og.HybridSolid3D | None = None) -> None:
+        self.hybrid_solid = (
+            hybrid_solid if hybrid_solid is not None else og.HybridSolid3D.create()
+        )
+        super().__init__(self.hybrid_solid)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeMeshType:
+        return "HybridSolid3D"
+
+    def native_extension(self) -> str:
+        return self.hybrid_solid.native_extension()
+
+    def builder(self) -> og.HybridSolidBuilder3D:
+        return og.HybridSolidBuilder3D.create(self.hybrid_solid)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeHybridSolid3D:
+        return GeodeHybridSolid3D(og.load_hybrid_solid3D(filename))
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.hybrid_solid_additional_files3D(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og.is_hybrid_solid_loadable3D(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og.HybridSolidInputFactory3D.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og.HybridSolidOutputFactory3D.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og.hybrid_solid_object_priority3D(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og.is_hybrid_solid_saveable3D(self.hybrid_solid, filename)
+
+    def save(self, filename: str) -> list[str]:
+        return og.save_hybrid_solid3D(self.hybrid_solid, filename)
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_hybrid_solid3D(
+            self.hybrid_solid, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_hybrid_solid3D(
+            self.hybrid_solid, filename_without_extension
+        )

opengeodeweb_back/geode_objects/geode_implicit_cross_section.py

@@ -0,0 +1,81 @@
+# Standard library imports
+from __future__ import annotations
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+import geode_viewables as viewables
+
+# Local application imports
+from .types import GeodeModelType
+from .geode_cross_section import GeodeCrossSection
+
+
+class GeodeImplicitCrossSection(GeodeCrossSection):
+    implicit_cross_section: og_geosciences.ImplicitCrossSection
+
+    def __init__(
+        self, implicit_cross_section: og_geosciences.ImplicitCrossSection | None = None
+    ) -> None:
+        self.implicit_cross_section = (
+            implicit_cross_section
+            if implicit_cross_section is not None
+            else og_geosciences.ImplicitCrossSection()
+        )
+        super().__init__(self.implicit_cross_section)
+
+    @classmethod
+    def geode_object_type(cls) -> GeodeModelType:
+        return "ImplicitCrossSection"
+
+    def native_extension(self) -> str:
+        return self.implicit_cross_section.native_extension()
+
+    def builder(self) -> og_geosciences.ImplicitCrossSectionBuilder:
+        return og_geosciences.ImplicitCrossSectionBuilder(self.implicit_cross_section)
+
+    @classmethod
+    def load(cls, filename: str) -> GeodeImplicitCrossSection:
+        return GeodeImplicitCrossSection(
+            og_geosciences.load_implicit_cross_section(filename)
+        )
+
+    @classmethod
+    def additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og_geosciences.implicit_cross_section_additional_files(filename)
+
+    @classmethod
+    def is_loadable(cls, filename: str) -> og.Percentage:
+        return og_geosciences.is_implicit_cross_section_loadable(filename)
+
+    @classmethod
+    def input_extensions(cls) -> list[str]:
+        return og_geosciences.ImplicitCrossSectionInputFactory.list_creators()
+
+    @classmethod
+    def output_extensions(cls) -> list[str]:
+        return og_geosciences.ImplicitCrossSectionOutputFactory.list_creators()
+
+    @classmethod
+    def object_priority(cls, filename: str) -> int:
+        return og_geosciences.implicit_cross_section_object_priority(filename)
+
+    def is_saveable(self, filename: str) -> bool:
+        return og_geosciences.is_implicit_cross_section_saveable(
+            self.implicit_cross_section, filename
+        )
+
+    def save(self, filename: str) -> list[str]:
+        return og_geosciences.save_implicit_cross_section(
+            self.implicit_cross_section, filename
+        )
+
+    def save_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_viewable_implicit_cross_section(
+            self.implicit_cross_section, filename_without_extension
+        )
+
+    def save_light_viewable(self, filename_without_extension: str) -> str:
+        return viewables.save_light_viewable_implicit_cross_section(
+            self.implicit_cross_section, filename_without_extension
+        )