fix(Meshes): viewer_elements_type

requirements.txt

@@ -61,4 +61,3 @@ wslink==1.12.4
 yarl>=1
     # via aiohttp
 
-opengeodeweb-microservice==1.*,>=1.0.13rc1

src/opengeodeweb_viewer/object/object_methods.py

@@ -13,7 +13,7 @@
 from vtkmodules.vtkCommonDataModel import vtkDataObject, vtkDataSet
 
 # Local application imports
-from opengeodeweb_viewer.vtk_protocol import VtkView, vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkView, VtkPipeline
 
 
 class VtkObjectView(VtkView):
@@ -24,7 +24,7 @@ def registerObject(
         self,
         id: str,
         file_name: str,
-        data: vtkData,
+        data: VtkPipeline,
     ) -> None:
         self.register_object(id, data)
         data.reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
@@ -47,74 +47,69 @@ def registerObject(
             renderer.ResetCamera()
 
     def deregisterObject(self, data_id: str) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
         self.deregister_object(data_id)
 
     def SetVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.SetVisibility(visibility)
 
     def SetOpacity(self, data_id: str, opacity: float) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetOpacity(opacity)
 
     def SetColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOff()
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
 
     def SetEdgesVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             self.SetVisibility(data_id, visibility)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetEdgeVisibility(visibility)
 
     def SetEdgesWidth(self, data_id: str, width: float) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        actor = self.get_vtk_pipeline(data_id).actor
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             actor.GetProperty().SetLineWidth(width)
         else:
             actor.GetProperty().SetEdgeWidth(width)
 
     def SetEdgesColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "edges":
+        if self.get_viewer_data(data_id).viewer_elements_type == "edges":
             self.SetColor(data_id, red, green, blue)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
 
     def SetPointsVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "points":
+        if self.get_viewer_data(data_id).viewer_elements_type == "points":
             self.SetVisibility(data_id, visibility)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetVertexVisibility(visibility)
 
     def SetPointsSize(self, data_id: str, size: float) -> None:
-        actor = self.get_object(data_id).actor
+        actor = self.get_vtk_pipeline(data_id).actor
         actor.GetProperty().SetPointSize(size)
 
     def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        actor = self.get_object(data_id).actor
-        max_dimension = self.get_object(data_id).max_dimension
-        if max_dimension == "points":
+        if self.get_viewer_data(data_id).viewer_elements_type == "points":
             self.SetColor(data_id, red, green, blue)
         else:
+            actor = self.get_vtk_pipeline(data_id).actor
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
 
     def SetBlocksVisibility(
         self, data_id: str, block_ids: list[int], visibility: bool
     ) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         if not isinstance(mapper, vtkCompositePolyDataMapper):
             raise Exception("Mapper is not a vtkCompositePolyDataMapper")
         for block_id in block_ids:
@@ -123,14 +118,14 @@ def SetBlocksVisibility(
     def SetBlocksColor(
         self, data_id: str, block_ids: list[int], red: int, green: int, blue: int
     ) -> None:
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         if not isinstance(mapper, vtkCompositePolyDataMapper):
             raise Exception("Mapper is not a vtkCompositePolyDataMapper")
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
 
     def clearColors(self, data_id: str) -> None:
-        db = self.get_object(data_id)
+        db = self.get_vtk_pipeline(data_id)
         mapper = db.mapper
         reader = db.reader
         output = reader.GetOutputDataObject(0)

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -38,8 +38,7 @@ def register(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
-        data = self.get_data(data_id)
-        viewer_object = str(data["viewer_object"])
+        viewer_object = self.get_viewer_data(data_id).viewer_object
         if viewer_object == "mesh":
             self.mesh_protocols.registerMesh(specific_params)
         elif viewer_object == "model":
@@ -53,8 +52,7 @@ def deregister(self, rpc_params: RpcParams) -> None:
         params = schemas.Deregister.from_dict(rpc_params)
         data_id = params.id
         specific_params = {"id": data_id}
-        data = self.get_data(data_id)
-        viewer_object = str(data["viewer_object"])
+        viewer_object = self.get_viewer_data(data_id).viewer_object
         if viewer_object == "mesh":
             self.mesh_protocols.deregisterMesh(specific_params)
         elif viewer_object == "model":

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -12,6 +12,7 @@
 )
 from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkCellTypes
 from vtkmodules.vtkCommonExecutionModel import vtkAlgorithm
+from vtkmodules.vtkCommonDataModel import vtkPolyData
 from opengeodeweb_microservice.database.data import Data
 from opengeodeweb_microservice.schemas import get_schemas_dict
 
@@ -21,7 +22,7 @@
     RpcParams,
 )
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
-from opengeodeweb_viewer.vtk_protocol import vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkPipeline
 from . import schemas
 
 
@@ -43,31 +44,12 @@ def registerMesh(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         try:
-            file_name = str(self.get_data(data_id)["viewable_file"])
+            file_name = str(self.get_viewer_data(data_id).viewable_file)
             reader = vtkXMLGenericDataObjectReader()
             mapper = vtkDataSetMapper()
             mapper.SetInputConnection(reader.GetOutputPort())
-            data = vtkData(reader, mapper)
+            data = VtkPipeline(reader, mapper)
             self.registerObject(data_id, file_name, data)
-            data_object = reader.GetOutput()
-            data_set = vtkDataSet.SafeDownCast(data_object)
-            cell_types = vtkCellTypes()
-            data_set.GetCellTypes(cell_types)
-            cell_data = cell_types.GetCellTypesArray()
-            max_id = -1
-            for t in range(cell_data.GetSize()):
-                t_id = cell_data.GetValue(t)
-                max_id = max(max_id, t_id)
-            print(f"{max_id=}", flush=True)
-            if max_id < 3:
-                data.max_dimension = "points"
-            elif max_id < 5:
-                data.max_dimension = "edges"
-            elif max_id < 7:
-                data.max_dimension = "polygons"
-            elif max_id >= 7:
-                data.max_dimension = "polyhedra"
-
         except Exception as e:
             print(f"Error registering mesh {data_id}: {str(e)}", flush=True)
             raise
@@ -123,37 +105,37 @@ def meshApplyTextures(self, rpc_params: RpcParams) -> None:
             texture = vtkTexture()
             texture.SetInputConnection(texture_reader.GetOutputPort())
             texture.InterpolateOn()
-            reader = self.get_object(mesh_id).reader
+            reader = self.get_vtk_pipeline(mesh_id).reader
             output = reader.GetOutputAsDataSet()
             point_data = output.GetPointData()
             for i in range(point_data.GetNumberOfArrays()):
                 array = point_data.GetArray(i)
                 if array.GetName() == tex_info.texture_name:
                     point_data.SetTCoords(array)
                     break
-            actor = self.get_object(mesh_id).actor
+            actor = self.get_vtk_pipeline(mesh_id).actor
             actor.SetTexture(texture)
 
     def displayAttributeOnVertices(self, data_id: str, name: str) -> None:
-        reader = self.get_object(data_id).reader
+        reader = self.get_vtk_pipeline(data_id).reader
         points = reader.GetOutputAsDataSet().GetPointData()
         points.SetActiveScalars(name)
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointData()
         mapper.SetScalarRange(points.GetScalars().GetRange())
 
     def displayAttributeOnCells(self, data_id: str, name: str) -> None:
-        reader = self.get_object(data_id).reader
+        reader = self.get_vtk_pipeline(data_id).reader
         cells = reader.GetOutputAsDataSet().GetCellData()
         cells.SetActiveScalars(name)
-        mapper = self.get_object(data_id).mapper
+        mapper = self.get_vtk_pipeline(data_id).mapper
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUseCellData()
         mapper.SetScalarRange(cells.GetScalars().GetRange())
 
     def displayScalarRange(self, data_id: str, minimum: float, maximum: float) -> None:
-        data = self.get_object(data_id)
+        data = self.get_vtk_pipeline(data_id)
         data.mapper.SetScalarRange(minimum, maximum)
         if hasattr(data, "color_map_points") and data.color_map_points:
             lut = vtkColorTransferFunction()
@@ -163,7 +145,7 @@ def displayScalarRange(self, data_id: str, minimum: float, maximum: float) -> No
             data.mapper.SetLookupTable(lut)
 
     def setupColorMap(self, data_id: str, points: list[list[float]]) -> None:
-        data = self.get_object(data_id)
+        data = self.get_vtk_pipeline(data_id)
         sorted_points = sorted(points, key=lambda x: x[0])
         points_min = sorted_points[0][0]
         points_max = sorted_points[-1][0]

src/opengeodeweb_viewer/rpc/model/model_protocols.py

@@ -17,7 +17,7 @@
     RpcParams,
 )
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
-from opengeodeweb_viewer.vtk_protocol import vtkData
+from opengeodeweb_viewer.vtk_protocol import VtkPipeline
 from . import schemas
 
 
@@ -38,15 +38,15 @@ def registerModel(self, rpc_params: RpcParams) -> None:
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
         try:
-            file_name = str(self.get_data(data_id)["viewable_file"])
+            file_name = str(self.get_viewer_data(data_id).viewable_file)
             reader = vtkXMLMultiBlockDataReader()
             filter = vtkGeometryFilter()
             filter.SetInputConnection(reader.GetOutputPort())
             mapper = vtkCompositePolyDataMapper()
             mapper.SetInputConnection(filter.GetOutputPort())
             attributes = vtkCompositeDataDisplayAttributes()
             mapper.SetCompositeDataDisplayAttributes(attributes)
-            data = vtkData(reader, mapper, filter)
+            data = VtkPipeline(reader, mapper, filter)
             self.registerObject(data_id, file_name, data)
         except Exception as e:
             print(f"Error registering model {data_id}: {str(e)}", flush=True)

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -169,7 +169,7 @@ def updateData(self, rpc_params: RpcParams) -> None:
             rpc_params, self.viewer_schemas_dict["update_data"], self.viewer_prefix
         )
         params = schemas.UpdateData.from_dict(rpc_params)
-        data = self.get_object(params.id)
+        data = self.get_vtk_pipeline(params.id)
         reader = data.reader
         reader.Update()
         mapper = data.mapper
@@ -231,7 +231,7 @@ def pickedIds(self, rpc_params: RpcParams) -> dict[str, list[str]]:
         array_ids = []
         if picked_actor:
             for id in params.ids:
-                if self.get_object(id).actor == picked_actor:
+                if self.get_vtk_pipeline(id).actor == picked_actor:
                     array_ids.append(id)
                     break
 

src/opengeodeweb_viewer/vtk_protocol.py

@@ -27,14 +27,19 @@
 
 
 @dataclass
-class vtkData:
+class ViewerData:
+    id: str
+    viewable_file: str | None
+    viewer_object: str
+    viewer_elements_type: str
+
+
+@dataclass
+class VtkPipeline:
     reader: vtkXMLReader
     mapper: vtkMapper
     filter: vtkAlgorithm | None = None
     actor: vtkActor = field(default_factory=vtkActor)
-    max_dimension: Literal["points", "edges", "polygons", "polyhedra", "default"] = (
-        "default"
-    )
     color_map_points: list[list[float]] = field(default_factory=list)
 
 
@@ -57,8 +62,8 @@ def __init__(self) -> None:
     def get_data_base(self) -> Any:
         return self.getSharedObject("db")
 
-    def get_object(self, id: str) -> vtkData:
-        return cast(vtkData, self.get_data_base()[id])
+    def get_vtk_pipeline(self, id: str) -> VtkPipeline:
+        return cast(VtkPipeline, self.get_data_base()[id])
 
     def get_grid_scale(self) -> vtkCubeAxesActor | None:
         return cast(vtkCubeAxesActor | None, self.getSharedObject("grid_scale"))
@@ -78,16 +83,7 @@ def get_widget(self) -> vtkOrientationMarkerWidget | None:
     def set_widget(self, widget: vtkOrientationMarkerWidget) -> None:
         self.coreServer.setSharedObject("widget", widget)
 
-    def get_viewer_object_type(self, data_id: str) -> str:
-        data = self.get_data(data_id)
-        object_type = data.get("object_type")
-        if object_type == "mesh":
-            return "mesh"
-        elif object_type == "model":
-            return "model"
-        raise Exception(f"Unknown object_type type: {object_type}")
-
-    def get_data(self, data_id: str) -> dict[str, str | list[str] | None]:
+    def get_viewer_data(self, data_id: str) -> ViewerData:
         if Data is None:
             raise Exception("Data model not available")
 
@@ -99,20 +95,20 @@ def get_data(self, data_id: str) -> dict[str, str | list[str] | None]:
                 data = session.get(Data, data_id)
                 if not data:
                     raise Exception(f"Data with id {data_id} not found in database")
-
-                return {
-                    "id": data.id,
-                    "viewable_file": data.viewable_file,
-                    "viewer_object": data.viewer_object,
-                }
+                return ViewerData(
+                    id=data.id,
+                    viewable_file=data.viewable_file,
+                    viewer_object=data.viewer_object,
+                    viewer_elements_type=data.viewer_elements_type,
+                )
             except Exception as e:
                 print(f"Error fetching data {data_id}: {e}")
                 raise
 
     def get_data_file_path(self, data_id: str, filename: str | None = None) -> str:
         if filename is None:
-            data = self.get_data(data_id)
-            viewable_file = data["viewable_file"]
+            data = self.get_viewer_data(data_id)
+            viewable_file = data.viewable_file
             filename = str(viewable_file) if viewable_file is not None else ""
 
         data_folder_path = self.DATA_FOLDER_PATH
@@ -132,7 +128,7 @@ def render(self, view: int = -1) -> None:
             grid_scale.SetBounds(renderer_bounds)
         self.getSharedObject("publisher").imagePush({"view": view})
 
-    def register_object(self, id: str, data: vtkData) -> None:
+    def register_object(self, id: str, data: VtkPipeline) -> None:
         self.get_data_base()[id] = data
 
     def deregister_object(self, id: str) -> None: