fix(Render): no automatic rendering

Author: BotellaA

src/opengeodeweb_viewer/object/object_methods.py

@@ -31,83 +31,34 @@ def registerObject(
 
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
+        resetCamara = True
+        for registered_actor in renderer.GetActors():
+            if registered_actor.visibility == True:
+                resetCamara = False
         renderer.AddActor(actor)
-        renderer.ResetCamera()
-        renderWindow.Render()
-        self.render()
+        if resetCamara:
+            renderer.ResetCamera()
 
     def deregisterObject(self, data_id: str) -> None:
         actor = self.get_object(data_id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
         self.deregister_object(data_id)
-        self.render()
-
-    def applyTextures(self, data_id: str, textures: list[dict[str, str]]) -> None:
-        textures_array: list[vtk.vtkTexture] = []
-        images_reader_array: list[vtk.vtkXMLImageDataReader] = []
-
-        data = self.get_object(data_id)
-        mapper = data["mapper"]
-        actor = data["actor"]
-        reader = data["reader"]
-
-        polydata_mapper = mapper.GetPolyDataMapper()
-        poly_data = reader.GetPolyDataOutput()
-
-        for index, value in enumerate(textures):
-            texture_name = value["texture_name"]
-            id_texture = value["id"]
-            print(f"{texture_name=} {id_texture=}", flush=True)
-
-            new_texture = vtk.vtkTexture()
-            image_reader = vtk.vtkXMLImageDataReader()
-            texture_path = self.get_data_file_path(data_id, id_texture)
-            image_reader.SetFileName(texture_path)
-
-            shader_texture_name = f"VTK_TEXTURE_UNIT_{index}"
-            polydata_mapper.MapDataArrayToMultiTextureAttribute(
-                shader_texture_name,
-                texture_name,
-                vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS,
-            )
-
-            if index == 0:
-                new_texture.SetBlendingMode(
-                    vtk.vtkTexture.VTK_TEXTURE_BLENDING_MODE_REPLACE
-                )
-            else:
-                new_texture.SetBlendingMode(
-                    vtk.vtkTexture.VTK_TEXTURE_BLENDING_MODE_ADD
-                )
-
-            images_reader_array.append(image_reader)
-            new_texture.SetInputConnection(image_reader.GetOutputPort())
-
-            actor.GetProperty().SetTexture(shader_texture_name, new_texture)
-
-            textures_array.append(new_texture)
-            images_reader_array.append(image_reader)
-
-        self.render()
 
     def SetVisibility(self, data_id: str, visibility: bool) -> None:
         actor = self.get_object(data_id)["actor"]
         actor.SetVisibility(visibility)
-        self.render()
 
     def SetOpacity(self, data_id: str, opacity: float) -> None:
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetOpacity(opacity)
-        self.render()
 
     def SetColor(self, data_id: str, red: int, green: int, blue: int) -> None:
         mapper = self.get_object(data_id)["mapper"]
         mapper.ScalarVisibilityOff()
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetColor([red / 255, green / 255, blue / 255])
-        self.render()
 
     def SetEdgesVisibility(self, data_id: str, visibility: bool) -> None:
         actor = self.get_object(data_id)["actor"]
@@ -116,12 +67,10 @@ def SetEdgesVisibility(self, data_id: str, visibility: bool) -> None:
             self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetEdgeVisibility(visibility)
-        self.render()
 
     def SetEdgesWidth(self, data_id: str, width: float) -> None:
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetEdgeWidth(width)
-        self.render()
 
     def SetEdgesColor(self, data_id: str, red: int, green: int, blue: int) -> None:
         actor = self.get_object(data_id)["actor"]
@@ -130,7 +79,6 @@ def SetEdgesColor(self, data_id: str, red: int, green: int, blue: int) -> None:
             self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetEdgeColor([red / 255, green / 255, blue / 255])
-        self.render()
 
     def SetPointsVisibility(self, data_id: str, visibility: bool) -> None:
         actor = self.get_object(data_id)["actor"]
@@ -139,12 +87,10 @@ def SetPointsVisibility(self, data_id: str, visibility: bool) -> None:
             self.SetVisibility(data_id, visibility)
         else:
             actor.GetProperty().SetVertexVisibility(visibility)
-        self.render()
 
     def SetPointsSize(self, data_id: str, size: float) -> None:
         actor = self.get_object(data_id)["actor"]
         actor.GetProperty().SetPointSize(size)
-        self.render()
 
     def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
         actor = self.get_object(data_id)["actor"]
@@ -153,23 +99,20 @@ def SetPointsColor(self, data_id: str, red: int, green: int, blue: int) -> None:
             self.SetColor(data_id, red, green, blue)
         else:
             actor.GetProperty().SetVertexColor([red / 255, green / 255, blue / 255])
-        self.render()
 
     def SetBlocksVisibility(
         self, data_id: str, block_ids: list[int], visibility: bool
     ) -> None:
         mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockVisibility(block_id, visibility)
-        self.render()
 
     def SetBlocksColor(
         self, data_id: str, block_ids: list[int], red: int, green: int, blue: int
     ) -> None:
         mapper = self.get_object(data_id)["mapper"]
         for block_id in block_ids:
             mapper.SetBlockColor(block_id, [red / 255, green / 255, blue / 255])
-        self.render()
 
     def clearColors(self, data_id: str) -> None:
         db = self.get_object(data_id)

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -135,7 +135,6 @@ def applyTextures(self, mesh_id: str, textures_info: list[dict[str, str]]) -> No
                     break
             actor = cast(vtk.vtkActor, self.get_object(mesh_id)["actor"])
             actor.SetTexture(texture)
-        self.render()
 
     def displayAttributeOnVertices(self, data_id: str, name: str) -> None:
         reader = self.get_object(data_id)["reader"]
@@ -145,7 +144,6 @@ def displayAttributeOnVertices(self, data_id: str, name: str) -> None:
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointData()
         mapper.SetScalarRange(points.GetScalars().GetRange())
-        self.render()
 
     def displayAttributeOnCells(self, data_id: str, name: str) -> None:
         reader = self.get_object(data_id)["reader"]
@@ -155,4 +153,3 @@ def displayAttributeOnCells(self, data_id: str, name: str) -> None:
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUseCellData()
         mapper.SetScalarRange(cells.GetScalars().GetRange())
-        self.render()

src/opengeodeweb_viewer/rpc/viewer/schemas/render_now.json renamed to src/opengeodeweb_viewer/rpc/viewer/schemas/render.json

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

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -82,8 +82,6 @@ def resetVisualization(self, params: RpcParams) -> None:
         renderer.SetBackground([180 / 255, 180 / 255, 180 / 255])
 
         renderer.ResetCamera()
-        renderWindow.Render()
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["set_background_color"]["rpc"])
     def setBackgroundColor(self, params: RpcParamsWithColor) -> None:
@@ -99,9 +97,6 @@ def setBackgroundColor(self, params: RpcParamsWithColor) -> None:
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
 
         renderer.SetBackground([red / 255, green / 255, blue / 255])
-        renderer.ResetCamera()
-        renderWindow.Render()
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_camera"]["rpc"])
     def resetCamera(self, params: RpcParams) -> None:
@@ -110,8 +105,6 @@ def resetCamera(self, params: RpcParams) -> None:
         )
         renderWindow = self.getView("-1")
         renderWindow.GetRenderers().GetFirstRenderer().ResetCamera()
-        renderWindow.Render()
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["take_screenshot"]["rpc"])
     def takeScreenshot(self, params: RpcParams) -> dict[str, str | bytes]:
@@ -183,7 +176,6 @@ def updateData(self, params: RpcParams) -> None:
             tag,
         )
         mapper.SetScalarRange(scalars.GetRange())
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["get_point_position"]["rpc"])
     def getPointPosition(self, params: RpcParams) -> dict[str, float]:
@@ -247,15 +239,13 @@ def toggleGridScale(self, params: RpcParams) -> None:
         if "grid_scale" in self.get_data_base():
             actor = self.get_object(id)["actor"]
             actor.SetVisibility(visibility)
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["axes"]["rpc"])
     def toggleAxes(self, params: RpcParams) -> None:
         validate_schema(params, self.viewer_schemas_dict["axes"], self.viewer_prefix)
         id, visibility = "axes", params["visibility"]
         actor = self.get_object(id)["actor"]
         actor.SetVisibility(visibility)
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["update_camera"]["rpc"])
     def updateCamera(self, params: RpcParams) -> None:
@@ -277,13 +267,10 @@ def updateCamera(self, params: RpcParams) -> None:
         camera.SetPosition(*position)
         camera.SetViewAngle(view_angle)
         camera.SetClippingRange(*clipping_range)
-        self.render()
 
-    @exportRpc(viewer_prefix + viewer_schemas_dict["render_now"]["rpc"])
+    @exportRpc(viewer_prefix + viewer_schemas_dict["render"]["rpc"])
     def renderNow(self, params: RpcParams) -> None:
-        validate_schema(
-            params, self.viewer_schemas_dict["render_now"], self.viewer_prefix
-        )
+        validate_schema(params, self.viewer_schemas_dict["render"], self.viewer_prefix)
         self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["set_z_scaling"]["rpc"])
@@ -302,4 +289,3 @@ def setZScaling(self, params: RpcParams) -> None:
         if "grid_scale" in self.get_data_base():
             cube_axes_actor = self.get_object("grid_scale")["actor"]
             cube_axes_actor.SetUse2DMode(1)
-        self.render()

tests/conftest.py

@@ -11,6 +11,7 @@
 from opengeodeweb_viewer import config
 from opengeodeweb_microservice.database.connection import get_session, init_database
 from opengeodeweb_microservice.database.data import Data
+from opengeodeweb_viewer.rpc.viewer.viewer_protocols import VtkViewerView
 
 type RpcTestParams = list[
     dict[str, str | int | float | bool | dict[str, int] | list[str]] | int
@@ -38,7 +39,7 @@ def call(self, rpc: str, params: RpcTestParams = None) -> None:
         self.ws.send(
             json.dumps(
                 {
-                    "id": "rpc:test",
+                    "id": "rpc:" + rpc,
                     "method": rpc,
                     "args": params,
                 }
@@ -98,29 +99,27 @@ def images_diff(self, first_image_path: str, second_image_path: str) -> float:
         print(f"{images_diff.GetThresholdedError()=}")
         return images_diff.GetThresholdedError()
 
-    def compare_image(self, nb_messages: int, filename: str) -> bool:
-        for message in range(nb_messages):
-            print(f"{message=}", flush=True)
+    def compare_image(self, filename: str) -> bool:
+        self.call(
+            VtkViewerView.viewer_prefix
+            + VtkViewerView.viewer_schemas_dict["render"]["rpc"]
+        )
+        while True:
             image = self.ws.recv()
             if isinstance(image, bytes):
+                response = self.ws.recv()
+                print(f"{response=}", flush=True)
+                format = json.loads(response)["result"]["format"]
                 test_file_path = os.path.abspath(
-                    os.path.join(self.test_output_dir, "test.jpeg")
+                    os.path.join(self.test_output_dir, f"test.{format}")
                 )
                 with open(test_file_path, "wb") as f:
                     f.write(image)
                     f.close()
-        if isinstance(image, bytes):
-            response = self.ws.recv()
-            print(f"{response=}", flush=True)
-            format = json.loads(response)["result"]["format"]
-            test_file_path = os.path.abspath(
-                os.path.join(self.test_output_dir, f"test.{format}")
-            )
-            with open(test_file_path, "wb") as f:
-                f.write(image)
-                f.close()
-            path_image = os.path.join(self.images_dir_path, filename)
-            return self.images_diff(test_file_path, path_image) == 0.0
+                path_image = os.path.join(self.images_dir_path, filename)
+                return self.images_diff(test_file_path, path_image) == 0.0
+            else:
+                print("response =", image, flush=True)
         return False
 
     def _init_ws(self) -> None:
@@ -140,10 +139,8 @@ def _drain_initial_messages(
     ) -> None:
         self.ws.settimeout(timeout)
         for i in range(max_messages):
-            print(f"{i=}", flush=True)
             try:
                 response = self.ws.recv()
-                print(f"{response=}", flush=True)
             except WebSocketTimeoutException:
                 print(
                     f"Timeout on message {i}, but continuing to try remaining messages...",

tests/data/images/viewer/render_now.jpeg renamed to tests/data/images/viewer/render.jpeg

@@ -20,7 +20,7 @@ def test_edges_visibility(
         + VtkMeshEdgesView.mesh_edges_schemas_dict["visibility"]["rpc"],
         [{"id": "123456789", "visibility": True}],
     )
-    assert server.compare_image(3, "mesh/edges/visibility.jpeg") == True
+    assert server.compare_image("mesh/edges/visibility.jpeg") == True
 
 
 def test_edges_color(
@@ -33,7 +33,7 @@ def test_edges_color(
         + VtkMeshEdgesView.mesh_edges_schemas_dict["color"]["rpc"],
         [{"id": "123456789", "color": {"r": 255, "g": 0, "b": 0}}],
     )
-    assert server.compare_image(3, "mesh/edges/color.jpeg") == True
+    assert server.compare_image("mesh/edges/color.jpeg") == True
 
 
 def test_edges_with_edged_curve(
@@ -45,18 +45,18 @@ def test_edges_with_edged_curve(
         VtkMeshView.mesh_prefix + VtkMeshView.mesh_schemas_dict["register"]["rpc"],
         [{"id": "123456789"}],
     )
-    assert server.compare_image(3, "mesh/edges/register_edged_curve.jpeg") == True
+    assert server.compare_image("mesh/edges/register_edged_curve.jpeg") == True
 
     server.call(
         VtkMeshEdgesView.mesh_edges_prefix
         + VtkMeshEdgesView.mesh_edges_schemas_dict["color"]["rpc"],
         [{"id": "123456789", "color": {"r": 255, "g": 0, "b": 0}}],
     )
-    assert server.compare_image(3, "mesh/edges/edged_curve_color.jpeg") == True
+    assert server.compare_image("mesh/edges/edged_curve_color.jpeg") == True
 
     server.call(
         VtkMeshEdgesView.mesh_edges_prefix
         + VtkMeshEdgesView.mesh_edges_schemas_dict["visibility"]["rpc"],
         [{"id": "123456789", "visibility": False}],
     )
-    assert server.compare_image(3, "mesh/edges/edged_curve_visibility.jpeg") == True
+    assert server.compare_image("mesh/edges/edged_curve_visibility.jpeg") == True