Feat/new rpcs

src/opengeodeweb_viewer/generic/generic_protocols.py

@@ -0,0 +1,47 @@
+# Standard library imports
+import json
+import os
+
+# Third party imports
+import vtk
+from vtk.web import protocols as vtk_protocols
+from wslink import register as exportRpc
+
+# 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
+
+class VtkGenericView(VtkView):
+    prefix = "opengeodeweb_viewer."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    def __init__(self, mesh_protocols, model_protocols):
+        super().__init__()
+        self.mesh_protocols = mesh_protocols
+        self.model_protocols = model_protocols
+
+    @exportRpc(prefix + schemas_dict["register"]["rpc"])
+    def register(self, params):
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
+        viewer_object = params["viewer_object"]
+        params.pop('viewer_object', None)
+        print(f"{params=}", flush=True)
+        if viewer_object == "mesh":
+            self.mesh_protocols.registerMesh(params)
+        elif viewer_object == "model":
+            self.model_protocols.registerModel(params)
+
+    @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
+    def deregister(self, params):
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
+        viewer_object = params["viewer_object"]
+        params.pop('viewer_object', None)
+        if viewer_object == "mesh":
+            self.mesh_protocols.deregisterMesh(params)
+        elif viewer_object == "model":
+            self.model_protocols.deregisterModel(params)
+

src/opengeodeweb_viewer/generic/schemas/deregister.json

@@ -0,0 +1,18 @@
+{
+  "rpc": "deregister",
+  "type": "object",
+  "properties": {
+    "viewer_object": {
+      "type": "string",
+      "enum": ["mesh", "model"]
+    },
+    "id": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "viewer_object",
+    "id"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/generic/schemas/register.json

@@ -0,0 +1,22 @@
+{
+  "rpc": "register",
+  "type": "object",
+  "properties": {
+    "viewer_object": {
+      "type": "string",
+      "enum": ["mesh", "model"]
+    },
+    "id": {
+      "type": "string"
+    },
+    "file_name": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "viewer_object",
+    "id",
+    "file_name"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/object/object_methods.py

@@ -12,7 +12,7 @@ class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
 
-    def register(self, id, file_name, reader, filter, mapper):
+    def registerObject(self, id, file_name, reader, filter, mapper):
         actor = vtk.vtkActor()
         self.register_object(id, reader, filter, actor, mapper, {})
 
@@ -31,7 +31,7 @@ def register(self, id, file_name, reader, filter, mapper):
         renderWindow.Render()
         self.render()
 
-    def deregister(self, id):
+    def deregisterObject(self, id):
         actor = self.get_object(id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -13,82 +13,79 @@
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
 
-schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
-schemas_dict = get_schemas_dict(schemas_dir)
-prefix = "opengeodeweb_viewer.mesh."
-
 class VtkMeshView(VtkObjectView):
+    prefix = "opengeodeweb_viewer.mesh."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
     def __init__(self):
         super().__init__()
-        self.prefix = prefix
-        self.schemas_dict = schemas_dict
 
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
-        print(schemas_dict["register"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["register"])
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
         try:
             reader = vtk.vtkXMLGenericDataObjectReader()
             filter = {}
             mapper = vtk.vtkDataSetMapper()
             mapper.SetInputConnection(reader.GetOutputPort())
-            self.register(id, file_name, reader, filter, mapper)
+            self.registerObject(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
-        print(schemas_dict["deregister"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["deregister"])
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
         id = params["id"]
-        self.deregister(id)
+        self.deregisterObject(id)
 
     @exportRpc(prefix + schemas_dict["set_visibility"]["rpc"])
     def SetMeshVisibility(self, params):
-        print(schemas_dict["set_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_visibility"])
+        print(self.schemas_dict["set_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_opacity"]["rpc"])
     def setMeshOpacity(self, params):
-        print(schemas_dict["set_opacity"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_opacity"])
+        print(self.schemas_dict["set_opacity"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_opacity"])
         id = params["id"]
         opacity = float(params["opacity"])
         self.SetOpacity(id, opacity)
 
     @exportRpc(prefix + schemas_dict["set_edge_visibility"]["rpc"])
     def setMeshEdgeVisibility(self, params):
-        print(schemas_dict["set_edge_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_edge_visibility"])
+        print(self.schemas_dict["set_edge_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_edge_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_point_visibility"]["rpc"])
     def setMeshPointVisibility(self, params):
-        print(schemas_dict["set_point_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_point_visibility"])
+        print(self.schemas_dict["set_point_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_point_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVertexVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_point_size"]["rpc"])
     def setMeshPointSize(self, params):
-        print(schemas_dict["set_point_size"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_point_size"])
+        print(self.schemas_dict["set_point_size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_point_size"])
         id = params["id"]
         size = float(params["size"])
         self.SetPointSize(id, size)
 
     @exportRpc(prefix + schemas_dict["set_color"]["rpc"])
     def setMeshColor(self, params):
-        print(schemas_dict["set_color"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_color"])
+        print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_color"])
         id = params["id"]
         red = params["red"]
         green = params["green"]
@@ -97,8 +94,8 @@ def setMeshColor(self, params):
 
     @exportRpc(prefix + schemas_dict["display_vertex_attribute"]["rpc"])
     def setVertexAttribute(self, params):
-        print(schemas_dict["display_vertex_attribute"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["display_vertex_attribute"])
+        print(self.schemas_dict["display_vertex_attribute"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["display_vertex_attribute"])
         id = params["id"]
         name = params["name"]
         reader = self.get_object(id)["reader"]
@@ -112,8 +109,8 @@ def setVertexAttribute(self, params):
 
     @exportRpc(prefix + schemas_dict["display_polygon_attribute"]["rpc"])
     def setPolygonAttribute(self, params):
-        print(schemas_dict["display_polygon_attribute"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["display_polygon_attribute"])
+        print(self.schemas_dict["display_polygon_attribute"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["display_polygon_attribute"])
         id = params["id"]
         name = params["name"]
         reader = self.get_object(id)["reader"]

src/opengeodeweb_viewer/rpc/model/model_protocols.py

@@ -11,20 +11,17 @@
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
 
-schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
-schemas_dict = get_schemas_dict(schemas_dir)
-prefix = "opengeodeweb_viewer.model."
-
 class VtkModelView(VtkObjectView):
+    prefix = "opengeodeweb_viewer.model."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
     def __init__(self):
         super().__init__()
-        self.prefix = prefix
-        self.schemas_dict = schemas_dict
 
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def registerModel(self, params):
-        print(schemas_dict["register"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["register"])
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
         try:
@@ -33,37 +30,37 @@ def registerModel(self, params):
             filter.SetInputConnection(reader.GetOutputPort())
             mapper = vtk.vtkCompositePolyDataMapper()
             mapper.SetInputConnection(filter.GetOutputPort())
-            self.register(id, file_name, reader, filter, mapper)
+            self.registerObject(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregisterModel(self, params):
-        print(schemas_dict["deregister"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["deregister"])
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
         id = params["id"]
-        self.deregister(id)
+        self.deregisterObject(id)
 
     @exportRpc(prefix + schemas_dict["set_mesh_visibility"]["rpc"])
     def setMeshVisibility(self, params):
-        print(schemas_dict["set_mesh_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_mesh_visibility"])
+        print(self.schemas_dict["set_mesh_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_mesh_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_components_visibility"]["rpc"])
     def setComponentsVisibility(self, params):
-        print(schemas_dict["set_components_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_components_visibility"])
+        print(self.schemas_dict["set_components_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_components_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_components_color"]["rpc"])
     def setComponentsColor(self, params):
-        print(schemas_dict["set_components_color"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_components_color"])
+        print(self.schemas_dict["set_components_color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_components_color"])
         id = params["id"]
         red = params["red"]
         green = params["green"]
@@ -72,8 +69,8 @@ def setComponentsColor(self, params):
 
     @exportRpc(prefix + schemas_dict["set_corners_size"]["rpc"])
     def setCornersSize(self, params):
-        print(schemas_dict["set_corners_size"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_corners_size"])
+        print(self.schemas_dict["set_corners_size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_corners_size"])
         id = params["id"]
         size = float(params["size"])
         self.SetPointSize(id, size)