Fix/no render

opengeodeweb_viewer_schemas.json

@@ -1304,9 +1304,9 @@
         "required": [],
         "additionalProperties": false
       },
-      "render_now": {
-        "$id": "opengeodeweb_viewer.viewer.render_now",
-        "rpc": "render_now",
+      "render": {
+        "$id": "opengeodeweb_viewer.viewer.render",
+        "rpc": "render",
         "type": "object",
         "properties": {},
         "required": [],

requirements.txt

@@ -61,4 +61,3 @@ wslink==1.12.4
 yarl>=1
     # via aiohttp
 
-opengeodeweb-microservice==1.*,>=1.0.8

src/opengeodeweb_viewer/object/object_methods.py

@@ -31,81 +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(data.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[vtkTexture] = []
-        images_reader_array: list[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 = vtkTexture()
-            image_reader = 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,
-                vtkDataObject.FIELD_ASSOCIATION_POINTS,
-            )
-
-            if index == 0:
-                new_texture.SetBlendingMode(
-                    vtkTexture.VTK_TEXTURE_BLENDING_MODE_REPLACE
-                )
-            else:
-                new_texture.SetBlendingMode(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
@@ -114,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
@@ -128,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
@@ -137,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
@@ -151,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

@@ -128,7 +128,6 @@ def meshApplyTextures(self, rpc_params: RpcParams) -> None:
                     break
             actor = 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
@@ -138,7 +137,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
@@ -148,4 +146,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/__init__.py

@@ -5,7 +5,7 @@
 from .set_background_color import *
 from .reset_visualization import *
 from .reset_camera import *
-from .render_now import *
+from .render import *
 from .picked_ids import *
 from .grid_scale import *
 from .get_point_position import *

src/opengeodeweb_viewer/rpc/viewer/schemas/render_now.json → 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/schemas/render_now.py → src/opengeodeweb_viewer/rpc/viewer/schemas/render.py

@@ -3,5 +3,5 @@
 
 
 @dataclass
-class RenderNow(DataClassJsonMixin):
+class Render(DataClassJsonMixin):
     pass

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -93,8 +93,6 @@ def resetVisualization(self, rpc_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, rpc_params: RpcParams) -> None:
@@ -109,9 +107,6 @@ def setBackgroundColor(self, rpc_params: RpcParams) -> None:
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
 
         renderer.SetBackground([color.r / 255, color.g / 255, color.b / 255])
-        renderer.ResetCamera()
-        renderWindow.Render()
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["reset_camera"]["rpc"])
     def resetCamera(self, rpc_params: RpcParams) -> None:
@@ -120,8 +115,6 @@ def resetCamera(self, rpc_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, rpc_params: RpcParams) -> dict[str, str | bytes]:
@@ -187,7 +180,6 @@ def updateData(self, rpc_params: RpcParams) -> None:
             tag,
         )
         mapper.SetScalarRange(scalars.GetRange())
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["get_point_position"]["rpc"])
     def getPointPosition(self, rpc_params: RpcParams) -> dict[str, float]:
@@ -251,7 +243,6 @@ def toggleGridScale(self, rpc_params: RpcParams) -> None:
         grid_scale = self.get_grid_scale()
         if grid_scale is not None:
             grid_scale.SetVisibility(params.visibility)
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["axes"]["rpc"])
     def toggleAxes(self, rpc_params: RpcParams) -> None:
@@ -262,7 +253,6 @@ def toggleAxes(self, rpc_params: RpcParams) -> None:
         axes = self.get_axes()
         if axes is not None:
             axes.SetVisibility(params.visibility)
-        self.render()
 
     @exportRpc(viewer_prefix + viewer_schemas_dict["update_camera"]["rpc"])
     def updateCamera(self, rpc_params: RpcParams) -> None:
@@ -280,12 +270,11 @@ def updateCamera(self, rpc_params: RpcParams) -> None:
         camera.SetPosition(camera_options.position)
         camera.SetViewAngle(camera_options.view_angle)
         camera.SetClippingRange(camera_options.clipping_range)
-        self.render()
 
-    @exportRpc(viewer_prefix + viewer_schemas_dict["render_now"]["rpc"])
+    @exportRpc(viewer_prefix + viewer_schemas_dict["render"]["rpc"])
     def renderNow(self, rpc_params: RpcParams) -> None:
         validate_schema(
-            rpc_params, self.viewer_schemas_dict["render_now"], self.viewer_prefix
+            rpc_params, self.viewer_schemas_dict["render"], self.viewer_prefix
         )
         self.render()
 
@@ -304,4 +293,3 @@ def setZScaling(self, rpc_params: RpcParams) -> None:
         grid_scale = self.get_grid_scale()
         if grid_scale is not None:
             grid_scale.SetUse2DMode(True)
-        self.render()

tests/conftest.py

@@ -12,6 +12,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
@@ -39,7 +40,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,
                 }
@@ -100,6 +101,10 @@ def images_diff(self, first_image_path: str, second_image_path: str) -> float:
         return images_diff.GetThresholdedError()
 
     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):

tests/test_viewer_protocols.py

@@ -250,7 +250,7 @@ def test_update_camera(
     assert server.compare_image("viewer/update_camera.jpeg") == True
 
 
-def test_render_now(server: ServerMonitor, dataset_factory: Callable[..., str]) -> None:
+def test_render(server: ServerMonitor, dataset_factory: Callable[..., str]) -> None:
     test_register_mesh(server, dataset_factory)
 
     camera_options = {
@@ -274,10 +274,10 @@ def test_render_now(server: ServerMonitor, dataset_factory: Callable[..., str])
 
     server.call(
         VtkViewerView.viewer_prefix
-        + VtkViewerView.viewer_schemas_dict["render_now"]["rpc"],
+        + VtkViewerView.viewer_schemas_dict["render"]["rpc"],
     )
 
-    assert server.compare_image("viewer/render_now.jpeg") == True
+    assert server.compare_image("viewer/render.jpeg") == True
 
 
 def test_set_z_scaling(