wip

Author: BotellaA

opengeodeweb_back_schemas.json

@@ -213,7 +213,7 @@
       ],
       "type": "object",
       "properties": {
-        "input_geode_object": {
+        "geode_object_type": {
           "type": "string",
           "minLength": 1
         },
@@ -223,7 +223,7 @@
         }
       },
       "required": [
-        "input_geode_object",
+        "geode_object_type",
         "filename"
       ],
       "additionalProperties": false
@@ -283,7 +283,7 @@
       ],
       "type": "object",
       "properties": {
-        "input_geode_object": {
+        "geode_object_type": {
           "type": "string",
           "minLength": 1
         },
@@ -293,7 +293,7 @@
         }
       },
       "required": [
-        "input_geode_object",
+        "geode_object_type",
         "filename"
       ],
       "additionalProperties": false
@@ -321,14 +321,14 @@
           "type": "string",
           "minLength": 1
         },
-        "input_geode_object": {
+        "geode_object_type": {
           "type": "string",
           "minLength": 1
         }
       },
       "required": [
         "filename",
-        "input_geode_object"
+        "geode_object_type"
       ],
       "additionalProperties": false
     },
@@ -351,13 +351,13 @@
       ],
       "type": "object",
       "properties": {
-        "input_geode_object": {
+        "geode_object_type": {
           "type": "string",
           "minLength": 1
         }
       },
       "required": [
-        "input_geode_object"
+        "geode_object_type"
       ],
       "additionalProperties": false
     },
@@ -369,7 +369,7 @@
       ],
       "type": "object",
       "properties": {
-        "input_geode_object": {
+        "geode_object_type": {
           "type": "string",
           "minLength": 1
         },
@@ -379,7 +379,7 @@
         }
       },
       "required": [
-        "input_geode_object",
+        "geode_object_type",
         "filename"
       ],
       "additionalProperties": false
@@ -417,17 +417,10 @@
         "filename": {
           "type": "string",
           "minLength": 1
-        },
-        "supported_feature": {
-          "type": [
-            "string",
-            "null"
-          ]
         }
       },
       "required": [
-        "filename",
-        "supported_feature"
+        "filename"
       ],
       "additionalProperties": false
     },
@@ -438,17 +431,8 @@
         "POST"
       ],
       "type": "object",
-      "properties": {
-        "supported_feature": {
-          "type": [
-            "string",
-            "null"
-          ]
-        }
-      },
-      "required": [
-        "supported_feature"
-      ],
+      "properties": {},
+      "required": [],
       "additionalProperties": false
     }
   }

src/opengeodeweb_back/geode_functions.py

@@ -9,8 +9,18 @@
 from typing import Any
 
 # Local application imports
-from .geode_objects import geode_objects
-from .geode_objects.geode_object import GeodeType, GeodeObject, to_geode_type
+from .geode_objects import geode_objects, geode_meshes, geode_models
+from .geode_objects.types import (
+    GeodeObjectType,
+    geode_object_type,
+    GeodeMeshType,
+    geode_mesh_type,
+    GeodeModelType,
+    geode_model_type,
+)
+from .geode_objects.geode_object import GeodeObject
+from .geode_objects.geode_mesh import GeodeMesh
+from .geode_objects.geode_model import GeodeModel
 from . import utils_functions
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.database.connection import get_session
@@ -24,24 +34,56 @@ def data_file_path(data_id: str, filename: str | None) -> str:
     return data_path
 
 
-def load_data(data_id: str) -> GeodeObject:
-    data_entry = Data.get(data_id)
-    if not data_entry:
+def geode_object_from_string(value: str) -> type[GeodeObject]:
+    return geode_objects[geode_object_type(value)]
+
+
+def geode_mesh_from_string(value: str) -> type[GeodeMesh]:
+    return geode_meshes[geode_mesh_type(value)]
+
+
+def geode_model_from_string(value: str) -> type[GeodeModel]:
+    return geode_models[geode_model_type(value)]
+
+
+def load_object_data(data_id: str) -> GeodeObject:
+    data = Data.get(data_id)
+    if not data:
+        flask.abort(404, f"Data with id {data_id} not found")
+
+    file_absolute_path = data_file_path(data_id, data.native_file_name)
+    print("Loading file: ", file_absolute_path)
+    print("File exists: ", os.path.exists(file_absolute_path))
+    return geode_object_from_string(data.geode_object).load(file_absolute_path)
+
+
+def load_mesh_data(data_id: str) -> GeodeMesh:
+    data = Data.get(data_id)
+    if not data:
+        flask.abort(404, f"Data with id {data_id} not found")
+
+    file_absolute_path = data_file_path(data_id, data.native_file_name)
+    print("Loading file: ", file_absolute_path)
+    print("File exists: ", os.path.exists(file_absolute_path))
+    return geode_mesh_from_string(data.geode_object).load_mesh(file_absolute_path)
+
+
+def load_model_data(data_id: str) -> GeodeModel:
+    data = Data.get(data_id)
+    if not data:
         flask.abort(404, f"Data with id {data_id} not found")
 
-    file_absolute_path = data_file_path(data_id, data_entry.native_file_name)
+    file_absolute_path = data_file_path(data_id, data.native_file_name)
     print("Loading file: ", file_absolute_path)
     print("File exists: ", os.path.exists(file_absolute_path))
-    return geode_objects[to_geode_type(data_entry.geode_object)].load(
-        file_absolute_path
-    )
+    return geode_model_from_string(data.geode_object).load_model(file_absolute_path)
 
 
 def get_data_info(data_id: str) -> Data:
-    data_entry = Data.get(data_id)
-    if not data_entry:
+    data = Data.get(data_id)
+    if not data:
         flask.abort(404, f"Data with id {data_id} not found")
-    return data_entry
+    return data
 
 
 def upload_file_path(filename: str) -> str:
@@ -52,9 +94,9 @@ def upload_file_path(filename: str) -> str:
 
 def geode_object_output_extensions(
     geode_object: GeodeObject,
-) -> dict[GeodeType, dict[str, bool]]:
-    results: dict[GeodeType, dict[str, bool]] = {}
-    for mixin_geode_object in geode_objects[geode_object.geode_type()].__mro__:
+) -> dict[GeodeObjectType, dict[str, bool]]:
+    results: dict[GeodeObjectType, dict[str, bool]] = {}
+    for mixin_geode_object in geode_objects[geode_object.geode_object_type()].__mro__:
         output_extensions_method = getattr(
             mixin_geode_object, "output_extensions", None
         )
@@ -70,23 +112,23 @@ def geode_object_output_extensions(
                 geode_object, f"test.{output_extension}"
             )
             object_output_extensions[output_extension] = bool_is_saveable
-        if hasattr(mixin_geode_object, "geode_type"):
-            results[mixin_geode_object.geode_type()] = object_output_extensions
+        if hasattr(mixin_geode_object, "geode_object_type"):
+            results[mixin_geode_object.geode_object_type()] = object_output_extensions
     return results
 
 
-# def assign_crs(geode_type: GeodeType, data, crs_name: str, info):
+# def assign_crs(geode_type: GeodeObjectType, data, crs_name: str, info):
 #     builder = create_builder(geode_object, data)
 #     geode_objects[geode_type].["crs"]["assign"](data, builder, crs_name, info)
 
 
-# def convert_crs(geode_type: GeodeType, data, crs_name: str, info):
+# def convert_crs(geode_type: GeodeObjectType, data, crs_name: str, info):
 #     builder = create_builder(geode_object, data)
 #     geode_objects[geode_type].["crs"]["convert"](data, builder, crs_name, info)
 
 
 # def create_crs(
-#     geode_type: GeodeType,
+#     geode_type: GeodeObjectType,
 #     data,
 #     name: str,
 #     input_coordiante_system,
@@ -98,7 +140,7 @@ def geode_object_output_extensions(
 #     )
 
 
-# def geographic_coordinate_systems_info(geode_type: GeodeType, crs):
+# def geographic_coordinate_systems_info(geode_type: GeodeObjectType, crs):
 #     if is_3D(geode_object):
 #         return og_gs.GeographicCoordinateSystemInfo3D(
 #             crs["authority"], crs["code"], crs["name"]
@@ -109,7 +151,7 @@ def geode_object_output_extensions(
 #         )
 
 
-# def coordinate_system(geode_type: GeodeType, coordinate_system):
+# def coordinate_system(geode_type: GeodeObjectType, coordinate_system):
 #     return og.CoordinateSystem2D(
 #         [
 #             og.Vector2D(
@@ -133,18 +175,18 @@ def geode_object_output_extensions(
 #     )
 
 
-# def assign_geographic_coordinate_system_info(geode_type: GeodeType, data, input_crs):
+# def assign_geographic_coordinate_system_info(geode_type: GeodeObjectType, data, input_crs):
 #     info = geographic_coordinate_systems_info(geode_object, input_crs)
 #     assign_crs(geode_object, data, input_crs["name"], info)
 
 
-# def convert_geographic_coordinate_system_info(geode_type: GeodeType, data, output_crs):
+# def convert_geographic_coordinate_system_info(geode_type: GeodeObjectType, data, output_crs):
 #     info = geographic_coordinate_systems_info(geode_object, output_crs)
 #     convert_crs(geode_object, data, output_crs["name"], info)
 
 
 # def create_coordinate_system(
-#     geode_type: GeodeType, data, name, input_coordinate_points, output_coordinate_points
+#     geode_type: GeodeObjectType, data, name, input_coordinate_points, output_coordinate_points
 # ):
 #     input_coordiante_system = coordinate_system(geode_object, input_coordinate_points)
 #     output_coordiante_system = coordinate_system(geode_object, output_coordinate_points)

src/opengeodeweb_back/geode_objects/__init__.py

@@ -12,11 +12,20 @@
 import geode_viewables as viewables
 
 # Local application imports
-from .geode_object import GeodeType, GeodeObject
+from .types import GeodeObjectType, GeodeMeshType, GeodeModelType
+from .geode_object import GeodeObject
+from .geode_model import GeodeModel
+from .geode_mesh import GeodeMesh
 from .geode_brep import GeodeBRep
 
 
-geode_objects: dict[GeodeType, type[GeodeObject]] = {"BRep": GeodeBRep}
+geode_meshes: dict[GeodeMeshType, type[GeodeMesh]] = {}
+geode_models: dict[GeodeModelType, type[GeodeModel]] = {"BRep": GeodeBRep}
+
+GeodeObjectsDict = dict[GeodeObjectType, type[GeodeObject]]
+geode_objects: GeodeObjectsDict = {}
+geode_objects.update(cast(GeodeObjectsDict, geode_meshes))
+geode_objects.update(cast(GeodeObjectsDict, geode_models))
 
 
 mesh = "mesh"

src/opengeodeweb_back/geode_objects/geode_brep.py

@@ -1,24 +1,27 @@
+# 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
 
-from .geode_object import GeodeObject, GeodeType, ViewerType
+# Local application imports
+from .types import GeodeModelType, ViewerType
+from .geode_model import GeodeModel, ComponentRegistry
 
 
-class GeodeBRep(GeodeObject):
+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_type(cls) -> GeodeType:
+    def geode_model_type(cls) -> GeodeModelType:
         return "BRep"
 
-    @classmethod
-    def viewer_type(cls) -> ViewerType:
-        return "model"
-
     def native_extension(self) -> str:
         return self.brep.native_extension()
 
@@ -34,7 +37,7 @@ def builder(self) -> og.BRepBuilder:
         return og.BRepBuilder(self.brep)
 
     @classmethod
-    def load(self, filename: str) -> "GeodeBRep":
+    def load_model(cls, filename: str) -> GeodeBRep:
         return GeodeBRep(og.load_brep(filename))
 
     @classmethod
@@ -68,3 +71,9 @@ def save_viewable(self, filename_without_extension: str) -> str:
 
     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)