Skip to content

Commit 297b005

Browse files
JulienChampagnolJulienChampagnol
committed
feat(generic rpcs): refactor all classes/tests
generic rpc for register/deregister
1 parent 07610d8 commit 297b005

File tree

11 files changed

+121
-135
lines changed

11 files changed

+121
-135
lines changed

‎src/opengeodeweb_viewer/generic/generic_protocols.py‎

Lines changed: 14 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -13,44 +13,35 @@
1313
from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
1414
from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
1515

16-
schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
17-
schemas_dict = get_schemas_dict(schemas_dir)
18-
prefix = "opengeodeweb_viewer."
19-
2016
class VtkGenericView(VtkView):
21-
def __init__(self):
17+
prefix = "opengeodeweb_viewer."
18+
schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
19+
20+
def __init__(self, mesh_protocols, model_protocols):
2221
super().__init__()
23-
self.prefix = prefix
24-
self.schemas_dict = schemas_dict
22+
self.mesh_protocols = mesh_protocols
23+
self.model_protocols = model_protocols
2524

2625
@exportRpc(prefix + schemas_dict["register"]["rpc"])
2726
def register(self, params):
28-
29-
print(f"{schemas_dict=}", flush=True)
30-
print(f"{params=}", flush=True)
31-
validate_schema(params, schemas_dict["register"])
27+
print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
28+
validate_schema(params, self.schemas_dict["register"])
3229
viewer_object = params["viewer_object"]
3330
params.pop('viewer_object', None)
3431
print(f"{params=}", flush=True)
3532
if viewer_object == "mesh":
36-
print(f"MESH", flush=True)
37-
class_ = VtkMeshView()
38-
class_.registerMesh(params)
33+
self.mesh_protocols.registerMesh(params)
3934
elif viewer_object == "model":
40-
print(f"MODEL", flush=True)
41-
class_ = VtkModelView()
42-
class_.registerModel(params)
35+
self.model_protocols.registerModel(params)
4336

4437
@exportRpc(prefix + schemas_dict["deregister"]["rpc"])
4538
def deregister(self, params):
46-
validate_schema(params, schemas_dict["deregister"])
39+
print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
40+
validate_schema(params, self.schemas_dict["deregister"])
4741
viewer_object = params["viewer_object"]
4842
params.pop('viewer_object', None)
4943
if viewer_object == "mesh":
50-
VtkMeshView.registerMesh(self, params)
44+
self.mesh_protocols.deregisterMesh(params)
5145
elif viewer_object == "model":
52-
VtkModelView.registerModel(self, params)
53-
54-
55-
46+
self.model_protocols.deregisterModel(params)
5647

‎src/opengeodeweb_viewer/object/object_methods.py‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@ def registerObject(self, id, file_name, reader, filter, mapper):
1616
actor = vtk.vtkActor()
1717
self.register_object(id, reader, filter, actor, mapper, {})
1818

19-
print("registerObject", flush=True)
2019
reader.SetFileName(os.path.join(self.DATA_FOLDER_PATH, file_name))
2120

2221
actor.SetMapper(mapper)
@@ -120,13 +119,5 @@ def SetVertexVisibility(self, id, visibility):
120119

121120
def SetPointSize(self, id, size):
122121
actor = self.get_object(id)["actor"]
123-
124-
actor.GetProperty().EdgeVisibilityOn()
125-
actor.GetProperty().VertexVisibilityOn()
126122
actor.GetProperty().SetPointSize(size)
127-
print("GetEdgeVisibility", actor.GetProperty().GetEdgeVisibility(), flush=True)
128-
print("GetVertexVisibility", actor.GetProperty().GetVertexVisibility(), flush=True)
129-
print("GetPointSize", actor.GetProperty().GetPointSize(), flush=True)
130-
131-
print("vtk.vtkRenderWindow().GetClassName()", vtk.vtkRenderWindow().GetClassName())
132123
self.render()

‎src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py‎

Lines changed: 24 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -13,20 +13,17 @@
1313
from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
1414
from opengeodeweb_viewer.object.object_methods import VtkObjectView
1515

16-
schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
17-
schemas_dict = get_schemas_dict(schemas_dir)
18-
prefix = "opengeodeweb_viewer.mesh."
19-
2016
class VtkMeshView(VtkObjectView):
17+
prefix = "opengeodeweb_viewer.mesh."
18+
schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
19+
2120
def __init__(self):
2221
super().__init__()
23-
self.prefix = prefix
24-
self.schemas_dict = schemas_dict
2522

2623
@exportRpc(prefix + schemas_dict["register"]["rpc"])
2724
def registerMesh(self, params):
28-
print(schemas_dict["register"]["rpc"], params, flush=True)
29-
validate_schema(params, schemas_dict["register"])
25+
print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
26+
validate_schema(params, self.schemas_dict["register"])
3027
id = params["id"]
3128
file_name = params["file_name"]
3229
try:
@@ -41,55 +38,56 @@ def registerMesh(self, params):
4138

4239
@exportRpc(prefix + schemas_dict["deregister"]["rpc"])
4340
def deregisterMesh(self, params):
44-
print(schemas_dict["deregister"]["rpc"], params, flush=True)
45-
validate_schema(params, schemas_dict["deregister"])
41+
print("deregisterMesh")
42+
print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
43+
validate_schema(params, self.schemas_dict["deregister"])
4644
id = params["id"]
4745
self.deregisterObject(id)
4846

4947
@exportRpc(prefix + schemas_dict["set_visibility"]["rpc"])
5048
def SetMeshVisibility(self, params):
51-
print(schemas_dict["set_visibility"]["rpc"], params, flush=True)
52-
validate_schema(params, schemas_dict["set_visibility"])
49+
print(self.schemas_dict["set_visibility"]["rpc"], f"{params=}", flush=True)
50+
validate_schema(params, self.schemas_dict["set_visibility"])
5351
id = params["id"]
5452
visibility = bool(params["visibility"])
5553
self.SetVisibility(id, visibility)
5654

5755
@exportRpc(prefix + schemas_dict["set_opacity"]["rpc"])
5856
def setMeshOpacity(self, params):
59-
print(schemas_dict["set_opacity"]["rpc"], params, flush=True)
60-
validate_schema(params, schemas_dict["set_opacity"])
57+
print(self.schemas_dict["set_opacity"]["rpc"], f"{params=}", flush=True)
58+
validate_schema(params, self.schemas_dict["set_opacity"])
6159
id = params["id"]
6260
opacity = float(params["opacity"])
6361
self.SetOpacity(id, opacity)
6462

6563
@exportRpc(prefix + schemas_dict["set_edge_visibility"]["rpc"])
6664
def setMeshEdgeVisibility(self, params):
67-
print(schemas_dict["set_edge_visibility"]["rpc"], params, flush=True)
68-
validate_schema(params, schemas_dict["set_edge_visibility"])
65+
print(self.schemas_dict["set_edge_visibility"]["rpc"], f"{params=}", flush=True)
66+
validate_schema(params, self.schemas_dict["set_edge_visibility"])
6967
id = params["id"]
7068
visibility = bool(params["visibility"])
7169
self.SetEdgeVisibility(id, visibility)
7270

7371
@exportRpc(prefix + schemas_dict["set_point_visibility"]["rpc"])
7472
def setMeshPointVisibility(self, params):
75-
print(schemas_dict["set_point_visibility"]["rpc"], params, flush=True)
76-
validate_schema(params, schemas_dict["set_point_visibility"])
73+
print(self.schemas_dict["set_point_visibility"]["rpc"], f"{params=}", flush=True)
74+
validate_schema(params, self.schemas_dict["set_point_visibility"])
7775
id = params["id"]
7876
visibility = bool(params["visibility"])
7977
self.SetVertexVisibility(id, visibility)
8078

8179
@exportRpc(prefix + schemas_dict["set_point_size"]["rpc"])
8280
def setMeshPointSize(self, params):
83-
print(schemas_dict["set_point_size"]["rpc"], params, flush=True)
84-
validate_schema(params, schemas_dict["set_point_size"])
81+
print(self.schemas_dict["set_point_size"]["rpc"], f"{params=}", flush=True)
82+
validate_schema(params, self.schemas_dict["set_point_size"])
8583
id = params["id"]
8684
size = float(params["size"])
8785
self.SetPointSize(id, size)
8886

8987
@exportRpc(prefix + schemas_dict["set_color"]["rpc"])
9088
def setMeshColor(self, params):
91-
print(schemas_dict["set_color"]["rpc"], params, flush=True)
92-
validate_schema(params, schemas_dict["set_color"])
89+
print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
90+
validate_schema(params, self.schemas_dict["set_color"])
9391
id = params["id"]
9492
red = params["red"]
9593
green = params["green"]
@@ -98,8 +96,8 @@ def setMeshColor(self, params):
9896

9997
@exportRpc(prefix + schemas_dict["display_vertex_attribute"]["rpc"])
10098
def setVertexAttribute(self, params):
101-
print(schemas_dict["display_vertex_attribute"]["rpc"], params, flush=True)
102-
validate_schema(params, schemas_dict["display_vertex_attribute"])
99+
print(self.schemas_dict["display_vertex_attribute"]["rpc"], f"{params=}", flush=True)
100+
validate_schema(params, self.schemas_dict["display_vertex_attribute"])
103101
id = params["id"]
104102
name = params["name"]
105103
reader = self.get_object(id)["reader"]
@@ -113,8 +111,8 @@ def setVertexAttribute(self, params):
113111

114112
@exportRpc(prefix + schemas_dict["display_polygon_attribute"]["rpc"])
115113
def setPolygonAttribute(self, params):
116-
print(schemas_dict["display_polygon_attribute"]["rpc"], params, flush=True)
117-
validate_schema(params, schemas_dict["display_polygon_attribute"])
114+
print(self.schemas_dict["display_polygon_attribute"]["rpc"], f"{params=}", flush=True)
115+
validate_schema(params, self.schemas_dict["display_polygon_attribute"])
118116
id = params["id"]
119117
name = params["name"]
120118
reader = self.get_object(id)["reader"]

‎src/opengeodeweb_viewer/rpc/model/model_protocols.py‎

Lines changed: 17 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -11,20 +11,17 @@
1111
from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
1212
from opengeodeweb_viewer.object.object_methods import VtkObjectView
1313

14-
schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
15-
schemas_dict = get_schemas_dict(schemas_dir)
16-
prefix = "opengeodeweb_viewer.model."
17-
1814
class VtkModelView(VtkObjectView):
15+
prefix = "opengeodeweb_viewer.model."
16+
schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
17+
1918
def __init__(self):
2019
super().__init__()
21-
self.prefix = prefix
22-
self.schemas_dict = schemas_dict
2320

2421
@exportRpc(prefix + schemas_dict["register"]["rpc"])
2522
def registerModel(self, params):
26-
print(schemas_dict["register"]["rpc"], params, flush=True)
27-
validate_schema(params, schemas_dict["register"])
23+
print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
24+
validate_schema(params, self.schemas_dict["register"])
2825
id = params["id"]
2926
file_name = params["file_name"]
3027
try:
@@ -33,37 +30,37 @@ def registerModel(self, params):
3330
filter.SetInputConnection(reader.GetOutputPort())
3431
mapper = vtk.vtkCompositePolyDataMapper()
3532
mapper.SetInputConnection(filter.GetOutputPort())
36-
self.register(id, file_name, reader, filter, mapper)
33+
self.registerObject(id, file_name, reader, filter, mapper)
3734
except Exception as e:
3835
print("error : ", str(e), flush=True)
3936

4037
@exportRpc(prefix + schemas_dict["deregister"]["rpc"])
4138
def deregisterModel(self, params):
42-
print(schemas_dict["deregister"]["rpc"], params, flush=True)
43-
validate_schema(params, schemas_dict["deregister"])
39+
print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
40+
validate_schema(params, self.schemas_dict["deregister"])
4441
id = params["id"]
45-
self.deregister(id)
42+
self.deregisterObject(id)
4643

4744
@exportRpc(prefix + schemas_dict["set_mesh_visibility"]["rpc"])
4845
def setMeshVisibility(self, params):
49-
print(schemas_dict["set_mesh_visibility"]["rpc"], params, flush=True)
50-
validate_schema(params, schemas_dict["set_mesh_visibility"])
46+
print(self.schemas_dict["set_mesh_visibility"]["rpc"], f"{params=}", flush=True)
47+
validate_schema(params, self.schemas_dict["set_mesh_visibility"])
5148
id = params["id"]
5249
visibility = bool(params["visibility"])
5350
self.SetEdgeVisibility(id, visibility)
5451

5552
@exportRpc(prefix + schemas_dict["set_components_visibility"]["rpc"])
5653
def setComponentsVisibility(self, params):
57-
print(schemas_dict["set_components_visibility"]["rpc"], params, flush=True)
58-
validate_schema(params, schemas_dict["set_components_visibility"])
54+
print(self.schemas_dict["set_components_visibility"]["rpc"], f"{params=}", flush=True)
55+
validate_schema(params, self.schemas_dict["set_components_visibility"])
5956
id = params["id"]
6057
visibility = bool(params["visibility"])
6158
self.SetVisibility(id, visibility)
6259

6360
@exportRpc(prefix + schemas_dict["set_components_color"]["rpc"])
6461
def setComponentsColor(self, params):
65-
print(schemas_dict["set_components_color"]["rpc"], params, flush=True)
66-
validate_schema(params, schemas_dict["set_components_color"])
62+
print(self.schemas_dict["set_components_color"]["rpc"], f"{params=}", flush=True)
63+
validate_schema(params, self.schemas_dict["set_components_color"])
6764
id = params["id"]
6865
red = params["red"]
6966
green = params["green"]
@@ -72,8 +69,8 @@ def setComponentsColor(self, params):
7269

7370
@exportRpc(prefix + schemas_dict["set_corners_size"]["rpc"])
7471
def setCornersSize(self, params):
75-
print(schemas_dict["set_corners_size"]["rpc"], params, flush=True)
76-
validate_schema(params, schemas_dict["set_corners_size"])
72+
print(self.schemas_dict["set_corners_size"]["rpc"], f"{params=}", flush=True)
73+
validate_schema(params, self.schemas_dict["set_corners_size"])
7774
id = params["id"]
7875
size = float(params["size"])
7976
self.SetPointSize(id, size)

‎src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py‎

Lines changed: 17 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -14,20 +14,17 @@
1414
from opengeodeweb_viewer.utils_functions import get_schemas_dict, validate_schema
1515
from opengeodeweb_viewer.vtk_protocol import VtkView
1616

17-
schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
18-
schemas_dict = get_schemas_dict(schemas_dir)
19-
prefix = "opengeodeweb_viewer.viewer."
20-
2117
class VtkViewerView(VtkView):
18+
prefix = "opengeodeweb_viewer.viewer."
19+
schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
20+
2221
def __init__(self):
2322
super().__init__()
24-
self.prefix = prefix
25-
self.schemas_dict = schemas_dict
2623

2724
@exportRpc(prefix + schemas_dict["create_visualization"]["rpc"])
2825
def createVisualization(self, params):
29-
print(schemas_dict["create_visualization"]["rpc"], params, flush=True)
30-
validate_schema(params, schemas_dict["create_visualization"])
26+
print(self.schemas_dict["create_visualization"]["rpc"], f"{params=}", flush=True)
27+
validate_schema(params, self.schemas_dict["create_visualization"])
3128
renderWindow = self.getView("-1")
3229
renderer = renderWindow.GetRenderers().GetFirstRenderer()
3330
renderer.SetBackground([180 / 255, 180 / 255, 180 / 255])
@@ -37,8 +34,8 @@ def createVisualization(self, params):
3734

3835
@exportRpc(prefix + schemas_dict["set_background_color"]["rpc"])
3936
def setBackgroundColor(self, params):
40-
print(schemas_dict["set_background_color"]["rpc"], params, flush=True)
41-
validate_schema(params, schemas_dict["set_background_color"])
37+
print(self.schemas_dict["set_background_color"]["rpc"], f"{params=}", flush=True)
38+
validate_schema(params, self.schemas_dict["set_background_color"])
4239
renderWindow = self.getView("-1")
4340
renderer = renderWindow.GetRenderers().GetFirstRenderer()
4441
red = params["red"]
@@ -52,17 +49,17 @@ def setBackgroundColor(self, params):
5249

5350
@exportRpc(prefix + schemas_dict["reset_camera"]["rpc"])
5451
def resetCamera(self, params):
55-
print(schemas_dict["reset_camera"]["rpc"], params, flush=True)
56-
validate_schema(params, schemas_dict["reset_camera"])
52+
print(self.schemas_dict["reset_camera"]["rpc"], f"{params=}", flush=True)
53+
validate_schema(params, self.schemas_dict["reset_camera"])
5754
renderWindow = self.getView("-1")
5855
renderWindow.GetRenderers().GetFirstRenderer().ResetCamera()
5956
renderWindow.Render()
6057
self.render()
6158

6259
@exportRpc(prefix + schemas_dict["take_screenshot"]["rpc"])
6360
def takeScreenshot(self, params):
64-
print(schemas_dict["take_screenshot"]["rpc"], params, flush=True)
65-
validate_schema(params, schemas_dict["take_screenshot"])
61+
print(self.schemas_dict["take_screenshot"]["rpc"], f"{params=}", flush=True)
62+
validate_schema(params, self.schemas_dict["take_screenshot"])
6663
filename = params["filename"]
6764
output_extension = params["output_extension"]
6865
include_background = params["include_background"]
@@ -107,8 +104,8 @@ def takeScreenshot(self, params):
107104

108105
@exportRpc(prefix + schemas_dict["update_data"]["rpc"])
109106
def updateData(self, params):
110-
print(schemas_dict["update_data"]["rpc"], params, flush=True)
111-
validate_schema(params, schemas_dict["update_data"])
107+
print(self.schemas_dict["update_data"]["rpc"], f"{params=}", flush=True)
108+
validate_schema(params, self.schemas_dict["update_data"])
112109
id = params["id"]
113110

114111
data = self.get_object(id)
@@ -129,8 +126,8 @@ def updateData(self, params):
129126

130127
@exportRpc(prefix + schemas_dict["get_point_position"]["rpc"])
131128
def getPointPosition(self, params):
132-
print(schemas_dict["get_point_position"]["rpc"], params, flush=True)
133-
validate_schema(params, schemas_dict["get_point_position"])
129+
print(self.schemas_dict["get_point_position"]["rpc"], f"{params=}", flush=True)
130+
validate_schema(params, self.schemas_dict["get_point_position"])
134131
x = float(params["x"])
135132
y = float(params["y"])
136133
xyz = [x, y, 0.0]
@@ -141,7 +138,7 @@ def getPointPosition(self, params):
141138

142139
@exportRpc(prefix + schemas_dict["reset"]["rpc"])
143140
def reset(self, params):
144-
print(schemas_dict["reset"]["rpc"], params, flush=True)
145-
validate_schema(params, schemas_dict["reset"])
141+
print(self.schemas_dict["reset"]["rpc"], f"{params=}", flush=True)
142+
validate_schema(params, self.schemas_dict["reset"])
146143
renderWindow = self.getView("-1")
147144
renderWindow.GetRenderers().GetFirstRenderer().RemoveAllViewProps()

‎src/opengeodeweb_viewer/vtkw_server.py‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -50,11 +50,13 @@ def initialize(self):
5050
self.setSharedObject("db", dict())
5151

5252
# Custom API
53+
mesh_protocols = VtkMeshView()
54+
model_protocols = VtkModelView()
5355
self.registerVtkWebProtocol(VtkView())
5456
self.registerVtkWebProtocol(VtkViewerView())
55-
self.registerVtkWebProtocol(VtkMeshView())
56-
self.registerVtkWebProtocol(VtkModelView())
57-
self.registerVtkWebProtocol(VtkGenericView())
57+
self.registerVtkWebProtocol(mesh_protocols)
58+
self.registerVtkWebProtocol(model_protocols)
59+
self.registerVtkWebProtocol(VtkGenericView(mesh_protocols,model_protocols))
5860

5961
# tell the C++ web app to use no encoding.
6062
# ParaViewWebPublishImageDelivery must be set to decode=False to match.

0 commit comments

Comments
 (0)