tidy

Author: JulienChampagnol

src/opengeodeweb_viewer/object/methods.py

@@ -8,11 +8,6 @@
 from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
 from opengeodeweb_viewer.vtk_protocol import VtkView
 
-
-schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
-schemas_dict = get_schemas_dict(schemas_dir)
-
-
 class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
@@ -108,7 +103,9 @@ def SetOpacity(self, id, opacity):
         actor.GetProperty().SetOpacity(opacity)
         self.render()
 
-    def SetColor(self, id, color):
+    def SetColor(self, id, red, green, blue):
+        color = [red, green, blue]
+        print(f"{color=}", flush=True)
         mapper = self.get_object(id)["mapper"]
         mapper.ScalarVisibilityOff()
         actor = self.get_object(id)["actor"]
@@ -126,7 +123,6 @@ def SetVertexVisibility(self, id, visibility):
         self.render()
 
     def SetPointSize(self, id, size):
-        validate_schema(params, schemas_dict["set_point_size"])
         actor = self.get_object(id)["actor"]
         actor.GetProperty().SetPointSize(size)
         self.render()

src/opengeodeweb_viewer/object/schemas/set_vertex_visility.json

@@ -35,7 +35,7 @@ def register(self, params):
         except Exception as e:
             print("error : ", str(e), flush=True)
 
-    @exportRpc(schemas_dict["register"]["rpc"])
+    @exportRpc(schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
         validate_schema(params, schemas_dict["deregister"])
         id = params["id"]
@@ -45,67 +45,74 @@ def deregisterMesh(self, params):
     def SetVisibility(self, params):
         print(schemas_dict["set_visibility"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_visibility"])
-        super().SetVisibility(params)
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_opacity"]["rpc"])
     def SetOpacity(self, params):
         print(schemas_dict["set_opacity"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_opacity"])
-        super().SetOpacity(params)
+        id = params["id"]
+        opacity = float(params["opacity"])
+        super().SetOpacity(id, opacity)
 
     @exportRpc(schemas_dict["set_edge_visibility"]["rpc"])
     def setEdgeVisibility(self, params):
         print(schemas_dict["set_edge_visibility"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_edge_visibility"])
         print(f"{params=}", flush=True)
-        super().SetEdgeVisibility(params)
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetEdgeVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_point_visibility"]["rpc"])
     def setPointVisibility(self, params):
         print(schemas_dict["set_point_visibility"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_point_visibility"])
-        super().SetVertexVisibility(params)
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetVertexVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_point_size"]["rpc"])
     def setPointSize(self, params):
         print(schemas_dict["set_point_size"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_point_size"])
-        super().SetPointSize(params)
+        id = params["id"]
+        size = float(params["size"])
+        super().SetPointSize(id, size)
 
     @exportRpc(schemas_dict["set_color"]["rpc"])
     def setColor(self, params):
         print(schemas_dict["set_color"]["rpc"], flush=True)
         validate_schema(params, schemas_dict["set_color"])
-        super().SetColor(params)
+        id = params["id"]
+        red = params["red"]
+        green = params["green"]
+        blue = params["blue"]
+        super().SetColor(id, red, green, blue)
 
     @exportRpc(schemas_dict["display_vertex_attribute"]["rpc"])
     def setVertexAttribute(self, params):
         validate_schema(params, schemas_dict["display_vertex_attribute"])
         print(f"{params=}", flush=True)
         id = params["id"]
         name = params["name"]
-        mapper = self.get_object(id)["mapper"]
+        mapper = super().get_object(id)["mapper"]
         mapper.SelectColorArray(name)
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointFieldData()
-        self.render()
+        super().render()
 
     @exportRpc(schemas_dict["display_polygon_attribute"]["rpc"])
-    def setPolygonAttribute(self, id, name):
+    def setPolygonAttribute(self, params):
         validate_schema(params, schemas_dict["display_polygon_attribute"])
-        cpp = store["cpp"]
-        print(cpp.nb_polygons())
-        cells = store["vtk"].GetCellData()
-        print(store["vtk"].GetNumberOfCells())
-        manager = cpp.polygon_attribute_manager()
-        if not manager.attribute_exists(name):
-            return
-        if not cells.HasArray(name):
-            data = self.computeAttributeData(manager, name)
-            cells.AddArray(data)
-        cells.SetActiveScalars(name)
-        mapper = self.get_object(id)["mapper"]
+        id = params["id"]
+        name = params["name"]
+        print(f"{id=}", flush=True)
+        print(f"{name=}", flush=True)
+        mapper = super().get_object(id)["mapper"]
+        mapper.SelectColorArray(name)
         mapper.ScalarVisibilityOn()
-        mapper.SetScalarModeToUseCellData()
-        mapper.SetScalarRange(cells.GetScalars().GetRange())
-        self.render()
+        mapper.SetScalarModeToUseCellFieldData()
+        super().render()

src/opengeodeweb_viewer/rpc/mesh/protocols.py

@@ -1,5 +1,5 @@
 {
-  "rpc": "display_polygon_attribute",
+  "rpc": "mesh.display_polygon_attribute",
   "type": "object",
   "properties": {
     "id": {

src/opengeodeweb_viewer/rpc/mesh/schemas/display_polygon_attribute.json

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

src/opengeodeweb_viewer/rpc/mesh/schemas/display_vertex_attribute.json

@@ -5,36 +5,27 @@
     "id": {
       "type": "string"
     },
-    "color": {
-      "type": "object",
-      "properties": {
-        "red": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 255
-        },
-        "green": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 255
-        },
-        "blue": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 255
-        }
-      },
-      "required": [
-        "red",
-        "green",
-        "blue"
-      ],
-      "additionalProperties": false
+    "red": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "green": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "blue": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
     }
   },
   "required": [
     "id",
-    "color"
+    "red",
+    "green",
+    "blue"
   ],
   "additionalProperties": false
 }

src/opengeodeweb_viewer/rpc/mesh/schemas/set_color.json

@@ -57,8 +57,10 @@ def SetComponentsVisibility(self, params):
     def SetComponentsColor(self, params):
         validate_schema(params, schemas_dict["set_components_color"])
         id = params["id"]
-        color = params["color"]
-        super().SetColor(id, color)
+        red = params["red"]
+        green = params["green"]
+        blue = params["blue"]
+        super().SetColor(id, red, green, blue)
 
     @exportRpc(schemas_dict["set_corners_size"]["rpc"])
     def setCornersSize(self, params):

src/opengeodeweb_viewer/rpc/model/protocols.py

@@ -5,13 +5,27 @@
     "id": {
       "type": "string"
     },
-    "color": {
-      "type": "string"
+    "red": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "green": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
+    },
+    "blue": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 255
     }
   },
   "required": [
     "id",
-    "color"
+    "red",
+    "green",
+    "blue"
   ],
   "additionalProperties": false
 }