wip points/edges/polygons protocols

Author: JulienChampagnol

src/opengeodeweb_viewer/object/object_methods.py

@@ -100,24 +100,41 @@ 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 SetVertexVisibility(self, id, visibility):
+    def SetEdgesColor(self, id, color):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetEdgeColor(color)
+        self.render()
+
+    def SetPointsVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetVertexVisibility(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 SetPolygonsVisibility(self, id, visibility):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetPolygonVisibility(visibility)
+        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/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):
+    prefix = "opengeodeweb_viewer.mesh.edges."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    def __init__(self):
+        super().__init__()
+
+    @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
+    def setMeshEdgesVisibility(self, params):
+        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        self.SetEdgesVisibility(id, visibility)
+
+    @exportRpc(prefix + schemas_dict["color"]["rpc"])
+    def setMeshEdgesColor(self, params):
+        print(self.schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["color"])
+        id = params["id"]
+        color = bool(params["color"])
+        self.SetEdgesColor(id, color)
+
+    @exportRpc(prefix + schemas_dict["size"]["rpc"])
+    def setMeshEdgesSize(self, params):
+        print(self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.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,37 @@
+{
+  "rpc": "color",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "red": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "green": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "blue": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "alpha": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 1
+    }
+  },
+  "required": [
+    "id",
+    "red",
+    "green",
+    "blue",
+    "alpha"
+  ],
+  "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 renamed to 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 renamed to 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,12 +1,8 @@
 # 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
@@ -42,10 +38,10 @@ def deregisterMesh(self, params):
         id = params["id"]
         self.deregisterObject(id)
 
-    @exportRpc(prefix + schemas_dict["set_visibility"]["rpc"])
+    @exportRpc(prefix + 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.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
@@ -58,30 +54,6 @@ def setMeshOpacity(self, params):
         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"])
     def setMeshColor(self, params):
         print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
@@ -92,12 +64,7 @@ def setMeshColor(self, params):
         blue = params["blue"]
         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 +74,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)

src/opengeodeweb_viewer/rpc/mesh/points/points_protocols.py

@@ -0,0 +1,49 @@
+# 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 VtkMeshPointsView(VtkMeshView):
+    prefix = "opengeodeweb_viewer.mesh.points."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    def __init__(self):
+        super().__init__()
+
+    @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
+    def setMeshPointsVisibility(self, params):
+        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        self.SetVertexVisibility(id, visibility)
+
+    @exportRpc(prefix + schemas_dict["color"]["rpc"])
+    def setMeshPointsSize(self, params):
+        print(self.schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["color"])
+        id = params["id"]
+        color = params["color"]
+        self.SetPointsColor(id, color)
+
+    @exportRpc(prefix + schemas_dict["size"]["rpc"])
+    def setMeshPointsSize(self, params):
+        print(self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["size"])
+        id = params["id"]
+        size = float(params["size"])
+        self.SetPointSize(id, size)
+
+    @exportRpc(prefix + schemas_dict["vertex_attribute"]["rpc"])
+    def setMeshPointsVertexAttribute(self, params):
+        print(self.schemas_dict["vertex_attribute"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["vertex_attribute"])
+        id = params["id"]
+        name = str(params["name"])
+        self.setMeshVertexAttribute(id, name)
+    

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

@@ -0,0 +1,37 @@
+{
+  "rpc": "color",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "red": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "green": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "blue": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "alpha": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 1
+    }
+  },
+  "required": [
+    "id",
+    "red",
+    "green",
+    "blue",
+    "alpha"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/mesh/schemas/set_point_size.json renamed to src/opengeodeweb_viewer/rpc/mesh/points/schemas/size.json

@@ -1,5 +1,5 @@
 {
-  "rpc": "set_point_size",
+  "rpc": "size",
   "type": "object",
   "properties": {
     "id": {