Feat/model components tools

requirements.txt

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

src/opengeodeweb_viewer/object/object_methods.py

@@ -42,16 +42,35 @@ def registerObject(
             if actor.visibility == True:
                 resetCamara = False
         renderer.AddActor(data.actor)
+        for category_actor in data.category_actors.values():
+            renderer.AddActor(category_actor)
         if resetCamara:
             renderer.ResetCamera()
 
     def deregisterObject(self, data_id: str) -> None:
-        actor = self.get_vtk_pipeline(data_id).actor
+        pipeline = self.get_vtk_pipeline(data_id)
+        actor = pipeline.actor
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.RemoveActor(actor)
+        for category_actor in pipeline.category_actors.values():
+            renderer.RemoveActor(category_actor)
         self.deregister_object(data_id)
 
+    def SetCategoryEdgesVisibility(
+        self, data_id: str, category: str, visibility: bool
+    ) -> None:
+        actor = self.get_vtk_pipeline(data_id).category_actors.get(category)
+        if actor is not None:
+            actor.GetProperty().SetEdgeVisibility(visibility)
+
+    def SetCategoryPointsVisibility(
+        self, data_id: str, category: str, visibility: bool
+    ) -> None:
+        actor = self.get_vtk_pipeline(data_id).category_actors.get(category)
+        if actor is not None:
+            actor.GetProperty().SetVertexVisibility(visibility)
+
     def SetVisibility(self, data_id: str, visibility: bool) -> None:
         actor = self.get_vtk_pipeline(data_id).actor
         actor.SetVisibility(visibility)

src/opengeodeweb_viewer/rpc/model/blocks/edges/model_surfaces_edges_protocols.py

@@ -0,0 +1,57 @@
+# Standard library imports
+import os
+
+# Third party imports
+from wslink import register as exportRpc
+from opengeodeweb_microservice.schemas import get_schemas_dict
+
+# Local application imports
+from opengeodeweb_viewer.utils_functions import validate_schema, RpcParams
+from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
+from . import schemas
+
+
+class VtkModelBlocksEdgesView(VtkModelView):
+    model_blocks_edges_prefix = "opengeodeweb_viewer.model.blocks.edges."
+    model_blocks_edges_schemas_dict = get_schemas_dict(
+        os.path.join(os.path.dirname(__file__), "schemas")
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @exportRpc(
+        model_blocks_edges_prefix + model_blocks_edges_schemas_dict["visibility"]["rpc"]
+    )
+    def setModelBlocksEdgesVisibility(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_edges_schemas_dict["visibility"],
+            self.model_blocks_edges_prefix,
+        )
+        params = schemas.Visibility.from_dict(rpc_params)
+        self.SetEdgesVisibility(params.id, params.visibility)
+
+    @exportRpc(
+        model_blocks_edges_prefix + model_blocks_edges_schemas_dict["color"]["rpc"]
+    )
+    def setModelBlocksEdgesColor(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_edges_schemas_dict["color"],
+            self.model_blocks_edges_prefix,
+        )
+        params = schemas.Color.from_dict(rpc_params)
+        self.SetEdgesColor(params.id, params.color.r, params.color.g, params.color.b)
+
+    @exportRpc(
+        model_blocks_edges_prefix + model_blocks_edges_schemas_dict["width"]["rpc"]
+    )
+    def setModelBlocksEdgesWidth(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_edges_schemas_dict["width"],
+            self.model_blocks_edges_prefix,
+        )
+        params = schemas.Width.from_dict(rpc_params)
+        self.SetEdgesWidth(params.id, params.width)

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/__init__.py

@@ -0,0 +1,3 @@
+from .width import *
+from .visibility import *
+from .color import *

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/color.json

@@ -0,0 +1,40 @@
+{
+  "rpc": "color",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "color": {
+      "type": "object",
+      "properties": {
+        "r": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "g": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "b": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "a": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "default": 1
+        }
+      },
+      "required": ["r", "g", "b"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["id", "color"],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/color.py

@@ -0,0 +1,23 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ColorClass(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    b: int
+    g: int
+    r: int
+    a: Optional[float] = None
+
+
+@dataclass
+class Color(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    color: ColorClass
+    id: str

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/visibility.json

@@ -0,0 +1,15 @@
+{
+  "rpc": "visibility",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "visibility": {
+      "type": "boolean"
+    }
+  },
+  "required": ["id", "visibility"],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/visibility.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Visibility(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str
+    visibility: bool

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/width.json

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

src/opengeodeweb_viewer/rpc/model/blocks/edges/schemas/width.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Width(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str
+    width: float

src/opengeodeweb_viewer/rpc/model/blocks/points/model_surfaces_points_protocols.py

@@ -0,0 +1,53 @@
+import os
+from wslink import register as exportRpc
+from opengeodeweb_microservice.schemas import get_schemas_dict
+from opengeodeweb_viewer.utils_functions import validate_schema, RpcParams
+from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
+from . import schemas
+
+
+class VtkModelBlocksPointsView(VtkModelView):
+    model_blocks_points_prefix = "opengeodeweb_viewer.model.blocks.points."
+    model_blocks_points_schemas_dict = get_schemas_dict(
+        os.path.join(os.path.dirname(__file__), "schemas")
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @exportRpc(
+        model_blocks_points_prefix
+        + model_blocks_points_schemas_dict["visibility"]["rpc"]
+    )
+    def setModelBlocksPointsVisibility(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_points_schemas_dict["visibility"],
+            self.model_blocks_points_prefix,
+        )
+        params = schemas.Visibility.from_dict(rpc_params)
+        self.SetPointsVisibility(params.id, params.visibility)
+
+    @exportRpc(
+        model_blocks_points_prefix + model_blocks_points_schemas_dict["size"]["rpc"]
+    )
+    def setModelBlocksPointsSize(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_points_schemas_dict["size"],
+            self.model_blocks_points_prefix,
+        )
+        params = schemas.Size.from_dict(rpc_params)
+        self.SetPointsSize(params.id, params.size)
+
+    @exportRpc(
+        model_blocks_points_prefix + model_blocks_points_schemas_dict["color"]["rpc"]
+    )
+    def setModelBlocksPointsColor(self, rpc_params: RpcParams) -> None:
+        validate_schema(
+            rpc_params,
+            self.model_blocks_points_schemas_dict["color"],
+            self.model_blocks_points_prefix,
+        )
+        params = schemas.Color.from_dict(rpc_params)
+        self.SetPointsColor(params.id, params.color.r, params.color.g, params.color.b)

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/__init__.py

@@ -0,0 +1,3 @@
+from .visibility import *
+from .size import *
+from .color import *

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/color.json

@@ -0,0 +1,40 @@
+{
+  "rpc": "color",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "color": {
+      "type": "object",
+      "properties": {
+        "r": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "g": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "b": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 255
+        },
+        "a": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "default": 1
+        }
+      },
+      "required": ["r", "g", "b"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["id", "color"],
+  "additionalProperties": false
+}

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/color.py

@@ -0,0 +1,23 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ColorClass(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    b: int
+    g: int
+    r: int
+    a: Optional[float] = None
+
+
+@dataclass
+class Color(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    color: ColorClass
+    id: str

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/size.json

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

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/size.py

@@ -0,0 +1,11 @@
+from dataclasses_json import DataClassJsonMixin
+from dataclasses import dataclass
+
+
+@dataclass
+class Size(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print(self, flush=True)
+
+    id: str
+    size: float

src/opengeodeweb_viewer/rpc/model/blocks/points/schemas/visibility.json

@@ -0,0 +1,15 @@
+{
+  "rpc": "visibility",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "visibility": {
+      "type": "boolean"
+    }
+  },
+  "required": ["id", "visibility"],
+  "additionalProperties": false
+}