Next

.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;
     }

package.json

@@ -1,7 +1,8 @@
 {
   "name": "@geode/opengeodeweb-viewer",
   "scripts": {
-    "json": "node generate_schemas.js"
+    "json": "node generate_schemas.js",
+    "test": "npm run json && pytest"
   },
   "dependencies": {
     "glob": "^10.3.10"

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Viewer"
-version = "0.3.0"
+version = "1.0.0-rc.4"
 dynamic = ["dependencies"]
 authors = [
   { name="Geode-solutions", email="[email protected]" },
@@ -36,7 +36,11 @@ dependencies = {file = ["requirements.txt"]}
 where = ["src"]
 
 [tool.setuptools.package-data]
-"opengeodeweb_viewer.rpc.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.generic.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.mesh.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.model.schemas" = ["*.json"]
+"opengeodeweb_viewer.rpc.viewer.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 registerObject(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 deregisterObject(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 = self.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/generic/generic_protocols.py

@@ -0,0 +1,48 @@
+# Standard library imports
+import json
+import os
+
+# Third party imports
+import vtk
+from vtk.web import protocols as vtk_protocols
+from wslink import register as exportRpc
+
+# Local application imports
+from opengeodeweb_viewer.vtk_protocol import VtkView
+from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
+from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
+from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
+
+class VtkGenericView(VtkView):
+    prefix = "opengeodeweb_viewer.generic."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
+    def __init__(self, mesh_protocols, model_protocols):
+        super().__init__()
+        self.mesh_protocols = mesh_protocols
+        self.model_protocols = model_protocols
+
+    @exportRpc(prefix + schemas_dict["register"]["rpc"])
+    def register(self, params):
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
+        viewer_object = params["viewer_object"]
+        params.pop('viewer_object', None)
+        print(f"{params=}", flush=True)
+        if viewer_object == "mesh":
+            self.mesh_protocols.registerMesh(params)
+        elif viewer_object == "model":
+            self.model_protocols.registerModel(params)
+
+    @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
+    def deregister(self, params):
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
+        viewer_object = params["viewer_object"]
+        params.pop('viewer_object', None)
+        if viewer_object == "mesh":
+            self.mesh_protocols.deregisterMesh(params)
+        elif viewer_object == "model":
+            self.model_protocols.deregisterModel(params)
+
+

src/opengeodeweb_viewer/rpc/generic/schemas/deregister.json

@@ -0,0 +1,18 @@
+{
+  "rpc": "deregister",
+  "type": "object",
+  "properties": {
+    "viewer_object": {
+      "type": "string",
+      "enum": ["mesh", "model"]
+    },
+    "id": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "viewer_object",
+    "id"
+  ],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/generic/schemas/register.json

@@ -0,0 +1,22 @@
+{
+  "rpc": "register",
+  "type": "object",
+  "properties": {
+    "viewer_object": {
+      "type": "string",
+      "enum": ["mesh", "model"]
+    },
+    "id": {
+      "type": "string"
+    },
+    "file_name": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "viewer_object",
+    "id",
+    "file_name"
+  ],
+  "additionalProperties": false
+}