feat(viewer): dynamic grid scale

Author: JulienChampagnol

CHANGELOG.md

@@ -65,7 +65,7 @@
 
 ### Features
 
-- **polyhedrons**: Color protocol
+- **polyhedra**: Color protocol
   ([`15b35fc`](https://github.com/Geode-solutions/OpenGeodeWeb-Viewer/commit/15b35fcfdda1afc66f4eb4942d9f54006bbc9a0f))
 
 

pyproject.toml

@@ -41,18 +41,12 @@ where = ["src"]
 "opengeodeweb_viewer.rpc.mesh.points.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.mesh.edges.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.mesh.polygons.schemas" = ["*.json"]
-"opengeodeweb_viewer.rpc.mesh.polyhedrons.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.mesh.polyhedra.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.model.corners.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.lines.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.surfaces.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.blocks.schemas" = ["*.json"]
 "opengeodeweb_viewer.rpc.viewer.schemas" = ["*.json"]
 
 [tool.semantic_release]

src/opengeodeweb_viewer/rpc/mesh/polyhedrons/polyhedrons_protocols.py renamed to src/opengeodeweb_viewer/rpc/mesh/polyhedra/polyhedra_protocols.py

@@ -9,33 +9,33 @@
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 
 
-class VtkMeshPolyhedronsView(VtkMeshView):
-    mesh_polyhedrons_prefix = "opengeodeweb_viewer.mesh.polyhedrons."
-    mesh_polyhedrons_schemas_dict = get_schemas_dict(
+class VtkMeshPolyhedraView(VtkMeshView):
+    mesh_polyhedra_prefix = "opengeodeweb_viewer.mesh.polyhedra."
+    mesh_polyhedra_schemas_dict = get_schemas_dict(
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
     def __init__(self):
         super().__init__()
 
     @exportRpc(
-        mesh_polyhedrons_prefix + mesh_polyhedrons_schemas_dict["visibility"]["rpc"]
+        mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["visibility"]["rpc"]
     )
-    def setMeshPolyhedronsVisibility(self, params):
+    def setMeshPolyhedraVisibility(self, params):
         validate_schema(
             params,
-            self.mesh_polyhedrons_schemas_dict["visibility"],
-            self.mesh_polyhedrons_prefix,
+            self.mesh_polyhedra_schemas_dict["visibility"],
+            self.mesh_polyhedra_prefix,
         )
         id, visibility = params["id"], params["visibility"]
         self.SetVisibility(id, visibility)
 
-    @exportRpc(mesh_polyhedrons_prefix + mesh_polyhedrons_schemas_dict["color"]["rpc"])
-    def setMeshPolyhedronsColor(self, params):
+    @exportRpc(mesh_polyhedra_prefix + mesh_polyhedra_schemas_dict["color"]["rpc"])
+    def setMeshPolyhedraColor(self, params):
         validate_schema(
             params,
-            self.mesh_polyhedrons_schemas_dict["color"],
-            self.mesh_polyhedrons_prefix,
+            self.mesh_polyhedra_schemas_dict["color"],
+            self.mesh_polyhedra_prefix,
         )
         id, red, green, blue = (
             params["id"],
@@ -46,27 +46,27 @@ def setMeshPolyhedronsColor(self, params):
         self.SetColor(id, red, green, blue)
 
     @exportRpc(
-        mesh_polyhedrons_prefix
-        + mesh_polyhedrons_schemas_dict["vertex_attribute"]["rpc"]
+        mesh_polyhedra_prefix
+        + mesh_polyhedra_schemas_dict["vertex_attribute"]["rpc"]
     )
-    def setMeshPolyhedronsVertexAttribute(self, params):
+    def setMeshPolyhedraVertexAttribute(self, params):
         validate_schema(
             params,
-            self.mesh_polyhedrons_schemas_dict["vertex_attribute"],
-            self.mesh_polyhedrons_prefix,
+            self.mesh_polyhedra_schemas_dict["vertex_attribute"],
+            self.mesh_polyhedra_prefix,
         )
         id, name = params["id"], params["name"]
         self.displayAttributeOnVertices(id, name)
 
     @exportRpc(
-        mesh_polyhedrons_prefix
-        + mesh_polyhedrons_schemas_dict["polyhedron_attribute"]["rpc"]
+        mesh_polyhedra_prefix
+        + mesh_polyhedra_schemas_dict["polyhedron_attribute"]["rpc"]
     )
-    def setMeshPolyhedronsPolyhedronAttribute(self, params):
+    def setMeshPolyhedraPolyhedronAttribute(self, params):
         validate_schema(
             params,
-            self.mesh_polyhedrons_schemas_dict["polyhedron_attribute"],
-            self.mesh_polyhedrons_prefix,
+            self.mesh_polyhedra_schemas_dict["polyhedron_attribute"],
+            self.mesh_polyhedra_prefix,
         )
         id, name = params["id"], params["name"]
         self.displayAttributeOnCells(id, name)

src/opengeodeweb_viewer/rpc/mesh/polyhedrons/schemas/color.json renamed to src/opengeodeweb_viewer/rpc/mesh/polyhedra/schemas/color.json

@@ -9,24 +9,24 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
 
 
-class VtkModelBlocksPolyhedronsView(VtkModelView):
-    model_blocks_polyhedrons_prefix = "opengeodeweb_viewer.model.blocks.polyhedrons."
-    model_blocks_polyhedrons_schemas_dict = get_schemas_dict(
+class VtkModelBlocksView(VtkModelView):
+    model_blocks_prefix = "opengeodeweb_viewer.model.blocks."
+    model_blocks_schemas_dict = get_schemas_dict(
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
     def __init__(self):
         super().__init__()
 
     @exportRpc(
-        model_blocks_polyhedrons_prefix
-        + model_blocks_polyhedrons_schemas_dict["visibility"]["rpc"]
+        model_blocks_prefix
+        + model_blocks_schemas_dict["visibility"]["rpc"]
     )
-    def setModelBlocksPolyhedronsVisibility(self, params):
+    def setModelBlocksPolyhedraVisibility(self, params):
         validate_schema(
             params,
-            self.model_blocks_polyhedrons_schemas_dict["visibility"],
-            self.model_blocks_polyhedrons_prefix,
+            self.model_blocks_schemas_dict["visibility"],
+            self.model_blocks_prefix,
         )
         id, block_ids, visibility = (
             params["id"],
@@ -36,14 +36,14 @@ def setModelBlocksPolyhedronsVisibility(self, params):
         self.SetBlocksVisibility(id, block_ids, visibility)
 
     @exportRpc(
-        model_blocks_polyhedrons_prefix
-        + model_blocks_polyhedrons_schemas_dict["color"]["rpc"]
+        model_blocks_prefix
+        + model_blocks_schemas_dict["color"]["rpc"]
     )
-    def setModelBlocksPolyhedronsColor(self, params):
+    def setModelBlocksPolyhedraColor(self, params):
         validate_schema(
             params,
-            self.model_blocks_polyhedrons_schemas_dict["color"],
-            self.model_blocks_polyhedrons_prefix,
+            self.model_blocks_schemas_dict["color"],
+            self.model_blocks_prefix,
         )
         id, block_ids, red, green, blue = (
             params["id"],

src/opengeodeweb_viewer/rpc/mesh/polyhedrons/schemas/polyhedron_attribute.json renamed to src/opengeodeweb_viewer/rpc/mesh/polyhedra/schemas/polyhedron_attribute.json

@@ -9,24 +9,24 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
 
 
-class VtkModelCornersPointsView(VtkModelView):
-    model_corners_points_prefix = "opengeodeweb_viewer.model.corners.points."
-    model_corners_points_schemas_dict = get_schemas_dict(
+class VtkModelCornersView(VtkModelView):
+    model_corners_prefix = "opengeodeweb_viewer.model.corners."
+    model_corners_schemas_dict = get_schemas_dict(
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
     def __init__(self):
         super().__init__()
 
     @exportRpc(
-        model_corners_points_prefix
-        + model_corners_points_schemas_dict["visibility"]["rpc"]
+        model_corners_prefix
+        + model_corners_schemas_dict["visibility"]["rpc"]
     )
     def setModelCornersPointsVisibility(self, params):
         validate_schema(
             params,
-            self.model_corners_points_schemas_dict["visibility"],
-            self.model_corners_points_prefix,
+            self.model_corners_schemas_dict["visibility"],
+            self.model_corners_prefix,
         )
         id, block_ids, visibility = (
             params["id"],
@@ -36,13 +36,13 @@ def setModelCornersPointsVisibility(self, params):
         self.SetBlocksVisibility(id, block_ids, visibility)
 
     @exportRpc(
-        model_corners_points_prefix + model_corners_points_schemas_dict["color"]["rpc"]
+        model_corners_prefix + model_corners_schemas_dict["color"]["rpc"]
     )
     def setModelCornersPointsColor(self, params):
         validate_schema(
             params,
-            self.model_corners_points_schemas_dict["color"],
-            self.model_corners_points_prefix,
+            self.model_corners_schemas_dict["color"],
+            self.model_corners_prefix,
         )
         id, block_ids, red, green, blue = (
             params["id"],

src/opengeodeweb_viewer/rpc/mesh/polyhedrons/schemas/vertex_attribute.json renamed to src/opengeodeweb_viewer/rpc/mesh/polyhedra/schemas/vertex_attribute.json

@@ -9,23 +9,23 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
 
 
-class VtkModelLinesEdgesView(VtkModelView):
-    model_lines_edges_prefix = "opengeodeweb_viewer.model.lines.edges."
-    model_lines_edges_schemas_dict = get_schemas_dict(
+class VtkModelLinesView(VtkModelView):
+    model_lines_prefix = "opengeodeweb_viewer.model.lines."
+    model_lines_schemas_dict = get_schemas_dict(
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
     def __init__(self):
         super().__init__()
 
     @exportRpc(
-        model_lines_edges_prefix + model_lines_edges_schemas_dict["visibility"]["rpc"]
+        model_lines_prefix + model_lines_schemas_dict["visibility"]["rpc"]
     )
     def setModelLinesEdgesVisibility(self, params):
         validate_schema(
             params,
-            self.model_lines_edges_schemas_dict["visibility"],
-            self.model_lines_edges_prefix,
+            self.model_lines_schemas_dict["visibility"],
+            self.model_lines_prefix,
         )
         id, block_ids, visibility = (
             params["id"],
@@ -35,13 +35,13 @@ def setModelLinesEdgesVisibility(self, params):
         self.SetBlocksVisibility(id, block_ids, visibility)
 
     @exportRpc(
-        model_lines_edges_prefix + model_lines_edges_schemas_dict["color"]["rpc"]
+        model_lines_prefix + model_lines_schemas_dict["color"]["rpc"]
     )
     def setModelLinesEdgesColor(self, params):
         validate_schema(
             params,
-            self.model_lines_edges_schemas_dict["color"],
-            self.model_lines_edges_prefix,
+            self.model_lines_schemas_dict["color"],
+            self.model_lines_prefix,
         )
         id, block_ids, red, green, blue = (
             params["id"],

src/opengeodeweb_viewer/rpc/mesh/polyhedrons/schemas/visibility.json renamed to src/opengeodeweb_viewer/rpc/mesh/polyhedra/schemas/visibility.json

@@ -9,24 +9,24 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
 
 
-class VtkModelSurfacesPolygonsView(VtkModelView):
-    model_surfaces_polygons_prefix = "opengeodeweb_viewer.model.surfaces.polygons."
-    model_surfaces_polygons_schemas_dict = get_schemas_dict(
+class VtkModelSurfacesView(VtkModelView):
+    model_surfaces_prefix = "opengeodeweb_viewer.model.surfaces."
+    model_surfaces_schemas_dict = get_schemas_dict(
         os.path.join(os.path.dirname(__file__), "schemas")
     )
 
     def __init__(self):
         super().__init__()
 
     @exportRpc(
-        model_surfaces_polygons_prefix
-        + model_surfaces_polygons_schemas_dict["visibility"]["rpc"]
+        model_surfaces_prefix
+        + model_surfaces_schemas_dict["visibility"]["rpc"]
     )
     def setModelSurfacesPolygonsVisibility(self, params):
         validate_schema(
             params,
-            self.model_surfaces_polygons_schemas_dict["visibility"],
-            self.model_surfaces_polygons_prefix,
+            self.model_surfaces_schemas_dict["visibility"],
+            self.model_surfaces_prefix,
         )
         id, block_ids, visibility = (
             params["id"],
@@ -36,14 +36,14 @@ def setModelSurfacesPolygonsVisibility(self, params):
         self.SetBlocksVisibility(id, block_ids, visibility)
 
     @exportRpc(
-        model_surfaces_polygons_prefix
-        + model_surfaces_polygons_schemas_dict["color"]["rpc"]
+        model_surfaces_prefix
+        + model_surfaces_schemas_dict["color"]["rpc"]
     )
     def setModelSurfacesPolygonsCOlor(self, params):
         validate_schema(
             params,
-            self.model_surfaces_polygons_schemas_dict["color"],
-            self.model_surfaces_polygons_prefix,
+            self.model_surfaces_schemas_dict["color"],
+            self.model_surfaces_prefix,
         )
         id, block_ids, red, green, blue = (
             params["id"],

src/opengeodeweb_viewer/rpc/model/blocks/polyhedrons/blocks_polyhedrons_protocols.py renamed to src/opengeodeweb_viewer/rpc/model/blocks/blocks_protocols.py

@@ -1,5 +1,5 @@
 {
-  "rpc": "reset",
+  "rpc": "reset_visualization",
   "type": "object",
   "properties": {},
   "required": [],

src/opengeodeweb_viewer/rpc/model/blocks/polyhedrons/schemas/color.json renamed to src/opengeodeweb_viewer/rpc/model/blocks/schemas/color.json

@@ -5,6 +5,7 @@
 # Third party imports
 import vtk
 from vtkmodules.vtkIOImage import vtkPNGWriter, vtkJPEGWriter
+from vtkmodules.vtkRenderingAnnotation import vtkCubeAxesActor
 from vtkmodules.vtkRenderingCore import vtkWindowToImageFilter
 from wslink import register as exportRpc
 
@@ -22,14 +23,42 @@ class VtkViewerView(VtkView):
     def __init__(self):
         super().__init__()
 
-    @exportRpc(viewer_prefix + viewer_schemas_dict["create_visualization"]["rpc"])
-    def createVisualization(self, params):
+    @exportRpc(viewer_prefix + viewer_schemas_dict["reset_visualization"]["rpc"])
+    def resetVisualization(self, params):
         validate_schema(
-            params, self.viewer_schemas_dict["create_visualization"], self.viewer_prefix
+            params, self.viewer_schemas_dict["reset_visualization"], self.viewer_prefix
         )
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
+        renderer.RemoveAllViewProps()
+
+        grid_scale = vtkCubeAxesActor()
+        grid_scale.SetCamera(renderer.GetActiveCamera())
+        grid_scale.DrawXGridlinesOn()
+        grid_scale.DrawYGridlinesOn()
+        grid_scale.DrawZGridlinesOn()
+        grid_scale.SetGridLineLocation(grid_scale.VTK_GRID_LINES_FURTHEST)
+        grid_scale.GetTitleTextProperty(0).SetColor(0, 0, 0)
+        grid_scale.GetTitleTextProperty(1).SetColor(0, 0, 0)
+        grid_scale.GetTitleTextProperty(2).SetColor(0, 0, 0)
+        grid_scale.GetXAxesLinesProperty().SetColor(0, 0, 0)
+        grid_scale.GetYAxesLinesProperty().SetColor(0, 0, 0)
+        grid_scale.GetZAxesLinesProperty().SetColor(0, 0, 0)
+        grid_scale.GetLabelTextProperty(0).SetColor(0, 0, 0)
+        grid_scale.GetLabelTextProperty(1).SetColor(0, 0, 0)
+        grid_scale.GetLabelTextProperty(2).SetColor(0, 0, 0)
+        grid_scale.GetXAxesGridlinesProperty().SetColor(0, 0, 0)
+        grid_scale.GetYAxesGridlinesProperty().SetColor(0, 0, 0)
+        grid_scale.GetZAxesGridlinesProperty().SetColor(0, 0, 0)
+
+        grid_scale.SetVisibility(False)
+        # grid_scale.SetFlyModeToStaticEdges()
+        self.register_object("grid_scale", "", "", grid_scale, "", "")
+
+
+        renderer.AddActor(grid_scale)
         renderer.SetBackground([180 / 255, 180 / 255, 180 / 255])
+
         renderer.ResetCamera()
         renderWindow.Render()
         self.render()
@@ -147,12 +176,6 @@ def getPointPosition(self, params):
         ppos = picker.GetPickPosition()
         return {"x": ppos[0], "y": ppos[1], "z": ppos[2]}
 
-    @exportRpc(viewer_prefix + viewer_schemas_dict["reset"]["rpc"])
-    def reset(self, params):
-        validate_schema(params, self.viewer_schemas_dict["reset"], self.viewer_prefix)
-        renderWindow = self.getView("-1")
-        renderWindow.GetRenderers().GetFirstRenderer().RemoveAllViewProps()
-
     def computeEpsilon(self, renderer, z):
         renderer.SetDisplayPoint(0, 0, z)
         renderer.DisplayToWorld()