wip refactor rpc

Author: JulienChampagnol

src/opengeodeweb_viewer/object/object_methods.py

@@ -110,27 +110,45 @@ 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 SetPointsVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetVertexVisibility(visibility)
+        actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
     def SetPointsSize(self, id, size):
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetPointSize(size)
         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.GetProperty().SetPolygonVisibility(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"]

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -24,7 +24,7 @@ def __init__(self, mesh_protocols, model_protocols):
 
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def register(self, params):
-        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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)
@@ -36,7 +36,7 @@ def register(self, params):
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregister(self, params):
-        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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)

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

@@ -17,23 +17,25 @@ def __init__(self):
 
     @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
     def setMeshEdgesVisibility(self, params):
-        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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)
+        print(self.prefix + 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)
+        red = 1.0 * params["color"]["r"]
+        green = 1.0 * params["color"]["g"]
+        blue = 1.0 * params["color"]["b"]
+        self.SetEdgesColor(id, [red, green, blue])
 
     @exportRpc(prefix + schemas_dict["size"]["rpc"])
     def setMeshEdgesSize(self, params):
-        print(self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["size"])
         id = params["id"]
         size = bool(params["size"])

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

@@ -5,33 +5,42 @@
     "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
+    "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",
-    "red",
-    "green",
-    "blue",
-    "alpha"
+    "color"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -18,7 +18,7 @@ def __init__(self):
 
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
-        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
@@ -33,30 +33,30 @@ def registerMesh(self, params):
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
-        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["deregister"])
         id = params["id"]
         self.deregisterObject(id)
 
     @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
     def SetMeshVisibility(self, params):
-        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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)
 
     @exportRpc(prefix + schemas_dict["set_opacity"]["rpc"])
     def setMeshOpacity(self, params):
-        print(self.schemas_dict["set_opacity"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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_color"]["rpc"])
     def setMeshColor(self, params):
-        print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["set_color"])
         id = params["id"]
         red = params["red"]

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

@@ -17,33 +17,35 @@ def __init__(self):
 
     @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
     def setMeshPointsVisibility(self, params):
-        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["visibility"])
-        id = params["id"]
+        id = str(params["id"])
         visibility = bool(params["visibility"])
-        self.SetVertexVisibility(id, visibility)
+        self.SetPointsVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["color"]["rpc"])
-    def setMeshPointsSize(self, params):
-        print(self.schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+    def setMeshPointsColor(self, params):
+        print(self.prefix + 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)
+        id = str(params["id"])
+        red = params["color"]["r"]
+        green = params["color"]["g"]
+        blue = params["color"]["b"]
+        self.SetPointsColor(id, [red, green, blue])
 
     @exportRpc(prefix + schemas_dict["size"]["rpc"])
     def setMeshPointsSize(self, params):
-        print(self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["size"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["size"])
-        id = params["id"]
+        id = str(params["id"])
         size = float(params["size"])
-        self.SetPointSize(id, size)
+        self.SetPointsSize(id, size)
 
     @exportRpc(prefix + schemas_dict["vertex_attribute"]["rpc"])
     def setMeshPointsVertexAttribute(self, params):
-        print(self.schemas_dict["vertex_attribute"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["vertex_attribute"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["vertex_attribute"])
-        id = params["id"]
+        id = str(params["id"])
         name = str(params["name"])
         self.setMeshVertexAttribute(id, name)
 

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

@@ -5,33 +5,42 @@
     "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
+    "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",
-    "red",
-    "green",
-    "blue",
-    "alpha"
+    "color"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/mesh/polygons/polygons_protocols.py

@@ -17,31 +17,33 @@ def __init__(self):
 
     @exportRpc(prefix + schemas_dict["visibility"]["rpc"])
     def setMeshPolygonsVisibility(self, params):
-        print(self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["visibility"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetPolygonsVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["color"]["rpc"])
     def setMeshPolygonsColor(self, params):
-        print(self.schemas_dict["color"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["color"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["color"])
         id = params["id"]
-        color = bool(params["color"])
-        self.SetPolygonsColor(id, color)
+        red = params["color"]["r"]
+        green = params["color"]["g"]
+        blue = params["color"]["b"]
+        self.SetPolygonsColor(id, [red, green, blue])
 
     @exportRpc(prefix + schemas_dict["vertex_attribute"]["rpc"])
     def setMeshPolygonsVertexAttribute(self, params):
-        print(self.schemas_dict["vertex_attribute"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + 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)
 
     @exportRpc(prefix + schemas_dict["polygon_attribute"]["rpc"])
     def setMeshPolygonsPolygonAttribute(self, params):
-        print(self.schemas_dict["polygon_attribute"]["rpc"], f"{params=}", flush=True)
+        print(self.prefix + self.schemas_dict["polygon_attribute"]["rpc"], f"{params=}", flush=True)
         validate_schema(params, self.schemas_dict["polygon_attribute"])
         id = params["id"]
         name = str(params["name"])