Merge pull request #57 from Geode-solutions/feat/model_graphic_options

feat(model): new rpcs

Author: JulienChampagnol

.gitignore

@@ -11,3 +11,4 @@ schemas.json
 build
 /src/tests/tests_output/
 *.egg-info
+.coverage*

pyproject.toml

@@ -43,6 +43,16 @@ where = ["src"]
 "opengeodeweb_viewer.rpc.mesh.polygons.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.mesh.polyhedrons.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.model.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.corners.points.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.lines.points.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.lines.edges.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.surfaces.points.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.surfaces.edges.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.surfaces.polygons.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.blocks.points.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.blocks.edges.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.blocks.polygons.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.blocks.polyhedrons.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.viewer.schemas" = ["*.json"]
 
 [tool.semantic_release]

src/opengeodeweb_viewer/object/object_methods.py

@@ -138,6 +138,18 @@ def SetPointsColor(self, id, red, green, blue):
         actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
         self.render()
 
+    def SetBlocksVisibility(self, id, block_ids, visibility):
+        mapper = self.get_object(id)["mapper"]
+        for block_id in block_ids:
+            mapper.SetBlockVisibility(block_id, visibility)
+        self.render()
+
+    def SetBlocksColor(self, id, block_ids, red, green, blue):
+        mapper = self.get_object(id)["mapper"]
+        for block_id in block_ids:
+            mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
+        self.render()
+
     def clearColors(self, id):
         db = self.get_object(id)
         mapper = db["mapper"]

src/opengeodeweb_viewer/rpc/generic/generic_protocols.py

@@ -1,9 +1,7 @@
 # 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
 
@@ -25,28 +23,21 @@ def __init__(self, mesh_protocols, model_protocols):
 
     @exportRpc(generic_prefix + generic_schemas_dict["register"]["rpc"])
     def register(self, params):
-        print(
-            self.generic_prefix + self.generic_schemas_dict["register"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.generic_schemas_dict["register"], self.generic_prefix
         )
-        validate_schema(params, self.generic_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(generic_prefix + generic_schemas_dict["deregister"]["rpc"])
     def deregister(self, params):
-        print(
-            self.generic_prefix + self.generic_schemas_dict["deregister"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.generic_schemas_dict["deregister"], self.generic_prefix
         )
-        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 renamed to src/opengeodeweb_viewer/rpc/mesh/edges/mesh_edges_protocols.py

@@ -20,26 +20,19 @@ def __init__(self):
 
     @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"], self.mesh_edges_prefix
         )
-        validate_schema(params, self.mesh_edges_schemas_dict["visibility"])
-        id = params["id"]
-        visibility = bool(params["visibility"])
+        id, visibility = params["id"], 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"], self.mesh_edges_prefix
         )
-        validate_schema(params, self.mesh_edges_schemas_dict["color"])
-        id = params["id"]
-        red, green, blue = (
+        id, red, green, blue = (
+            params["id"],
             params["color"]["r"],
             params["color"]["g"],
             params["color"]["b"],
@@ -48,12 +41,8 @@ def setMeshEdgesColor(self, params):
 
     @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"], self.mesh_edges_prefix
         )
-        validate_schema(params, self.mesh_edges_schemas_dict["size"])
-        id = params["id"]
-        size = bool(params["size"])
+        id, size = params["id"], params["size"]
         self.SetEdgesSize(id, size)

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -21,14 +21,8 @@ def __init__(self):
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
-        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"]
+        validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
+        id, file_name = params["id"], params["file_name"]
         try:
             reader = vtk.vtkXMLGenericDataObjectReader()
             filter = {}
@@ -40,49 +34,27 @@ def registerMesh(self, params):
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
-        print(
-            self.mesh_prefix + self.mesh_schemas_dict["deregister"]["rpc"],
-            f"{params=}",
-            flush=True,
-        )
-        validate_schema(params, self.mesh_schemas_dict["deregister"])
+        validate_schema(params, self.mesh_schemas_dict["deregister"], self.mesh_prefix)
         id = params["id"]
         self.deregisterObject(id)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["visibility"]["rpc"])
     def SetMeshVisibility(self, params):
-        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"])
+        validate_schema(params, self.mesh_schemas_dict["visibility"], self.mesh_prefix)
+        id, visibility = params["id"], params["visibility"]
         self.SetVisibility(id, visibility)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["opacity"]["rpc"])
     def setMeshOpacity(self, params):
-        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"])
+        validate_schema(params, self.mesh_schemas_dict["opacity"], self.mesh_prefix)
+        id, opacity = params["id"], params["opacity"]
         self.SetOpacity(id, opacity)
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["color"]["rpc"])
     def setMeshColor(self, params):
-        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, green, blue = (
+        validate_schema(params, self.mesh_schemas_dict["color"], self.mesh_prefix)
+        id, red, green, blue = (
+            params["id"],
             params["color"]["r"],
             params["color"]["g"],
             params["color"]["b"],
@@ -91,14 +63,10 @@ def setMeshColor(self, params):
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["apply_textures"]["rpc"])
     def meshApplyTextures(self, params):
-        print(
-            self.mesh_prefix + self.mesh_schemas_dict["apply_textures"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.mesh_schemas_dict["apply_textures"], self.mesh_prefix
         )
-        validate_schema(params, self.mesh_schemas_dict["apply_textures"])
-        id = params["id"]
-        textures = params["textures"]
+        id, textures = params["id"], params["textures"]
         self.applyTextures(id, textures)
 
     def displayAttributeOnVertices(self, id, name):

src/opengeodeweb_viewer/rpc/mesh/points/points_protocols.py renamed to src/opengeodeweb_viewer/rpc/mesh/points/mesh_points_protocols.py

@@ -20,27 +20,19 @@ def __init__(self):
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["visibility"]["rpc"])
     def setMeshPointsVisibility(self, params):
-        print(
-            self.mesh_points_prefix
-            + self.mesh_points_schemas_dict["visibility"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.mesh_points_schemas_dict["visibility"], self.mesh_points_prefix
         )
-        validate_schema(params, self.mesh_points_schemas_dict["visibility"])
-        id = str(params["id"])
-        visibility = bool(params["visibility"])
+        id, visibility = params["id"], params["visibility"]
         self.SetPointsVisibility(id, visibility)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["color"]["rpc"])
     def setMeshPointsColor(self, params):
-        print(
-            self.mesh_points_prefix + self.mesh_points_schemas_dict["color"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.mesh_points_schemas_dict["color"], self.mesh_points_prefix
         )
-        validate_schema(params, self.mesh_points_schemas_dict["color"])
-        id = str(params["id"])
-        red, green, blue = (
+        id, red, green, blue = (
+            params["id"],
             params["color"]["r"],
             params["color"]["g"],
             params["color"]["b"],
@@ -49,25 +41,18 @@ def setMeshPointsColor(self, params):
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["size"]["rpc"])
     def setMeshPointsSize(self, params):
-        print(
-            self.mesh_points_prefix + self.mesh_points_schemas_dict["size"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params, self.mesh_points_schemas_dict["size"], self.mesh_points_prefix
         )
-        validate_schema(params, self.mesh_points_schemas_dict["size"])
-        id = str(params["id"])
-        size = float(params["size"])
+        id, size = params["id"], params["size"]
         self.SetPointsSize(id, size)
 
     @exportRpc(mesh_points_prefix + mesh_points_schemas_dict["vertex_attribute"]["rpc"])
     def setMeshPointsVertexAttribute(self, params):
-        print(
-            self.mesh_points_prefix
-            + self.mesh_points_schemas_dict["vertex_attribute"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params,
+            self.mesh_points_schemas_dict["vertex_attribute"],
+            self.mesh_points_prefix,
         )
-        validate_schema(params, self.mesh_points_schemas_dict["vertex_attribute"])
-        id = str(params["id"])
-        name = str(params["name"])
+        id, name = params["id"], params["name"]
         self.displayAttributeOnVertices(id, name)

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

@@ -20,27 +20,23 @@ def __init__(self):
 
     @exportRpc(mesh_polygons_prefix + mesh_polygons_schemas_dict["visibility"]["rpc"])
     def setMeshPolygonsVisibility(self, params):
-        print(
-            self.mesh_polygons_prefix
-            + self.mesh_polygons_schemas_dict["visibility"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params,
+            self.mesh_polygons_schemas_dict["visibility"],
+            self.mesh_polygons_prefix,
         )
-        validate_schema(params, self.mesh_polygons_schemas_dict["visibility"])
-        id = params["id"]
-        visibility = bool(params["visibility"])
+        id, visibility = params["id"], params["visibility"]
         self.SetVisibility(id, visibility)
 
     @exportRpc(mesh_polygons_prefix + mesh_polygons_schemas_dict["color"]["rpc"])
     def setMeshPolygonsColor(self, params):
-        print(
-            self.mesh_polygons_prefix + self.mesh_polygons_schemas_dict["color"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params,
+            self.mesh_polygons_schemas_dict["color"],
+            self.mesh_polygons_prefix,
         )
-        validate_schema(params, self.mesh_polygons_schemas_dict["color"])
-        id = params["id"]
-        red, green, blue = (
+        id, red, green, blue = (
+            params["id"],
             params["color"]["r"],
             params["color"]["g"],
             params["color"]["b"],
@@ -51,28 +47,22 @@ def setMeshPolygonsColor(self, params):
         mesh_polygons_prefix + mesh_polygons_schemas_dict["vertex_attribute"]["rpc"]
     )
     def setMeshPolygonsVertexAttribute(self, params):
-        print(
-            self.mesh_polygons_prefix
-            + self.mesh_polygons_schemas_dict["vertex_attribute"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params,
+            self.mesh_polygons_schemas_dict["vertex_attribute"],
+            self.mesh_polygons_prefix,
         )
-        validate_schema(params, self.mesh_polygons_schemas_dict["vertex_attribute"])
-        id = params["id"]
-        name = str(params["name"])
+        id, name = params["id"], params["name"]
         self.displayAttributeOnVertices(id, name)
 
     @exportRpc(
         mesh_polygons_prefix + mesh_polygons_schemas_dict["polygon_attribute"]["rpc"]
     )
     def setMeshPolygonsPolygonAttribute(self, params):
-        print(
-            self.mesh_polygons_prefix
-            + self.mesh_polygons_schemas_dict["polygon_attribute"]["rpc"],
-            f"{params=}",
-            flush=True,
+        validate_schema(
+            params,
+            self.mesh_polygons_schemas_dict["polygon_attribute"],
+            self.mesh_polygons_prefix,
         )
-        validate_schema(params, self.mesh_polygons_schemas_dict["polygon_attribute"])
-        id = params["id"]
-        name = str(params["name"])
+        id, name = params["id"], params["name"]
         self.displayAttributeOnCells(id, name)