Feat/new rpcs

.gitignore

@@ -9,4 +9,5 @@ __pycache__/
 latest_logs
 schemas.json
 build
+src/tests/tests_output/
 *.egg-info

generate_schemas.js

@@ -62,7 +62,7 @@ function return_json_schema(directoryPath, folder_path, project_name) {
         return acc;
       }, folders_schemas);
     } else {
-      var new_folder_path = folder_path + "/" + folder.name;
+      var new_folder_path = folder_path + "." + folder.name;
       var test = return_json_schema(folder.path, new_folder_path, project_name);
       folders_schemas[folder.name] = test;
     }

pyproject.toml

@@ -36,7 +36,10 @@ dependencies = {file = ["requirements.txt"]}
 where = ["src"]
 
 [tool.setuptools.package-data]
-"opengeodeweb_viewer.rpc.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.viewer.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.mesh.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.schemas" = ["*.json"]
+
 
 [tool.semantic_release]
 version_toml = [

src/opengeodeweb_viewer/__init__.py

@@ -1,3 +1,3 @@
 from .config import *
-from .function import *
+from .utils_functions import *
 from .vtk_protocol import *

src/opengeodeweb_viewer/config.py

@@ -24,9 +24,11 @@ def dev_config():
         os.mkdir(os.environ.get("DATA_FOLDER_PATH"))
 
 
-def test_config():
+def test_config(path):
     default_config()
     print(f"{os.path.dirname(__file__)=}", flush=True)
-    os.environ["DATA_FOLDER_PATH"] = os.path.join(
-        os.path.dirname(__file__), "..", "tests", "data"
+    os.environ["DATA_FOLDER_PATH"] = os.path.join(path, 
+     "data"
     )
+
+    print(f"{os.environ.get('DATA_FOLDER_PATH')=}", flush=True)

src/opengeodeweb_viewer/object/object_methods.py

@@ -0,0 +1,123 @@
+# Standard library imports
+import os
+
+# Third party imports
+import vtk
+
+# Local application imports
+from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.vtk_protocol import VtkView
+
+class VtkObjectView(VtkView):
+    def __init__(self):
+        super().__init__()
+
+    def register(self, id, file_name, reader, filter, mapper):
+        actor = vtk.vtkActor()
+        self.register_object(id, reader, filter, actor, mapper, {})
+
+        reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, file_name))
+
+        actor.SetMapper(mapper)
+        mapper.SetColorModeToMapScalars()
+        mapper.SetResolveCoincidentTopologyLineOffsetParameters(1, -0.1)
+        mapper.SetResolveCoincidentTopologyPolygonOffsetParameters(2, 0)
+        mapper.SetResolveCoincidentTopologyPointOffsetParameter(-2)
+
+        renderWindow = self.getView("-1")
+        renderer = renderWindow.GetRenderers().GetFirstRenderer()
+        renderer.AddActor(actor)
+        renderer.ResetCamera()
+        renderWindow.Render()
+        self.render()
+
+    def deregister(self, id):
+        actor = self.get_object(id)["actor"]
+        renderWindow = self.getView("-1")
+        renderer = renderWindow.GetRenderers().GetFirstRenderer()
+        renderer.RemoveActor(actor)
+        self.deregister_object(id)
+        self.render()
+
+    def applyTextures(self, id, textures):
+        textures_array = []
+        images_reader_array = []
+
+        data = self.get_object(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"]
+            texture_file_name = value["texture_file_name"]
+            print(f"{texture_name=} {texture_file_name=}", flush=True)
+
+            new_texture = vtk.vtkTexture()
+            image_reader = vtk.vtkXMLImageDataReader()
+            image_reader.SetFileName(
+                os.path.join(self.DATA_FOLDER_PATH, texture_file_name)
+            )
+
+            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, id, visibility):
+        actor = self.get_object(id)["actor"]
+        actor.SetVisibility(visibility)
+        self.render()
+
+    def SetOpacity(self, id, opacity):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetOpacity(opacity)
+        self.render()
+
+    def SetColor(self, id, red, green, blue):
+        reader = super().get_object(id)["reader"]
+        mapper = self.get_object(id)["mapper"]
+        mapper.ScalarVisibilityOff()
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetColor([red, green, blue])
+        self.render()
+
+    def SetEdgeVisibility(self, id, visibility):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetEdgeVisibility(visibility)
+        self.render()
+
+    def SetVertexVisibility(self, id, visibility):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetVertexVisibility(visibility)
+        self.render()
+
+    def SetPointSize(self, id, size):
+        actor = self.get_object(id)["actor"]
+        actor.GetProperty().SetPointSize(size)
+        self.render()

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -0,0 +1,124 @@
+# Standard library imports
+import json
+import os
+
+# Third party imports
+import vtk
+from vtk.web import protocols as vtk_protocols
+from vtkmodules.vtkIOImage import vtkPNGWriter, vtkJPEGWriter
+from vtkmodules.vtkRenderingCore import (vtkWindowToImageFilter)
+from wslink import register as exportRpc
+
+# Local application imports
+from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+from opengeodeweb_viewer.object.object_methods import VtkObjectView
+
+
+schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
+schemas_dict = get_schemas_dict(schemas_dir)
+
+class VtkMeshView(VtkObjectView):
+    def __init__(self):
+        super().__init__()
+
+    @exportRpc(schemas_dict["register"]["rpc"])
+    def register(self, params):
+        print(schemas_dict["register"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["register"])
+        id = params["id"]
+        file_name = params["file_name"]
+        try:
+            reader = vtk.vtkXMLGenericDataObjectReader()
+            filter = {}
+            mapper = vtk.vtkDataSetMapper()
+            mapper.SetInputConnection(reader.GetOutputPort())
+            super().register(id, file_name, reader, filter, mapper)
+        except Exception as e:
+            print("error : ", str(e), flush=True)
+
+    @exportRpc(schemas_dict["deregister"]["rpc"])
+    def deregisterMesh(self, params):
+        print(schemas_dict["deregister"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["deregister"])
+        id = params["id"]
+        super().deregister(id)
+
+    @exportRpc(schemas_dict["set_visibility"]["rpc"])
+    def SetVisibility(self, params):
+        print(schemas_dict["set_visibility"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetVisibility(id, visibility)
+
+    @exportRpc(schemas_dict["set_opacity"]["rpc"])
+    def SetOpacity(self, params):
+        print(schemas_dict["set_opacity"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_opacity"])
+        id = params["id"]
+        opacity = float(params["opacity"])
+        super().SetOpacity(id, opacity)
+
+    @exportRpc(schemas_dict["set_edge_visibility"]["rpc"])
+    def setEdgeVisibility(self, params):
+        print(schemas_dict["set_edge_visibility"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_edge_visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetEdgeVisibility(id, visibility)
+
+    @exportRpc(schemas_dict["set_point_visibility"]["rpc"])
+    def setPointVisibility(self, params):
+        print(schemas_dict["set_point_visibility"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_point_visibility"])
+        id = params["id"]
+        visibility = bool(params["visibility"])
+        super().SetVertexVisibility(id, visibility)
+
+    @exportRpc(schemas_dict["set_point_size"]["rpc"])
+    def setPointSize(self, params):
+        print(schemas_dict["set_point_size"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_point_size"])
+        id = params["id"]
+        size = float(params["size"])
+        super().SetPointSize(id, size)
+
+    @exportRpc(schemas_dict["set_color"]["rpc"])
+    def setColor(self, params):
+        print(schemas_dict["set_color"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["set_color"])
+        id = params["id"]
+        red = params["red"]
+        green = params["green"]
+        blue = params["blue"]
+        super().SetColor(id, red, green, blue)
+
+    @exportRpc(schemas_dict["display_vertex_attribute"]["rpc"])
+    def setVertexAttribute(self, params):
+        print(schemas_dict["display_vertex_attribute"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["display_vertex_attribute"])
+        id = params["id"]
+        name = params["name"]
+        reader = super().get_object(id)["reader"]
+        points = reader.GetOutput().GetPointData()
+        points.SetActiveScalars(name)
+        mapper = super().get_object(id)["mapper"]
+        mapper.ScalarVisibilityOn()
+        mapper.SetScalarModeToUsePointData()
+        mapper.SetScalarRange(points.GetScalars().GetRange())
+        super().render()
+
+    @exportRpc(schemas_dict["display_polygon_attribute"]["rpc"])
+    def setPolygonAttribute(self, params):
+        print(schemas_dict["display_polygon_attribute"]["rpc"], params, flush=True)
+        validate_schema(params, schemas_dict["display_polygon_attribute"])
+        id = params["id"]
+        name = params["name"]
+        reader = super().get_object(id)["reader"]
+        cells = reader.GetOutput().GetCellData()
+        cells.SetActiveScalars(name)
+        mapper = super().get_object(id)["mapper"]
+        mapper.ScalarVisibilityOn()
+        mapper.SetScalarModeToUseCellData()
+        mapper.SetScalarRange(cells.GetScalars().GetRange())
+        super().render()

src/opengeodeweb_viewer/rpc/schemas/apply_textures.json → src/opengeodeweb_viewer/rpc/mesh/schemas/apply_textures.json

@@ -17,12 +17,18 @@
             "type": "string"
           }
         },
-        "required": ["texture_name", "texture_file_name"],
+        "required": [
+          "texture_name",
+          "texture_file_name"
+        ],
         "additionalProperties": false
       },
       "minItems": 1
     }
   },
-  "required": ["id", "textures"],
+  "required": [
+    "id",
+    "textures"
+  ],
   "additionalProperties": false
-}
+}

src/opengeodeweb_viewer/rpc/schemas/delete_object_pipeline.json → src/opengeodeweb_viewer/rpc/mesh/schemas/deregister.json

@@ -1,11 +1,13 @@
 {
-  "rpc": "delete_object_pipeline",
+  "rpc": "mesh.deregister",
   "type": "object",
   "properties": {
     "id": {
       "type": "string"
     }
   },
-  "required": ["id"],
+  "required": [
+    "id"
+  ],
   "additionalProperties": false
-}
+}

src/opengeodeweb_viewer/rpc/mesh/schemas/display_polygon_attribute.json

@@ -0,0 +1,17 @@
+{
+  "rpc": "mesh.display_polygon_attribute",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string"
+    },
+    "name": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "id",
+    "name"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/schemas/set_vertex_attribute.json → src/opengeodeweb_viewer/rpc/mesh/schemas/display_vertex_attribute.json

@@ -1,5 +1,5 @@
 {
-  "rpc": "set_vertex_attribute",
+  "rpc": "mesh.display_vertex_attribute",
   "type": "object",
   "properties": {
     "id": {
@@ -9,6 +9,9 @@
       "type": "string"
     }
   },
-  "required": ["id", "name"],
+  "required": [
+    "id",
+    "name"
+  ],
   "additionalProperties": false
-}
+}