vtkHardwarePicker instead of vtkCellPicker

Author: MaxNumerique

src/opengeodeweb_viewer/object/object_methods.py

@@ -9,14 +9,11 @@
     vtkActor,
     vtkTexture,
     vtkCompositePolyDataMapper,
-    vtkCompositeDataDisplayAttributes,
     vtkDataSetMapper,
 )
 from vtkmodules.vtkCommonDataModel import (
     vtkDataSet,
-    vtkMultiBlockDataSet,
 )
-from vtkmodules.vtkFiltersExtraction import vtkExtractSelection
 
 # Local application imports
 from opengeodeweb_viewer.vtk_protocol import VtkView, VtkPipeline
@@ -133,27 +130,6 @@ def SetPointsColor(
             actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
 
-    def _prune_hidden_blocks(
-        self,
-        dataset: vtkMultiBlockDataSet,
-        visibility_attributes: vtkCompositeDataDisplayAttributes,
-    ) -> vtkMultiBlockDataSet:
-        pruned = vtkMultiBlockDataSet()
-        pruned.SetNumberOfBlocks(dataset.GetNumberOfBlocks())
-        for index in range(dataset.GetNumberOfBlocks()):
-            block = dataset.GetBlock(index)
-            if block is None:
-                continue
-            if not visibility_attributes.GetBlockVisibility(block):
-                continue
-            if isinstance(block, vtkMultiBlockDataSet):
-                pruned.SetBlock(
-                    index, self._prune_hidden_blocks(block, visibility_attributes)
-                )
-            else:
-                pruned.SetBlock(index, block)
-        return pruned
-
     def SetBlocksVisibility(
         self, data_id: str, block_ids: list[int], visibility: bool
     ) -> None:
@@ -165,18 +141,6 @@ def SetBlocksVisibility(
         visibility_attributes = mapper.GetCompositeDataDisplayAttributes()
         for block_id in block_ids:
             visibility_attributes.SetBlockVisibility(blocks[block_id], visibility)
-        dataset = (
-            pipeline.filter.GetOutputDataObject(0)
-            if pipeline.filter
-            else pipeline.reader.GetOutputDataObject(0)
-        )
-        if not isinstance(dataset, vtkMultiBlockDataSet):
-            return
-        if pipeline.pick_mapper is None:
-            pipeline.pick_mapper = vtkCompositePolyDataMapper()
-        pipeline.pick_mapper.SetInputDataObject(
-            self._prune_hidden_blocks(dataset, visibility_attributes)
-        )
 
     def SetBlocksColor(
         self,

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -13,7 +13,7 @@
     vtkRenderWindowInteractor,
     vtkAbstractMapper,
     vtkWorldPointPicker,
-    vtkCellPicker,
+    vtkHardwarePicker,
     vtkPropPicker,
     vtkDataSetMapper,
     vtkActor,
@@ -261,7 +261,8 @@ def pickedIds(self, rpc_params: RpcParams) -> dict[str, list[str] | int | None]:
             rpc_params, self.viewer_schemas_dict["picked_ids"], self.viewer_prefix
         )
         params = schemas.PickedIDS.from_dict(rpc_params)
-        picker = vtkCellPicker(tolerance=0.005)
+        picker = vtkHardwarePicker()
+        picker.SetPixelTolerance(15)
         actors, flat_index = self.pick_actors_under_coordinate(
             params.ids, params.x, params.y, picker
         )
@@ -273,13 +274,6 @@ def pickedIds(self, rpc_params: RpcParams) -> dict[str, list[str] | int | None]:
         if not array_ids:
             return {"array_ids": [], "viewer_id": None}
         viewer_id = flat_index if flat_index != -1 else None
-        if viewer_id is not None:
-            pipeline = self.get_vtk_pipeline(array_ids[0])
-            dataset, geode_id, is_visible = self.get_composite_block_info(
-                pipeline, picker
-            )
-            if not is_visible:
-                return {"array_ids": [], "viewer_id": None}
         return {
             "array_ids": array_ids,
             "viewer_id": viewer_id,
@@ -338,18 +332,16 @@ def setHighlight(
         )
         params = schemas.Highlight.from_dict(rpc_params)
         self.clear_highlights(params.ids)
-        picker = vtkCellPicker(tolerance=0.005)
+        picker = vtkHardwarePicker()
+        picker.SetPixelTolerance(15)
         data_id, id_to_select = self.pick_cell_or_point(
             params.ids, params.x, params.y, params.field_type.value, picker
         )
         if not data_id or id_to_select == -1:
             self.render(-1)
             return {}
         pipeline = self.get_vtk_pipeline(data_id)
-        dataset, geode_id, is_visible = self.get_composite_block_info(pipeline, picker)
-        if not is_visible:
-            self.render(-1)
-            return {}
+        dataset, geode_id = self.get_composite_block_info(pipeline, picker)
         self.update_highlight(pipeline, id_to_select, params.field_type.value, dataset)
         self.render(-1)
         data_attributes = self.extract_picked_attributes(

src/opengeodeweb_viewer/vtk_protocol.py

@@ -19,7 +19,7 @@
     vtkRenderWindow,
     vtkDataSetMapper,
     vtkCompositePolyDataMapper,
-    vtkCellPicker,
+    vtkHardwarePicker,
 )
 from vtkmodules.vtkCommonDataModel import (
     vtkDataObject,
@@ -79,7 +79,6 @@ class VtkPipeline:
     blockGeodeIds: list[str] = field(default_factory=list)
     scalarBar: vtkScalarBarActor = field(default_factory=vtkScalarBarActor)
     block_styles: dict[int, BlockStyle] = field(default_factory=dict)
-    pick_mapper: vtkMapper | None = None
 
 
 class VtkTypingMixin:
@@ -196,26 +195,16 @@ def clear_highlights(self, data_ids: list[str]) -> None:
             pipeline = self.get_vtk_pipeline(data_id)
             pipeline.highlight.actor.VisibilityOff()
 
-    def swap_pick_mappers(self, data_ids: list[str], use_pick_mapper: bool) -> None:
-        for data_id in data_ids:
-            pipeline = self.get_vtk_pipeline(data_id)
-            if pipeline.pick_mapper:
-                mapper = pipeline.pick_mapper if use_pick_mapper else pipeline.mapper
-                pipeline.actor.SetMapper(mapper)
-
     def pick_cell_or_point(
         self,
         data_ids: list[str],
         x: float,
         y: float,
         field_type: str,
-        picker: vtkCellPicker,
+        picker: vtkHardwarePicker,
     ) -> tuple[str | None, int]:
-        self.swap_pick_mappers(data_ids, use_pick_mapper=True)
-        try:
-            picker.Pick(x, y, 0, self.get_renderer())
-        finally:
-            self.swap_pick_mappers(data_ids, use_pick_mapper=False)
+        picker.SetSnapToMeshPoint(field_type == "POINT")
+        picker.Pick(x, y, 0, self.get_renderer())
         actor = picker.GetActor()
         data_id = next(
             (
@@ -231,10 +220,9 @@ def pick_cell_or_point(
         return data_id, id_to_select
 
     def pick_actors_under_coordinate(
-        self, data_ids: list[str], x: float, y: float, picker: vtkCellPicker
+        self, data_ids: list[str], x: float, y: float, picker: vtkHardwarePicker
     ) -> tuple[list[vtkActor], int]:
         renderer = self.get_renderer()
-        self.swap_pick_mappers(data_ids, use_pick_mapper=True)
         actors = []
         viewer_id = -1
         try:
@@ -247,28 +235,23 @@ def pick_actors_under_coordinate(
         finally:
             for actor in actors:
                 actor.SetPickable(True)
-            self.swap_pick_mappers(data_ids, use_pick_mapper=False)
         return actors, viewer_id
 
     def get_composite_block_info(
-        self, pipeline: VtkPipeline, picker: vtkCellPicker
-    ) -> tuple[vtkDataObject | None, str | None, bool]:
+        self, pipeline: VtkPipeline, picker: vtkHardwarePicker
+    ) -> tuple[vtkDataObject | None, str | None]:
         if not isinstance(pipeline.mapper, vtkCompositePolyDataMapper):
-            return None, None, True
+            return None, None
         flat_index = picker.GetFlatBlockIndex()
         if not (0 <= flat_index < len(pipeline.blockDataSets)):
-            return None, None, True
+            return None, None
         dataset = pipeline.blockDataSets[flat_index]
-        if dataset:
-            attr = pipeline.mapper.GetCompositeDataDisplayAttributes()
-            if attr and not attr.GetBlockVisibility(dataset):
-                return None, None, False
         geode_id = (
             pipeline.blockGeodeIds[flat_index]
             if flat_index < len(pipeline.blockGeodeIds)
             else None
         )
-        return dataset, geode_id, True
+        return dataset, geode_id
 
     def get_array_values(self, array: Any, id_to_select: int) -> list[float] | float:
         components = array.GetNumberOfComponents()