wip

Author: BotellaA

src/opengeodeweb_back/geode_objects/__init__.py

@@ -3,11 +3,12 @@
 
 # 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 .types import GeodeModelType
 from .geode_model import GeodeModel, ComponentRegistry
 
 
@@ -77,3 +78,25 @@ def mesh_components(self) -> ComponentRegistry:
 
     def inspect(self) -> og_inspector.BRepInspectionResult:
         return og_inspector.inspect_brep(self.brep)
+
+    # def assign_crs(
+    #     self, crs_name: str, info: og_geosciences.GeographicCoordinateSystemInfo3D
+    # ) -> 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.GeographicCoordinateSystemInfo3D
+    # ) -> 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)

src/opengeodeweb_back/geode_objects/geode_brep.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_model_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_model(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
+        )

src/opengeodeweb_back/geode_objects/geode_cross_section.py

@@ -0,0 +1,80 @@
+# 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_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()
+        super().__init__(self.edged_curve)
+
+    @classmethod
+    def geode_mesh_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 False
+
+    def builder(self) -> og.EdgedCurveBuilder2D:
+        return og.EdgedCurveBuilder2D(self.edged_curve)
+
+    @classmethod
+    def load_mesh(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)

src/opengeodeweb_back/geode_objects/geode_edged_curve2d.py

@@ -0,0 +1,80 @@
+# 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_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()
+        super().__init__(self.edged_curve)
+
+    @classmethod
+    def geode_mesh_type(cls) -> GeodeMeshType:
+        return "EdgedCurve3D"
+
+    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 False
+
+    def builder(self) -> og.EdgedCurveBuilder3D:
+        return og.EdgedCurveBuilder3D(self.edged_curve)
+
+    @classmethod
+    def load_mesh(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)

src/opengeodeweb_back/geode_objects/geode_edged_curve3d.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()
+        super().__init__(self.graph)
+
+    @classmethod
+    def geode_mesh_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(self.graph)
+
+    @classmethod
+    def load_mesh(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