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

opengeodeweb_back/routes/create/blueprint_create.py

@@ -0,0 +1,121 @@
+# Standard library imports
+import os
+
+# Third party imports
+import flask
+import opengeode
+from opengeodeweb_microservice.schemas import get_schemas_dict
+
+# Local application imports
+from opengeodeweb_back import geode_functions, utils_functions
+from . import schemas
+from opengeodeweb_back.geode_objects.geode_point_set3d import GeodePointSet3D
+from opengeodeweb_back.geode_objects.geode_edged_curve3d import GeodeEdgedCurve3D
+
+routes = flask.Blueprint("create", __name__, url_prefix="/create")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+
+@routes.route(
+    schemas_dict["create_point"]["route"],
+    methods=schemas_dict["create_point"]["methods"],
+)
+def create_point() -> flask.Response:
+    """Endpoint to create a single point in 3D space."""
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["create_point"]
+    )
+    params = schemas.CreatePoint.from_dict(json_data)
+
+    # Create the point
+    pointset = GeodePointSet3D()
+    builder = pointset.builder()
+    builder.set_name(params.name)
+    builder.create_point(opengeode.Point3D([params.x, params.y, params.z]))
+
+    # Save and get info
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        pointset
+    )
+    return flask.make_response(result, 200)
+
+
+@routes.route(
+    schemas_dict["create_aoi"]["route"], methods=schemas_dict["create_aoi"]["methods"]
+)
+def create_aoi() -> flask.Response:
+    """Endpoint to create an Area of Interest (AOI) as an EdgedCurve3D."""
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["create_aoi"]
+    )
+    params = schemas.CreateAoi.from_dict(json_data)
+
+    # Create the edged curve
+    edged_curve = GeodeEdgedCurve3D()
+    builder = edged_curve.builder()
+    builder.set_name(params.name)
+
+    # Create vertices first
+    for point in params.points:
+        builder.create_point(opengeode.Point3D([point.x, point.y, params.z]))
+
+    # Create edges between consecutive vertices and close the loop
+    num_vertices = len(params.points)
+    for i in range(num_vertices):
+        next_i = (i + 1) % num_vertices
+        builder.create_edge_with_vertices(i, next_i)
+
+    # Save and get info
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        edged_curve
+    )
+    return flask.make_response(result, 200)
+
+
+@routes.route(
+    schemas_dict["create_voi"]["route"], methods=schemas_dict["create_voi"]["methods"]
+)
+def create_voi() -> flask.Response:
+    """Endpoint to create a Volume of Interest (VOI) as an EdgedCurve3D (a bounding box/prism)."""
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["create_voi"]
+    )
+    params = schemas.CreateVoi.from_dict(json_data)
+
+    aoi_data = geode_functions.get_data_info(params.aoi_id)
+    if not aoi_data:
+        flask.abort(404, f"AOI with id {params.aoi_id} not found")
+
+    aoi_object = geode_functions.load_geode_object(params.aoi_id)
+    if not isinstance(aoi_object, GeodeEdgedCurve3D):
+        flask.abort(400, f"AOI with id {params.aoi_id} is not a GeodeEdgedCurve3D")
+
+    aoi_curve = aoi_object.edged_curve
+    nb_points = aoi_curve.nb_vertices()
+
+    edged_curve = GeodeEdgedCurve3D()
+    builder = edged_curve.builder()
+    builder.set_name(params.name)
+
+    for point_id in range(nb_points):
+        aoi_point = aoi_curve.point(point_id)
+        builder.create_point(
+            opengeode.Point3D([aoi_point.value(0), aoi_point.value(1), params.z_min])
+        )
+
+    for point_id in range(nb_points):
+        aoi_point = aoi_curve.point(point_id)
+        builder.create_point(
+            opengeode.Point3D([aoi_point.value(0), aoi_point.value(1), params.z_max])
+        )
+
+    for point_id in range(nb_points):
+        next_point = (point_id + 1) % nb_points
+        builder.create_edge_with_vertices(point_id, next_point)
+        builder.create_edge_with_vertices(point_id + nb_points, next_point + nb_points)
+        builder.create_edge_with_vertices(point_id, point_id + nb_points)
+
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        edged_curve
+    )
+    return flask.make_response(result, 200)

opengeodeweb_back/routes/create/schemas/__init__.py

@@ -0,0 +1,3 @@
+from .create_voi import *
+from .create_point import *
+from .create_aoi import *

opengeodeweb_back/routes/create/schemas/create_aoi.json

@@ -0,0 +1,45 @@
+{
+    "route": "/create_aoi",
+    "methods": [
+        "POST"
+    ],
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "Name of the AOI"
+        },
+        "points": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "x": {
+                        "type": "number"
+                    },
+                    "y": {
+                        "type": "number"
+                    }
+                },
+                "required": [
+                    "x",
+                    "y"
+                ],
+                "additionalProperties": false
+            },
+            "minItems": 3
+        },
+        "z": {
+            "type": "number"
+        },
+        "id": {
+            "type": "string"
+        }
+    },
+    "required": [
+        "name",
+        "points",
+        "z"
+    ],
+    "additionalProperties": false
+}

opengeodeweb_back/routes/create/schemas/create_aoi.py

@@ -0,0 +1,25 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class Point(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    x: float
+    y: float
+
+
+@dataclass
+class CreateAoi(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    name: str
+    """Name of the AOI"""
+
+    points: List[Point]
+    z: float
+    id: Optional[str] = None

opengeodeweb_back/routes/create/schemas/create_point.json

@@ -0,0 +1,29 @@
+{
+    "route": "/create_point",
+    "methods": [
+        "POST"
+    ],
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "minLength": 1
+        },
+        "x": {
+            "type": "number"
+        },
+        "y": {
+            "type": "number"
+        },
+        "z": {
+            "type": "number"
+        }
+    },
+    "required": [
+        "name",
+        "x",
+        "y",
+        "z"
+    ],
+    "additionalProperties": false
+}

opengeodeweb_back/routes/create/schemas/create_point.py

@@ -0,0 +1,13 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class CreatePoint(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    name: str
+    x: float
+    y: float
+    z: float

opengeodeweb_back/routes/create/schemas/create_voi.json

@@ -0,0 +1,36 @@
+{
+    "route": "/create_voi",
+    "methods": [
+        "POST"
+    ],
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "Name of the VOI"
+        },
+        "aoi_id": {
+            "type": "string",
+            "description": "ID of the corresponding AOI"
+        },
+        "z_min": {
+            "type": "number",
+            "description": "Minimum Z coordinate"
+        },
+        "z_max": {
+            "type": "number",
+            "description": "Maximum Z coordinate"
+        },
+        "id": {
+            "type": "string",
+            "description": "Optional ID for updating existing VOI"
+        }
+    },
+    "required": [
+        "name",
+        "aoi_id",
+        "z_min",
+        "z_max"
+    ],
+    "additionalProperties": false
+}

opengeodeweb_back/routes/create/schemas/create_voi.py

@@ -0,0 +1,24 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class CreateVoi(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    aoi_id: str
+    """ID of the corresponding AOI"""
+
+    name: str
+    """Name of the VOI"""
+
+    z_max: float
+    """Maximum Z coordinate"""
+
+    z_min: float
+    """Minimum Z coordinate"""
+
+    id: Optional[str] = None
+    """Optional ID for updating existing VOI"""

opengeodeweb_back/routes/models/blueprint_models.py

@@ -1,29 +1,30 @@
-import json
 import os
 import xml.etree.ElementTree as ET
 import flask
-from ... import geode_functions, utils_functions
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
-routes = flask.Blueprint("models", __name__, url_prefix="/models")
-
-
-schemas = os.path.join(os.path.dirname(__file__), "schemas")
+from opengeodeweb_back import geode_functions, utils_functions
+from opengeodeweb_back.geode_objects.geode_model import GeodeModel
+from . import schemas
 
-with open(os.path.join(schemas, "vtm_component_indices.json"), "r") as file:
-    vtm_component_indices_json = json.load(file)
+routes = flask.Blueprint("models", __name__, url_prefix="/models")
+schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
 
 
 @routes.route(
-    vtm_component_indices_json["route"], methods=vtm_component_indices_json["methods"]
+    schemas_dict["vtm_component_indices"]["route"],
+    methods=schemas_dict["vtm_component_indices"]["methods"],
 )
-def uuid_to_flat_index():
-    utils_functions.validate_request(flask.request, vtm_component_indices_json)
-
-    vtm_file_path = geode_functions.data_file_path(
-        flask.request.get_json().get("id"), "viewable.vtm"
+def uuid_to_flat_index() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["vtm_component_indices"]
     )
+    params = schemas.VtmComponentIndices.from_dict(json_data)
+    vtm_file_path = geode_functions.data_file_path(params.id, "viewable.vtm")
     tree = ET.parse(vtm_file_path)
     root = tree.find("vtkMultiBlockDataSet")
+    if root is None:
+        flask.abort(500, "Failed to read viewable file")
     uuid_to_flat_index = {}
     current_index = 0
     for elem in root.iter():
@@ -33,22 +34,21 @@ def uuid_to_flat_index():
     return flask.make_response({"uuid_to_flat_index": uuid_to_flat_index}, 200)
 
 
-def extract_model_uuids(model):
+@routes.route(
+    schemas_dict["mesh_components"]["route"],
+    methods=schemas_dict["mesh_components"]["methods"],
+)
+def extract_uuids_endpoint() -> flask.Response:
+    json_data = utils_functions.validate_request(
+        flask.request, schemas_dict["mesh_components"]
+    )
+    params = schemas.MeshComponents.from_dict(json_data)
+    model = geode_functions.load_geode_object(params.id)
+    if not isinstance(model, GeodeModel):
+        flask.abort(400, f"{params.id} is not a GeodeModel")
     mesh_components = model.mesh_components()
     uuid_dict = {}
     for mesh_component, ids in mesh_components.items():
         component_name = mesh_component.get()
         uuid_dict[component_name] = [id.string() for id in ids]
-    return uuid_dict
-
-
-with open(os.path.join(schemas, "mesh_components.json"), "r") as file:
-    mesh_components_json = json.load(file)
-
-
-@routes.route(mesh_components_json["route"], methods=mesh_components_json["methods"])
-def extract_uuids_endpoint():
-    utils_functions.validate_request(flask.request, mesh_components_json)
-    model = geode_functions.load_data(flask.request.get_json().get("id"))
-    uuid_dict = extract_model_uuids(model)
     return flask.make_response({"uuid_dict": uuid_dict}, 200)

opengeodeweb_back/routes/models/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .vtm_component_indices import *
+from .mesh_components import *

opengeodeweb_back/routes/models/schemas/mesh_components.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class MeshComponents(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str

opengeodeweb_back/routes/models/schemas/vtm_component_indices.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class VtmComponentIndices(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str

opengeodeweb_back/routes/schemas/__init__.py

@@ -0,0 +1,17 @@
+from .vertex_attribute_names import *
+from .upload_file import *
+from .texture_coordinates import *
+from .save_viewable_file import *
+from .polyhedron_attribute_names import *
+from .polygon_attribute_names import *
+from .ping import *
+from .missing_files import *
+from .kill import *
+from .inspect_file import *
+from .import_project import *
+from .geographic_coordinate_systems import *
+from .geode_objects_and_output_extensions import *
+from .export_project import *
+from .cell_attribute_names import *
+from .allowed_objects import *
+from .allowed_files import *

opengeodeweb_back/routes/schemas/allowed_files.json

@@ -1,12 +1,10 @@
 {
   "route": "/allowed_files",
-  "methods": ["POST"],
+  "methods": [
+    "POST"
+  ],
   "type": "object",
-  "properties": {
-    "supported_feature": {
-      "type": ["string", "null"]
-    }
-  },
-  "required": ["supported_feature"],
+  "properties": {},
+  "required": [],
   "additionalProperties": false
-}
+}

opengeodeweb_back/routes/schemas/allowed_files.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class AllowedFiles(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    pass

opengeodeweb_back/routes/schemas/allowed_objects.json

@@ -8,17 +8,10 @@
     "filename": {
       "type": "string",
       "minLength": 1
-    },
-    "supported_feature": {
-      "type": [
-        "string",
-        "null"
-      ]
     }
   },
   "required": [
-    "filename",
-    "supported_feature"
+    "filename"
   ],
   "additionalProperties": false
 }

opengeodeweb_back/routes/schemas/allowed_objects.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class AllowedObjects(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    filename: str

opengeodeweb_back/routes/schemas/cell_attribute_names.json

@@ -0,0 +1,13 @@
+{
+  "route": "/cell_attribute_names",
+  "methods": ["POST"],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": ["id"],
+  "additionalProperties": false
+}

opengeodeweb_back/routes/schemas/cell_attribute_names.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class CellAttributeNames(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str

opengeodeweb_back/routes/schemas/export_project.json

@@ -0,0 +1,21 @@
+{
+  "route": "/export_project",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "snapshot": {
+      "type": "object"
+    },
+    "filename": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "snapshot",
+    "filename"
+  ],
+  "additionalProperties": false
+}

opengeodeweb_back/routes/schemas/export_project.py

@@ -0,0 +1,12 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Dict, Any
+
+
+@dataclass
+class ExportProject(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    filename: str
+    snapshot: Dict[str, Any]

opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.json

@@ -5,7 +5,7 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
+    "geode_object_type": {
       "type": "string",
       "minLength": 1
     },
@@ -15,7 +15,7 @@
     }
   },
   "required": [
-    "input_geode_object",
+    "geode_object_type",
     "filename"
   ],
   "additionalProperties": false

opengeodeweb_back/routes/schemas/geode_objects_and_output_extensions.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeodeObjectsAndOutputExtensions(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    filename: str
+    geode_object_type: str

opengeodeweb_back/routes/schemas/geographic_coordinate_systems.json

@@ -5,13 +5,13 @@
   ],
   "type": "object",
   "properties": {
-    "input_geode_object": {
+    "geode_object_type": {
       "type": "string",
       "minLength": 1
     }
   },
   "required": [
-    "input_geode_object"
+    "geode_object_type"
   ],
   "additionalProperties": false
 }

opengeodeweb_back/routes/schemas/geographic_coordinate_systems.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class GeographicCoordinateSystems(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    geode_object_type: str

opengeodeweb_back/routes/schemas/import_project.json

@@ -0,0 +1,10 @@
+{
+  "route": "/import_project",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {},
+  "required": [],
+  "additionalProperties": false
+}

opengeodeweb_back/routes/schemas/import_project.py

@@ -0,0 +1,10 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class ImportProject(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    pass

opengeodeweb_back/routes/schemas/inspect_file.json

@@ -9,14 +9,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
 }

opengeodeweb_back/routes/schemas/inspect_file.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class InspectFile(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    filename: str
+    geode_object_type: str