Feat/mesh sub protocols

src/opengeodeweb_viewer/object/object_methods.py

@@ -100,24 +100,60 @@ def SetOpacity(self, id, opacity):
         self.render()
 
     def SetColor(self, id, red, green, blue):
-        reader = self.get_object(id)["reader"]
         mapper = self.get_object(id)["mapper"]
         mapper.ScalarVisibilityOff()
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetColor([red, green, blue])
         self.render()
 
-    def SetEdgeVisibility(self, id, visibility):
+    def SetEdgesVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
+
+    def SetEdgesSize(self, id, size):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetEdgeWidth(size)
+        print("GetEdgeSize", actor.GetProperty().GetEdgeWidth())
+        self.render()
+
+    def SetEdgesColor(self, id, color):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetEdgeColor(color)
+        print("GetEdgeColor", actor.GetProperty().GetEdgeColor())
+        self.render()
 
-    def SetVertexVisibility(self, id, visibility):
+    def SetPointsVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetVertexVisibility(visibility)
+        actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetPointSize(self, id, size):
+    def SetPointsSize(self, id, size):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetPointSize(size)
-        self.render()
+        self.render()
+
+    def SetPointsColor(self, id, color):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetVertexColor(color)
+        self.render()
+
+    def SetPolygonsVisibility(self, id, visibility):
+        actor = self.get_object(id)["actor"]
+        actor.SetVisibility(visibility)
+        # actor.GetProperty().SetVisibility(visibility)
+        self.render()
+
+    def SetPolygonsColor(self, id, color):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetColor(color)
+        self.render()
+
+    def clearColors(self, id):
+        db = self.get_object(id)
+        mapper = db["mapper"]
+        reader = db["reader"]
+        reader.GetOutput().GetPointData().SetActiveScalars("")
+        reader.GetOutput().GetCellData().SetActiveScalars("")
+        mapper.ScalarVisibilityOff()

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -9,23 +9,21 @@
 
 # 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.generic."
-    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+    generic_prefix = "opengeodeweb_viewer.generic."
+    generic_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"])
+    @exportRpc(generic_prefix + generic_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"])
+        print(self.generic_prefix + self.generic_schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.generic_schemas_dict["register"])
         viewer_object = params["viewer_object"]
         params.pop('viewer_object', None)
         print(f"{params=}", flush=True)
@@ -34,10 +32,10 @@ def register(self, params):
         elif viewer_object == "model":
             self.model_protocols.registerModel(params)
 
-    @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
+    @exportRpc(generic_prefix + generic_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"])
+        print(self.generic_prefix + self.generic_schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.generic_schemas_dict["deregister"])
         viewer_object = params["viewer_object"]
         params.pop('viewer_object', None)
         if viewer_object == "mesh":

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

@@ -0,0 +1,43 @@
+# Standard library imports
+import os
+
+# Third party imports
+from wslink import register as exportRpc
+
+# Local application imports
+from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+
+class VtkMeshEdgesView(VtkMeshView):
+    mesh_edges_prefix = "opengeodeweb_viewer.mesh.edges."
+    mesh_edges_schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    def __init__(self):
+        super().__init__()
+
+    @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["visibility"]["rpc"])
+    def setMeshEdgesVisibility(self, params):
+        print(self.mesh_edges_prefix + self.mesh_edges_schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_edges_schemas_dict["visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        self.SetEdgesVisibility(id, visibility)
+
+    @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["color"]["rpc"])
+    def setMeshEdgesColor(self, params):
+        print(self.mesh_edges_prefix + self.mesh_edges_schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_edges_schemas_dict["color"])
+        id = params["id"]
+        red, green, blue = params["color"]["r"], params["color"]["g"], params["color"]["b"]
+        self.SetEdgesColor(id, [red, green, blue])
+
+    @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["size"]["rpc"])
+    def setMeshEdgesSize(self, params):
+        print(self.mesh_edges_prefix + self.mesh_edges_schemas_dict["size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_edges_schemas_dict["size"])
+        id = params["id"]
+        size = bool(params["size"])
+        self.SetEdgesSize(id, size)
+
+
+

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

@@ -0,0 +1,46 @@
+{
+  "rpc": "color",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "color": {
+      "type": "object",
+      "properties": {
+        "r": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "g": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "b": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "a": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "default": 1
+        }
+      },
+      "required": [
+        "r",
+        "g",
+        "b"
+      ],
+      "additionalProperties": false
+    }
+  },
+  "required": [
+    "id",
+    "color"
+  ],
+  "additionalProperties": false
+}

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

@@ -0,0 +1,17 @@
+{
+  "rpc": "size",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "size": {
+      "type": "integer"
+    }
+  },
+  "required": [
+    "id",
+    "size"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/mesh/schemas/display_vertex_attribute.json → src/opengeodeweb_viewer/rpc/mesh/edges/schemas/vertex_attribute.json

@@ -1,5 +1,5 @@
 {
-  "rpc": "display_vertex_attribute",
+  "rpc": "vertex_attribute",
   "type": "object",
   "properties": {
     "id": {

src/opengeodeweb_viewer/rpc/mesh/schemas/set_visibility.json → src/opengeodeweb_viewer/rpc/mesh/edges/schemas/visibility.json

@@ -1,5 +1,5 @@
 {
-  "rpc": "set_visibility",
+  "rpc": "visibility",
   "type": "object",
   "properties": {
     "id": {

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -1,29 +1,25 @@
 # Standard library imports
-import json
 import os
 
 # Third party imports
 import vtk
-from vtk.web import protocols as vtk_protocols
-from vtkmodules.vtkIOImage import vtkPNGWriter, vtkJPEGWriter
-from vtkmodules.vtkRenderingCore import (vtkWindowToImageFilter)
 from wslink import register as exportRpc
 
 # Local application imports
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.object.object_methods import VtkObjectView
 
 class VtkMeshView(VtkObjectView):
-    prefix = "opengeodeweb_viewer.mesh."
-    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+    mesh_prefix = "opengeodeweb_viewer.mesh."
+    mesh_schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
 
     def __init__(self):
         super().__init__()
 
-    @exportRpc(prefix + schemas_dict["register"]["rpc"])
+    @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
-        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
-        validate_schema(params, self.schemas_dict["register"])
+        print(self.mesh_prefix + self.mesh_schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
         try:
@@ -35,69 +31,38 @@ def registerMesh(self, params):
         except Exception as e:
             print("error : ", str(e), flush=True)
 
-    @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
+    @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
-        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
-        validate_schema(params, self.schemas_dict["deregister"])
+        print(self.mesh_prefix + self.mesh_schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_schemas_dict["deregister"])
         id = params["id"]
         self.deregisterObject(id)
 
-    @exportRpc(prefix + schemas_dict["set_visibility"]["rpc"])
+    @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
     def SetMeshVisibility(self, params):
-        print(self.schemas_dict["set_visibility"]["rpc"], f"{params=}", flush=True)
-        validate_schema(params, self.schemas_dict["set_visibility"])
+        print(self.mesh_prefix + self.mesh_schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_schemas_dict["visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
 
-    @exportRpc(prefix + schemas_dict["set_opacity"]["rpc"])
+    @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
     def setMeshOpacity(self, params):
-        print(self.schemas_dict["set_opacity"]["rpc"], f"{params=}", flush=True)
-        validate_schema(params, self.schemas_dict["set_opacity"])
+        print(self.mesh_prefix + self.mesh_schemas_dict["opacity"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_schemas_dict["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(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(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(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"])
+    @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
     def setMeshColor(self, params):
-        print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
-        validate_schema(params, self.schemas_dict["set_color"])
+        print(self.mesh_prefix + self.mesh_schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.mesh_schemas_dict["color"])
         id = params["id"]
-        red = params["red"]
-        green = params["green"]
-        blue = params["blue"]
+        red, green, blue = params["color"]["r"], params["color"]["g"], params["color"]["b"]
         self.SetColor(id, red, green, blue)
 
-    @exportRpc(prefix + schemas_dict["display_vertex_attribute"]["rpc"])
-    def setVertexAttribute(self, params):
-        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"]
+    def setMeshVertexAttribute(self, id, name):
         reader = self.get_object(id)["reader"]
         points = reader.GetOutput().GetPointData()
         points.SetActiveScalars(name)
@@ -107,12 +72,7 @@ def setVertexAttribute(self, params):
         mapper.SetScalarRange(points.GetScalars().GetRange())
         self.render()
 
-    @exportRpc(prefix + schemas_dict["display_polygon_attribute"]["rpc"])
-    def setPolygonAttribute(self, params):
-        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"]
+    def setMeshPolygonAttribute(self, id, name):
         reader = self.get_object(id)["reader"]
         cells = reader.GetOutput().GetCellData()
         cells.SetActiveScalars(name)