viewer: remove Plotter dependency to the box engine

Author: lucas-givord

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

@@ -22,32 +22,35 @@ def __init__( self, mesh: pv.UnstructuredGrid, box: Box ) -> None:
         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._extracted_cells: pv.UnstructuredGrid = None
+        self._extracted_cells_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.
+    def get_box_polydata( self ) -> pv.PolyData | None:
+        """Get the box polydata."""
+        return self._box_polydata
 
-        The box is represented as a polydata with a low opacity.
-        """
-        self._box_polydata_actor = plotter.add_mesh( self._box_polydata, opacity=0.2 )
+    def get_box_polydata_actor( self ) -> pv.Actor:
+        """Get the actor generated by a pv.Plotter for the box polydata."""
+        return self._box_polydata_actor
 
-        if self._extracted_cell is not None:
-            self._extracted_cell_actor = plotter.add_mesh( self._extracted_cell, show_edges=True )
+    def get_extracted_cells( self ) -> pv.UnstructuredGrid | None:
+        """Get the extracted cell polydata."""
+        return self._extracted_cells
 
-    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 )
+    def get_extracted_cells_actor( self ) -> pv.Actor | None:
+        """Get the extracted cell polydata actor."""
+        return self._extracted_cells_actor
 
-        if self._extracted_cell_actor is not None:
-            plotter.remove_actor( self._extracted_cell_actor )
+    def set_box_polydata_actor( self, box_actor: pv.Actor ) -> None:
+        """Set the actor generated by a pv.Plotter for the box polydata."""
+        self._box_polydata_actor = box_actor
 
-        self._box_polydata = None
-        self._extracted_cell = None
+    def set_extracted_cells_actor( self, extracted_cell: pv.Actor ) -> None:
+        """Set the actor generated by a pv.Plotter for the extracted cell."""
+        self._extracted_cells_actor = extracted_cell
 
     def _compute_box_as_polydata( self ) -> None:
         """Create a polydata reresenting a BBox using pyvista and coordinates from the Geos Box."""
@@ -95,7 +98,7 @@ def _compute_intersected_cell( self ) -> None:
                 saved_ids.append( id )
 
         if len( saved_ids ) > 0:
-            self._extracted_cell = self._mesh.extract_cells( saved_ids )
+            self._extracted_cells = 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.

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

@@ -36,6 +36,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).
@@ -124,7 +125,7 @@ def rendering_menu_extra_items( self ) -> None:
     def update_viewer( self, active_block: BaseModel, path: str, show_obj: bool ) -> None:
         """Add from path the dataset given by the user.
 
-        Supported data type is: Vtkwell, Vtkmesh, InternalWell, Perforation.
+        Supported data type is: Vtkwell, Vtkmesh, InternalWell, Perforation, Box.
 
         object_state  : array used to store path to the data and if we want to show it or not.
         """
@@ -141,24 +142,10 @@ def update_viewer( self, active_block: BaseModel, path: str, show_obj: bool ) ->
             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
+            self._update_box( active_block, show_obj )
 
-            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 )
-
-        # make sure that added data in the plot will be rendered with the correct scalar array/lut
+        # when data is added in the pv.Plotter, we need to refresh the scene to update
+        # the actor to avoid LUT issue.
         self.plotter.update()
 
     def _on_clip_visibility_change( self, **kwargs: Any ) -> None:
@@ -353,6 +340,36 @@ def _add_perforation( self, distance_from_head: float, path: str ) -> None:
         cell_id = self.region_engine.input.find_closest_cell( point_offsetted )
         cell = self.region_engine.input.extract_cells( [ cell_id ] )
         cell_actor = self.plotter.add_mesh( cell )
-        saved_perforation.add_extracted_cell( cell_actor )
+        saved_perforation.add_extracted_cells( cell_actor )
 
         self._perforations[ path ] = saved_perforation
+
+    def _update_box( self, active_block: Box, show_obj: bool ) -> None:
+        """Generate and display a Box and inner cell(s) from the mesh."""
+        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:
+            box_polydata_actor: pv.Actor = self.box_engine.get_box_polydata_actor()
+            extracted_cell_actor: pv.Actor = self.box_engine.get_extracted_cells_actor()
+            self.plotter.remove_actor( box_polydata_actor )
+            self.plotter.remove_actor( extracted_cell_actor )
+
+        if not show_obj:
+            return
+
+        box: Box = active_block
+        self.box_engine = BoxViewer( self.region_engine.input, box )
+
+        box_polydata: pv.PolyData = self.box_engine.get_box_polydata()
+        extracted_cell: pv.UnstructuredGrid = self.box_engine.get_extracted_cells()
+
+        if box_polydata is not None and extracted_cell is not None:
+            _box_polydata_actor = self.plotter.add_mesh( box_polydata, opacity=0.2 )
+            _extracted_cells_actor = self.plotter.add_mesh( extracted_cell, show_edges=True )
+            self.box_engine.set_box_polydata_actor( _box_polydata_actor )
+            self.box_engine.set_extracted_cells_actor( _extracted_cells_actor )

geos-trame/tests/test_box_intersection.py

@@ -27,7 +27,7 @@ def test_box_intersection( trame_server_layout: tuple[ Server, VAppLayout ] ) ->
     app.deckInspector.state.flush()
 
     box = app.deckViewer.box_engine._box
-    cells = app.deckViewer.box_engine._extracted_cell
+    cells = app.deckViewer.box_engine._extracted_cells
 
     assert box is not None
     assert box.x_min == '{ 3509, 4117, -596 }'