feat(viewer): add support for intersected cell from Box

Author: lucas-givord

geos-trame/geos_trame/app/data_types/renderable.py

@@ -6,6 +6,7 @@
 
 class Renderable( Enum ):
     """Enum class for renderable types and their ids."""
+    BOX = "Box"
     VTKMESH = "VTKMesh"
     INTERNALMESH = "InternalMesh"
     INTERNALWELL = "InternalWell"

geos-trame/geos_trame/app/ui/viewer/boxViewer.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
+# SPDX-FileContributor: Lucas Givord - Kitware
+import pyvista as pv
+
+from geos_trame.schema_generated.schema_mod import Box
+
+import re
+
+
+class BoxViewer:
+    """A BoxViewer represents a Box and its intersected cell in a mesh.
+
+    This mesh is represented in GEOS with a Box.
+    """
+
+    def __init__( self, mesh: pv.UnstructuredGrid, box: Box ) -> None:
+        """Initialize the BoxViewer with a mesh and a box."""
+        self._mesh: pv.UnstructuredGrid = mesh
+
+        self._box: Box = box
+        self._box_polydata: pv.PolyData = None
+        self._box_polydata_actor: pv.Actor = None
+
+        self._extracted_cell: pv.UnstructuredGrid = None
+        self._extracted_cell_actor: pv.Actor = None
+
+        self._compute_box_as_polydata()
+        self._compute_intersected_cell()
+
+    def append_to_plotter( self, plotter: pv.Plotter ) -> None:
+        """Append the box and the intersected cell to the plotter.
+
+        The box is represented as a polydata with a low opacity.
+        """
+        self._box_polydata_actor = plotter.add_mesh( self._box_polydata, opacity=0.2 )
+
+        if self._extracted_cell is not None:
+            self._extracted_cell_actor = plotter.add_mesh( self._extracted_cell, show_edges=True )
+
+    def reset( self, plotter: pv.Plotter ) -> None:
+        """Reset the box viewer by removing the box and the intersected cell from the plotter."""
+        if self._box_polydata_actor is not None:
+            plotter.remove_actor( self._box_polydata_actor )
+
+        if self._extracted_cell_actor is not None:
+            plotter.remove_actor( self._extracted_cell_actor )
+
+        self._box_polydata = None
+        self._extracted_cell = None
+
+    def _compute_box_as_polydata( self ) -> None:
+        """Create a polydata reresenting a BBox using pyvista and coordinates from the Geos Box."""
+        bounding_box: list[ float ] = self._retrieve_bounding_box()
+        self._box_polydata = pv.Box( bounds=bounding_box )
+
+    def _retrieve_bounding_box( self ) -> list[ float ]:
+        """This method converts bounding box information from Box into a list of coordinates readable by pyvista.
+
+        e.g., this Box:
+
+        <Box name="box_1"
+             xMin="{ 1150, 700, 62 }"
+             xMax="{ 1250, 800, 137 }"/>
+
+        will return [1150, 1250, 700, 800, 62, 137].
+        """
+        # split str and remove brackets
+        min_point_str = re.findall( r"-?\d+\.\d+|-?\d+", self._box.x_min )
+        max_point_str = re.findall( r"-?\d+\.\d+|-?\d+", self._box.x_max )
+
+        min_point = list( map( float, min_point_str ) )
+        max_point = list( map( float, max_point_str ) )
+
+        return [
+            min_point[ 0 ],
+            max_point[ 0 ],
+            min_point[ 1 ],
+            max_point[ 1 ],
+            min_point[ 2 ],
+            max_point[ 2 ],
+        ]
+
+    def _compute_intersected_cell( self ) -> None:
+        """Extract the cells from the mesh that are inside the box."""
+        ids = self._mesh.find_cells_within_bounds( self._box_polydata.bounds )
+
+        saved_ids: list[ int ] = []
+
+        for id in ids:
+            cell: pv.vtkCell = self._mesh.GetCell( id )
+
+            is_inside = self._check_cell_inside_box( cell, self._box_polydata.bounds )
+            if is_inside:
+                saved_ids.append( id )
+
+        if len( saved_ids ) > 0:
+            self._extracted_cell = self._mesh.extract_cells( saved_ids )
+
+    def _check_cell_inside_box( self, cell: pv.Cell, box_bounds: list[ float ] ) -> bool:
+        """Check if the cell is inside the box bounds.
+
+        A cell is considered inside the box if his bounds are completely
+        inside the box bounds.
+        """
+        cell_bounds = cell.GetBounds()
+        is_inside_in_x = cell_bounds[ 0 ] >= box_bounds[ 0 ] and cell_bounds[ 1 ] <= box_bounds[ 1 ]
+        is_inside_in_y = cell_bounds[ 2 ] >= box_bounds[ 2 ] and cell_bounds[ 3 ] <= box_bounds[ 3 ]
+        is_inside_in_z = cell_bounds[ 4 ] >= box_bounds[ 4 ] and cell_bounds[ 5 ] <= box_bounds[ 5 ]
+
+        return is_inside_in_x and is_inside_in_y and is_inside_in_z

geos-trame/geos_trame/app/ui/viewer/viewer.py

@@ -11,10 +11,12 @@
 from vtkmodules.vtkRenderingCore import vtkActor
 
 from geos_trame.app.deck.tree import DeckTree
+from geos_trame.app.ui.viewer.boxViewer import BoxViewer
 from geos_trame.app.ui.viewer.perforationViewer import PerforationViewer
 from geos_trame.app.ui.viewer.regionViewer import RegionViewer
 from geos_trame.app.ui.viewer.wellViewer import WellViewer
 from geos_trame.schema_generated.schema_mod import (
+    Box,
     Vtkmesh,
     Vtkwell,
     Perforation,
@@ -40,6 +42,7 @@ def __init__(
          - Vtkwell,
          - Perforation,
          - InternalWell
+         - Box
 
         Everything is handle in the method 'update_viewer()' which is trigger when the
         'state.object_state' changed (see DeckTree).
@@ -57,6 +60,7 @@ def __init__(
         self.server.state[ self.CUT_PLANE ] = True
         self.server.state[ self.ZAMPLIFICATION ] = 1
 
+        self.box_engine: BoxViewer | None = None
         self.region_engine = region_viewer
         self.well_engine = well_viewer
         self._perforations: dict[ str, PerforationViewer ] = {}
@@ -123,6 +127,24 @@ def update_viewer( self, active_block: BaseModel, path: str, show_obj: bool ) ->
         if isinstance( active_block, Perforation ):
             self._update_perforation( active_block, show_obj, path )
 
+        if isinstance( active_block, Box ):
+            if self.region_engine.input.number_of_cells == 0 and show_obj:
+                self.ctrl.on_add_warning(
+                    "Can't display " + active_block.name,
+                    "Please display the mesh before creating a well",
+                )
+                return
+
+            if self.box_engine is not None:
+                self.box_engine.reset( self.plotter )
+
+            if not show_obj:
+                return
+
+            box: Box = active_block
+            self.box_engine = BoxViewer( self.region_engine.input, box )
+            self.box_engine.append_to_plotter( self.plotter )
+
     def _on_clip_visibility_change( self, **kwargs: Any ) -> None:
         """Toggle cut plane visibility for all actors.
 

geos-trame/tests/data/geosDeck/geosDeck.xml

@@ -127,8 +127,8 @@
     <Geometry>
         <Box
         name="box_1"
-        xMin="{ 1150, 700, 62 }"
-        xMax="{ 1250, 800, 137 }"/>
+        xMin="{ 3509, 4117, -596 }"
+        xMax="{ 4482, 5041, -500 }"/>
     </Geometry>
     <!-- End Block to comment to deactivate box definition -->
 

geos-trame/tests/test_box_intersection.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
+# SPDX-FileContributor: Kitware
+# ruff: noqa
+from pathlib import Path
+
+from trame_server import Server
+from trame_server.state import State
+from trame_vuetify.ui.vuetify3 import VAppLayout
+
+from geos_trame.app.core import GeosTrame
+from tests.trame_fixtures import trame_state, trame_server_layout
+
+
+def test_box_intersection( trame_server_layout: tuple[ Server, VAppLayout ] ) -> None:
+    """Test box intersection."""
+    root_path = Path( __file__ ).parent.absolute().__str__()
+    file_name = root_path + "/data/geosDeck/geosDeck.xml"
+
+    app = GeosTrame( trame_server_layout[ 0 ], file_name )
+    app.state.ready()
+
+    app.deckInspector.state.object_state = [ "Problem/Mesh/0/VTKMesh/0", True ]
+    app.deckInspector.state.flush()
+
+    app.deckInspector.state.object_state = [ "Problem/Geometry/0/Box/0", True ]
+    app.deckInspector.state.flush()
+
+    box = app.deckViewer.box_engine._box
+    cells = app.deckViewer.box_engine._extracted_cell
+
+    assert box is not None
+    assert box.x_min == '{ 3509, 4117, -596 }'
+    assert box.x_max == '{ 4482, 5041, -500 }'
+    assert cells is not None
+    assert cells.number_of_cells == 1