more types

Author: BotellaA

src/opengeodeweb_viewer/object/object_methods.py

@@ -2,10 +2,13 @@
 import os
 
 # Third party imports
-import vtk
+from vtkmodules.vtkIOXML import vtkXMLDataReader, vtkXMLImageDataReader
+from vtkmodules.vtkCommonExecutionModel import vtkAlgorithm
+from vtkmodules.vtkRenderingCore import vtkMapper, vtkActor, vtkTexture
+from vtkmodules.vtkCommonDataModel import vtkDataObject
 
 # Local application imports
-from opengeodeweb_viewer.vtk_protocol import VtkView
+from opengeodeweb_viewer.vtk_protocol import VtkView, vtkData
 
 
 class VtkObjectView(VtkView):
@@ -16,37 +19,34 @@ def registerObject(
         self,
         id: str,
         file_name: str,
-        reader: vtk.vtkDataReader,
-        filter: vtk.vtkAlgorithm | None,
-        mapper: vtk.vtkMapper,
+        data: vtkData,
     ) -> None:
-        actor = vtk.vtkActor()
-        self.register_object(id, reader, filter, actor, mapper, {})
-        reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
-        actor.SetMapper(mapper)
-        mapper.SetColorModeToMapScalars()
-        mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
-        mapper.SetResolveCoincidentTopologyPolygonOffsetParameters(2, 0)
-        mapper.SetResolveCoincidentTopologyPointOffsetParameter(-2)
+        self.register_object(id, data)
+        data.reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, id, file_name))
+        data.actor.SetMapper(data.mapper)
+        data.mapper.SetColorModeToMapScalars()
+        data.mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
+        data.mapper.SetResolveCoincidentTopologyPolygonOffsetParameters(2, 0)
+        data.mapper.SetResolveCoincidentTopologyPointOffsetParameter(-2)
 
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
-        renderer.AddActor(actor)
+        renderer.AddActor(data.actor)
         renderer.ResetCamera()
         renderWindow.Render()
         self.render()
 
     def deregisterObject(self, data_id: str) -> None:
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
         self.deregister_object(data_id)
         self.render()
 
     def applyTextures(self, data_id: str, textures: list[dict[str, str]]) -> None:
-        textures_array: list[vtk.vtkTexture] = []
-        images_reader_array: list[vtk.vtkXMLImageDataReader] = []
+        textures_array: list[vtkTexture] = []
+        images_reader_array: list[vtkXMLImageDataReader] = []
 
         data = self.get_object(data_id)
         mapper = data["mapper"]
@@ -61,26 +61,24 @@ def applyTextures(self, data_id: str, textures: list[dict[str, str]]) -> None:
             id_texture = value["id"]
             print(f"{texture_name=} {id_texture=}", flush=True)
 
-            new_texture = vtk.vtkTexture()
-            image_reader = vtk.vtkXMLImageDataReader()
+            new_texture = vtkTexture()
+            image_reader = vtkXMLImageDataReader()
             texture_path = self.get_data_file_path(data_id, id_texture)
             image_reader.SetFileName(texture_path)
 
             shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
             polydata_mapper.MapDataArrayToMultiTextureAttribute(
                 shader_texture_name,
                 texture_name,
-                vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS,
+                vtkDataObject.FIELD_ASSOCIATION_POINTS,
             )
 
             if index == 0:
                 new_texture.SetBlendingMode(
-                    vtk.vtkTexture.VTK_TEXTURE_BLENDING_MODE_REPLACE
+                    vtkTexture.VTK_TEXTURE_BLENDING_MODE_REPLACE
                 )
             else:
-                new_texture.SetBlendingMode(
-                    vtk.vtkTexture.VTK_TEXTURE_BLENDING_MODE_ADD
-                )
+                new_texture.SetBlendingMode(vtkTexture.VTK_TEXTURE_BLENDING_MODE_ADD)
 
             images_reader_array.append(image_reader)
             new_texture.SetInputConnection(image_reader.GetOutputPort())
@@ -93,62 +91,62 @@ def applyTextures(self, data_id: str, textures: list[dict[str, str]]) -> None:
         self.render()
 
     def SetVisibility(self, data_id: str, visibility: bool) -> None:
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         actor.SetVisibility(visibility)
         self.render()
 
     def SetOpacity(self, data_id: str, opacity: float) -> None:
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         actor.GetProperty().SetOpacity(opacity)
         self.render()
 
     def SetColor(self, data_id: str, red: int, green: int, blue: int) -> None:
-        mapper = self.get_object(data_id)["mapper"]
+        mapper = self.get_object(data_id).mapper
         mapper.ScalarVisibilityOff()
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
         self.render()
 
     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"]
+        actor = self.get_object(data_id).actor
+        max_dimension = self.get_object(data_id).max_dimension
         if max_dimension == "edges":
             self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
     def SetEdgesWidth(self, data_id: str, width: float) -> None:
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         actor.GetProperty().SetEdgeWidth(width)
         self.render()
 
     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"]
+        actor = self.get_object(data_id).actor
+        max_dimension = self.get_object(data_id).max_dimension
         if max_dimension == "edges":
             self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
         self.render()
 
     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"]
+        actor = self.get_object(data_id).actor
+        max_dimension = self.get_object(data_id).max_dimension
         if max_dimension == "points":
             self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetVertexVisibility(visibility)
         self.render()
 
     def SetPointsSize(self, data_id: str, size: float) -> None:
-        actor = self.get_object(data_id)["actor"]
+        actor = self.get_object(data_id).actor
         actor.GetProperty().SetPointSize(size)
         self.render()
 
     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"]
+        actor = self.get_object(data_id).actor
+        max_dimension = self.get_object(data_id).max_dimension
         if max_dimension == "points":
             self.SetColor(data_id, red, green, blue)
         else:
@@ -158,15 +156,15 @@ def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
     def SetBlocksVisibility(
         self, data_id: str, block_ids: list[int], visibility: bool
     ) -> None:
-        mapper = self.get_object(data_id)["mapper"]
+        mapper = self.get_object(data_id).mapper
         for block_id in block_ids:
             mapper.SetBlockVisibility(block_id, visibility)
         self.render()
 
     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_object(data_id).mapper
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
         self.render()

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -2,14 +2,18 @@
 import os
 
 # Third party imports
-from vtk.web import protocols as vtk_protocols
-from wslink import register as exportRpc
+from vtk.web import protocols as vtk_protocols  # type: ignore
+from wslink import register as exportRpc  # type: ignore
 
 # Local application imports
 from opengeodeweb_viewer.vtk_protocol import VtkView
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    get_schemas_dict,
+    validate_schema,
+    RpcParams,
+)
 from . import schemas
 
 
@@ -29,7 +33,7 @@ def __init__(
     @exportRpc(generic_prefix + generic_schemas_dict["register"]["rpc"])
     def register(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            params, self.generic_schemas_dict["register"], self.generic_prefix
+            rpc_params, self.generic_schemas_dict["register"], self.generic_prefix
         )
         params = schemas.Register.from_dict(rpc_params)
         data_id = params.id
@@ -44,7 +48,7 @@ def register(self, rpc_params: RpcParams) -> None:
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            params, self.generic_schemas_dict["deregister"], self.generic_prefix
+            rpc_params, self.generic_schemas_dict["deregister"], self.generic_prefix
         )
         params = schemas.Deregister.from_dict(rpc_params)
         data_id = params.id

src/opengeodeweb_viewer/rpc/mesh/edges/mesh_edges_protocols.py

@@ -2,10 +2,14 @@
 import os
 
 # Third party imports
-from wslink import register as exportRpc
+from wslink import register as exportRpc  # type: ignore
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    get_schemas_dict,
+    validate_schema,
+    RpcParams,
+)
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 from . import schemas
 
@@ -22,15 +26,17 @@ def __init__(self) -> None:
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["visibility"]["rpc"])
     def setMeshEdgesVisibility(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            params, self.mesh_edges_schemas_dict["visibility"], self.mesh_edges_prefix
+            rpc_params,
+            self.mesh_edges_schemas_dict["visibility"],
+            self.mesh_edges_prefix,
         )
         params = schemas.Visibility.from_dict(rpc_params)
         self.SetEdgesVisibility(params.id, params.visibility)
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["color"]["rpc"])
     def setMeshEdgesColor(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            params, self.mesh_edges_schemas_dict["color"], self.mesh_edges_prefix
+            rpc_params, self.mesh_edges_schemas_dict["color"], self.mesh_edges_prefix
         )
         params = schemas.Color.from_dict(rpc_params)
         color = params.color
@@ -39,7 +45,7 @@ def setMeshEdgesColor(self, rpc_params: RpcParams) -> None:
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["width"]["rpc"])
     def setMeshEdgesWidth(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            params, self.mesh_edges_schemas_dict["width"], self.mesh_edges_prefix
+            rpc_params, self.mesh_edges_schemas_dict["width"], self.mesh_edges_prefix
         )
         params = schemas.Color.from_dict(rpc_params)
         self.SetEdgesWidth(params.id, params.width)