test points

Author: JulienChampagnol

src/opengeodeweb_viewer/object/object_methods.py

@@ -108,21 +108,35 @@ def SetColor(self, id, red, green, blue):
 
     def SetEdgesVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
-        actor.GetProperty().SetEdgeVisibility(visibility)
+        max_dimension = self.get_object(id)["max_dimension"]
+        if max_dimension == "edges":
+            self.SetVisibility(id, visibility)
+        else: 
+
+            actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
 
-    def SetEdgesSize(self, id, size):
+    def SetEdgesWidth(self, id, width):
         actor = self.get_object(id)["actor"]
-        actor.GetProperty().SetEdgeWidth(size)
+        actor.GetProperty().UseLineWidthForEdgeThicknessOn()
+        actor.GetProperty().SetEdgeWidth(width)
         self.render()
 
     def SetEdgesColor(self, id, red, green, blue):
         actor = self.get_object(id)["actor"]
-        actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
+        max_dimension = self.get_object(id)["max_dimension"]
+        if max_dimension == "edges":
+            self.SetColor(id, red, green, blue)
+        else: 
+        # actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
         self.render()
 
     def SetPointsVisibility(self, id, visibility):
         actor = self.get_object(id)["actor"]
+        # max_dimension = self.get_object(id)["max_dimension"]
+        # if max_dimension == "points":
+        #     self.SetVisibility(id, visibility)
+        # else: 
         actor.GetProperty().SetVertexVisibility(visibility)
         actor.GetProperty().SetEdgeVisibility(visibility)
         self.render()
@@ -134,6 +148,10 @@ def SetPointsSize(self, id, size):
 
     def SetPointsColor(self, id, red, green, blue):
         actor = self.get_object(id)["actor"]
+        # max_dimension = self.get_object(id)["max_dimension"]
+        # if max_dimension == "points":
+        #     self.SetColor(id, red, green, blue)
+        # else: 
         actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
         self.render()
 

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

@@ -39,10 +39,10 @@ def setMeshEdgesColor(self, params):
         )
         self.SetEdgesColor(id, red, green, blue)
 
-    @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["size"]["rpc"])
-    def setMeshEdgesSize(self, params):
+    @exportRpc(mesh_edges_prefix + mesh_edges_schemas_dict["width"]["rpc"])
+    def setMeshEdgesWidth(self, params):
         validate_schema(
-            params, self.mesh_edges_schemas_dict["size"], self.mesh_edges_prefix
+            params, self.mesh_edges_schemas_dict["width"], self.mesh_edges_prefix
         )
-        id, size = params["id"], params["size"]
-        self.SetEdgesSize(id, size)
+        id, size = params["id"], params["width"]
+        self.SetEdgesWidth(id, width)

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

@@ -0,0 +1,18 @@
+{
+  "rpc": "size",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "width": {
+      "type": "integer"
+    }
+  },
+  "required": [
+    "id",
+    "width"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -23,14 +23,33 @@ def __init__(self):
     def registerMesh(self, params):
         validate_schema(params, self.mesh_schemas_dict["register"], self.mesh_prefix)
         id, file_name = params["id"], params["file_name"]
-        try:
-            reader = vtk.vtkXMLGenericDataObjectReader()
-            filter = {}
-            mapper = vtk.vtkDataSetMapper()
-            mapper.SetInputConnection(reader.GetOutputPort())
-            self.registerObject(id, file_name, reader, filter, mapper)
-        except Exception as e:
-            print("error : ", str(e), flush=True)
+        # try:
+        reader = vtk.vtkXMLGenericDataObjectReader()
+        filter = {}
+        mapper = vtk.vtkDataSetMapper()
+        mapper.SetInputConnection(reader.GetOutputPort())
+        self.registerObject(id, file_name, reader, filter, mapper)
+
+        data_object = reader.GetOutput()
+        data_set = vtk.vtkDataSet.SafeDownCast(data_object)
+        cell_types = vtk.vtkCellTypes()
+        data_set.GetCellTypes(cell_types)
+        cell_data = cell_types.GetCellTypesArray()
+        max_id = -1
+        for t in range(cell_data.GetSize()):
+            t_id = cell_data.GetValue(t)
+            max_id = max(max_id, t_id)
+        print(f"{max_id=}", flush=True)
+        max_dimension = ""
+        if max_id < 3:
+            max_dimension = "points"
+        elif max_id < 5:
+            max_dimension = "edges"
+        elif max_id < 7:
+            max_dimension = "polygons"
+        elif max_id >= 7:
+            max_dimension = "polyhedra"
+        self.get_data_base()[id]["max_dimension"] = max_dimension
 
     @exportRpc(mesh_prefix + mesh_schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):

src/tests/data/images/mesh/points/point_set_color.jpeg

@@ -2,6 +2,7 @@
 
 # Third party imports
 from opengeodeweb_viewer.rpc.mesh.points.mesh_points_protocols import VtkMeshPointsView
+from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
 
 # Local application imports
 from src.tests.mesh.test_mesh_protocols import test_register_mesh
@@ -41,3 +42,34 @@ def test_points_color(server):
         [{"id": "123456789", "color": {"r": 255, "g": 0, "b": 0}}],
     )
     assert server.compare_image(3, "mesh/points/color.jpeg") == True
+
+
+def test_points_visibility_with_point_set(server):
+
+    server.call(
+        VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
+        [{"id": "123456789", "file_name": "points.vtp"}],
+    )
+    assert server.compare_image(3, "mesh/points/register_point_set.jpeg") == True
+
+    server.call(
+        VtkMeshPointsView.mesh_points_prefix
+        + VtkMeshPointsView.mesh_points_schemas_dict["size"]["rpc"],
+        [{"id": "123456789", "size": 10}],
+    )
+    assert server.compare_image(3, "mesh/points/point_set_size.jpeg") == True
+
+    server.call(
+        VtkMeshPointsView.mesh_points_prefix
+        + VtkMeshPointsView.mesh_points_schemas_dict["color"]["rpc"],
+        [{"id": "123456789", "color": {"r": 255, "g": 0, "b": 0}}],
+    )
+    assert server.compare_image(3, "mesh/points/point_set_color.jpeg") == True
+
+    server.call(
+        VtkMeshPointsView.mesh_points_prefix
+        + VtkMeshPointsView.mesh_points_schemas_dict["visibility"]["rpc"],
+        [{"id": "123456789", "visibility": False}],
+    )
+    assert server.compare_image(3, "mesh/points/point_set_visibility.jpeg") == True
+