feat(create): New feature : create Volume of Interest

Author: SpliiT

src/opengeodeweb_back/routes/create/blueprint_create.py

@@ -54,7 +54,7 @@ def create_aoi() -> flask.Response:
 
     # Create vertices first
     for point in params.points:
-        pp = opengeode.Point3D([point.x, point.y, params.z])
+        # pp = opengeode.Point3D([point.x, point.y, params.z])
         builder.create_point(opengeode.Point3D([point.x, point.y, params.z]))
 
     # Create edges between consecutive vertices and close the loop
@@ -69,3 +69,69 @@ def create_aoi() -> flask.Response:
         data=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)."""
+    print(f"create_voi : {flask.request=}", flush=True)
+    utils_functions.validate_request(flask.request, schemas_dict["create_voi"])
+    params = schemas.CreateVoi.from_dict(flask.request.get_json())
+    
+    # 1. Simuler la récupération des coordonnées (X, Y) de l'AOI
+    # ATTENTION : En l'absence de `utils_functions.get_data`, nous utilisons des
+    # points de simulation pour construire la VOI. L'ID de l'AOI (params.aoi_id) est ignoré.
+    aoi_vertices = [
+        (0.0, 0.0),
+        (10.0, 0.0),
+        (10.0, 10.0),
+        (0.0, 10.0),
+    ]
+
+    # 2. Créer le VOI (EdgedCurve3D)
+    edged_curve = geode_functions.geode_object_class("EdgedCurve3D").create()
+    builder = geode_functions.create_builder("EdgedCurve3D", edged_curve)
+    builder.set_name(params.name)
+    
+    z_min = params.z_min
+    z_max = params.z_max
+
+    # 3. Créer les 8 vertices de la boîte (VOI)
+    # Indices 0-3 (face inférieure Z_min), Indices 4-7 (face supérieure Z_max)
+    
+    # Bottom face (Z_min) indices 0, 1, 2, 3
+    for x, y in aoi_vertices:
+        builder.create_point(opengeode.Point3D([x, y, z_min]))
+    
+    # Top face (Z_max) indices 4, 5, 6, 7
+    for x, y in aoi_vertices:
+        builder.create_point(opengeode.Point3D([x, y, z_max]))
+
+    # 4. Créer les 12 arêtes
+    
+    # Arêtes de la face inférieure: 0-1, 1-2, 2-3, 3-0
+    bottom_edges = [(i, (i + 1) % 4) for i in range(4)]
+    
+    # Arêtes de la face supérieure: 4-5, 5-6, 6-7, 7-4
+    top_edges = [(i + 4, (i + 1) % 4 + 4) for i in range(4)]
+    
+    # Arêtes verticales: 0-4, 1-5, 2-6, 3-7
+    vertical_edges = [(i, i + 4) for i in range(4)]
+    
+    all_edges = bottom_edges + top_edges + vertical_edges
+    
+    for v1, v2 in all_edges:
+        builder.create_edge_with_vertices(v1, v2)
+
+    # 5. Sauvegarder et obtenir les informations
+    # Utilise generate_native_viewable... car update_native_viewable... n'est pas disponible.
+    # L'ID optionnel (params.id) est donc ignoré, et une NOUVELLE entrée Data est créée.
+    result = utils_functions.generate_native_viewable_and_light_viewable_from_object(
+        geode_object="EdgedCurve3D",
+        data=edged_curve,
+    )
+
+    # Retourne l'ID de la nouvelle entrée Data créée
+    return flask.make_response(result, 200)

src/opengeodeweb_back/routes/create/schemas/__init__.py

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

src/opengeodeweb_back/routes/create/schemas/create_voi.json

@@ -0,0 +1,35 @@
+{
+    "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 from which to take X and Y coordinates"
+        },
+        "z_min": {
+            "type": "number",
+            "description": "Minimum Z coordinate for the VOI"
+        },
+        "z_max": {
+            "type": "number",
+            "description": "Maximum Z coordinate for the VOI"
+        },
+        "id": {
+            "type": "string"
+        }
+    },
+    "required": [
+        "name",
+        "aoi_id",
+        "z_min",
+        "z_max"
+    ],
+    "additionalProperties": false
+}

src/opengeodeweb_back/routes/create/schemas/create_voi.py

@@ -0,0 +1,20 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class CreateVoi(DataClassJsonMixin):
+    name: str
+    """Name of the VOI"""
+
+    aoi_id: str
+    """ID of the corresponding AOI from which to take X and Y coordinates"""
+
+    z_min: float
+    """Minimum Z coordinate for the VOI"""
+
+    z_max: float
+    """Maximum Z coordinate for the VOI"""
+
+    id: Optional[str] = None

tests/test_create_routes.py

@@ -29,6 +29,17 @@ def aoi_data() -> Dict[str, Any]:
         "z": 0.0,
     }
 
+@pytest.fixture
+def voi_data() -> Dict[str, Any]:
+    """Fixture for Volume of Interest (VOI) test data."""
+    return {
+        "name": "test_voi",
+        "aoi_id": str(uuid.uuid4()), 
+        "z_min": -50.0,
+        "z_max": 100.0,
+        "id": str(uuid.uuid4()), 
+    }
+
 
 def test_create_point(client: FlaskClient, point_data: Dict[str, Any]) -> None:
     """Test the creation of a point with valid data."""
@@ -80,6 +91,33 @@ def test_create_aoi(client: FlaskClient, aoi_data: Dict[str, Any]) -> None:
     test_utils.test_route_wrong_params(client, route, lambda: aoi_data.copy())  # type: ignore
 
 
+def test_create_voi(client: FlaskClient, voi_data: Dict[str, Any]) -> None:
+    """Test the creation of a VOI with valid data (including optional id)."""
+    route: str = "/opengeodeweb_back/create/create_voi"
+
+    response = client.post(route, json=voi_data)
+    assert response.status_code == 200
+
+    response_data: Any = response.json
+    assert "id" in response_data
+    assert "name" in response_data
+    assert response_data["name"] == voi_data["name"]
+    assert response_data["object_type"] == "mesh"
+    assert response_data["geode_object"] == "EdgedCurve3D"
+
+    voi_data_no_id = voi_data.copy()
+    del voi_data_no_id["id"]
+    response = client.post(route, json=voi_data_no_id)
+    assert response.status_code == 200
+    assert response.json["name"] == voi_data["name"]
+
+    voi_data_required_only = voi_data.copy()
+    del voi_data_required_only["id"]
+    
+    test_utils.test_route_wrong_params(client, route, lambda: voi_data_required_only.copy()) # type: ignore
+
+
+
 def test_create_point_with_invalid_data(client: FlaskClient) -> None:
     """Test the point creation endpoint with invalid data."""
     route: str = "/opengeodeweb_back/create/create_point"
@@ -130,6 +168,28 @@ def test_create_aoi_with_invalid_data(
     assert response.status_code == 400
 
 
+def test_create_voi_with_invalid_data(
+    client: FlaskClient, voi_data: Dict[str, Any]
+) -> None:
+    """Test the VOI creation endpoint with invalid data."""
+    route: str = "/opengeodeweb_back/create/create_voi"
+
+    # Test with non-numeric z_min
+    invalid_data: Dict[str, Any] = {**voi_data, "z_min": "not_a_number"}
+    response = client.post(route, json=invalid_data)
+    assert response.status_code == 400
+
+    # Test with non-numeric z_max
+    invalid_data = {**voi_data, "z_max": "not_a_number"}
+    response = client.post(route, json=invalid_data)
+    assert response.status_code == 400
+    
+    # Test with invalid aoi_id format (e.g., not a string/uuid)
+    invalid_data = {**voi_data, "aoi_id": 12345}
+    response = client.post(route, json=invalid_data)
+    assert response.status_code == 400
+
+
 def test_create_point_file_generation(
     client: FlaskClient, point_data: Dict[str, Any]
 ) -> None:
@@ -208,3 +268,43 @@ def test_create_aoi_file_generation(
     # Verify file extensions
     assert response_data["native_file_name"].endswith(".og_edc3d")
     assert response_data["viewable_file_name"].endswith(".vtp")
+
+
+def test_create_voi_file_generation(
+    client: FlaskClient, voi_data: Dict[str, Any]
+) -> None:
+    """Test that the VOI creation generates the correct files."""
+    route: str = "/opengeodeweb_back/create/create_voi"
+
+    # Make the request
+    response = client.post(route, json=voi_data)
+    assert response.status_code == 200
+    response_data: Any = response.json
+
+    # Get the data folder path for this specific ID
+    DATA_FOLDER_PATH: str = client.application.config["DATA_FOLDER_PATH"]
+    data_id: str = response_data["id"]
+    data_folder: str = os.path.join(DATA_FOLDER_PATH, data_id)
+
+    # Check that the data folder exists
+    assert os.path.exists(data_folder)
+    assert os.path.isdir(data_folder)
+
+    # Check native file exists
+    native_file_path: str = os.path.join(data_folder, response_data["native_file_name"])
+    assert os.path.exists(native_file_path)
+
+    # Check viewable file exists
+    viewable_file_path: str = os.path.join(
+        data_folder, response_data["viewable_file_name"]
+    )
+    assert os.path.exists(viewable_file_path)
+
+    # Check light viewable file exists if present
+    if "binary_light_viewable" in response_data:
+        light_viewable_file_path: str = os.path.join(data_folder, "light_viewable.vtp")
+        assert os.path.exists(light_viewable_file_path)
+
+    # Verify file extensions (VOI uses EdgedCurve3D like AOI)
+    assert response_data["native_file_name"].endswith(".og_edc3d")
+    assert response_data["viewable_file_name"].endswith(".vtp")