Schema types

.gitignore

@@ -11,5 +11,4 @@ build
 .coverage*
 .mypy_cache
 *.db
-tests/tests_output/
-opengeodeweb_viewer_schemas.json
+tests/tests_output/

opengeodeweb_viewer_schemas.json

@@ -0,0 +1,3 @@
+{
+  "opengeodeweb_viewer": {}
+}

requirements.txt

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

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,12 +2,19 @@
 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
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
 # Local application imports
 from opengeodeweb_viewer.vtk_protocol import VtkView
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
+from opengeodeweb_viewer.utils_functions import (
+    validate_schema,
+    RpcParams,
+)
+from . import schemas
 
 
 class VtkGenericView(VtkView):
@@ -16,17 +23,20 @@ class VtkGenericView(VtkView):
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
-    def __init__(self, mesh_protocols, model_protocols):
+    def __init__(
+        self, mesh_protocols: VtkMeshView, model_protocols: VtkModelView
+    ) -> None:
         super().__init__()
         self.mesh_protocols = mesh_protocols
         self.model_protocols = model_protocols
 
     @exportRpc(generic_prefix + generic_schemas_dict["register"]["rpc"])
-    def register(self, params):
+    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
         )
-        data_id = str(params["id"])
+        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"])
@@ -36,11 +46,12 @@ def register(self, params):
             self.model_protocols.registerModel(specific_params)
 
     @exportRpc(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
-    def deregister(self, params):
+    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
         )
-        data_id = str(params["id"])
+        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"])

src/opengeodeweb_viewer/rpc/generic/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .register import *
+from .deregister import *

src/opengeodeweb_viewer/rpc/generic/schemas/deregister.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Deregister(DataClassJsonMixin):
+    id: str

src/opengeodeweb_viewer/rpc/generic/schemas/register.py

@@ -0,0 +1,7 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Register(DataClassJsonMixin):
+    id: str

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

@@ -2,11 +2,16 @@
 import os
 
 # Third party imports
-from wslink import register as exportRpc
+from wslink import register as exportRpc  # type: ignore
+from opengeodeweb_microservice.schemas import get_schemas_dict
 
 # Local application imports
-from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.utils_functions import (
+    validate_schema,
+    RpcParams,
+)
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from . import schemas
 
 
 class VtkMeshEdgesView(VtkMeshView):
@@ -15,34 +20,32 @@ class VtkMeshEdgesView(VtkMeshView):
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["visibility"]["rpc"])
-    def setMeshEdgesVisibility(self, params):
+    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,
         )
-        id, visibility = params["id"], params["visibility"]
-        self.SetEdgesVisibility(id, visibility)
+        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, params):
+    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
         )
-        id, red, green, blue = (
-            params["id"],
-            params["color"]["r"],
-            params["color"]["g"],
-            params["color"]["b"],
-        )
-        self.SetEdgesColor(id, red, green, blue)
+        params = schemas.Color.from_dict(rpc_params)
+        color = params.color
+        self.SetEdgesColor(params.id, color.r, color.g, color.b)
 
     @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["width"]["rpc"])
-    def setMeshEdgesWidth(self, params):
+    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
         )
-        id, size = params["id"], params["width"]
-        self.SetEdgesWidth(id, width)
+        params = schemas.Width.from_dict(rpc_params)
+        self.SetEdgesWidth(params.id, params.width)

src/opengeodeweb_viewer/rpc/mesh/edges/schemas/__init__.py

@@ -0,0 +1,5 @@
+from .width import *
+from .visibility import *
+from .vertex_attribute import *
+from .size import *
+from .color import *

src/opengeodeweb_viewer/rpc/mesh/edges/schemas/color.py

@@ -0,0 +1,17 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ColorClass(DataClassJsonMixin):
+    b: int
+    g: int
+    r: int
+    a: Optional[float] = None
+
+
+@dataclass
+class Color(DataClassJsonMixin):
+    color: ColorClass
+    id: str

src/opengeodeweb_viewer/rpc/mesh/edges/schemas/size.py

@@ -0,0 +1,8 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Size(DataClassJsonMixin):
+    id: str
+    size: int