call self everywhere

Author: JulienChampagnol

src/opengeodeweb_viewer/object/object_methods.py

@@ -100,7 +100,7 @@ def SetOpacity(self, id, opacity):
         self.render()
 
     def SetColor(self, id, red, green, blue):
-        reader = super().get_object(id)["reader"]
+        reader = self.get_object(id)["reader"]
         mapper = self.get_object(id)["mapper"]
         mapper.ScalarVisibilityOff()
         actor = self.get_object(id)["actor"]

src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py

@@ -22,7 +22,7 @@ def __init__(self):
         super().__init__()
 
     @exportRpc(schemas_dict["register"]["rpc"])
-    def register(self, params):
+    def registerMesh(self, params):
         print(schemas_dict["register"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["register"])
         id = params["id"]
@@ -32,7 +32,7 @@ def register(self, params):
             filter = {}
             mapper = vtk.vtkDataSetMapper()
             mapper.SetInputConnection(reader.GetOutputPort())
-            super().register(id, file_name, reader, filter, mapper)
+            self.register(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
@@ -41,84 +41,84 @@ def deregisterMesh(self, params):
         print(schemas_dict["deregister"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["deregister"])
         id = params["id"]
-        super().deregister(id)
+        self.deregister(id)
 
     @exportRpc(schemas_dict["set_visibility"]["rpc"])
-    def SetVisibility(self, params):
+    def SetMeshVisibility(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)
+        self.SetVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_opacity"]["rpc"])
-    def SetOpacity(self, params):
+    def SetMeshOpacity(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)
+        self.SetOpacity(id, opacity)
 
     @exportRpc(schemas_dict["set_edge_visibility"]["rpc"])
-    def setEdgeVisibility(self, params):
+    def setMeshEdgeVisibility(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)
+        self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_point_visibility"]["rpc"])
-    def setPointVisibility(self, params):
+    def setMeshPointVisibility(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)
+        self.SetVertexVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_point_size"]["rpc"])
-    def setPointSize(self, params):
+    def setMeshPointSize(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)
+        self.SetPointSize(id, size)
 
     @exportRpc(schemas_dict["set_color"]["rpc"])
-    def setColor(self, params):
+    def setMeshColor(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)
+        self.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"]
+        reader = self.get_object(id)["reader"]
         points = reader.GetOutput().GetPointData()
         points.SetActiveScalars(name)
-        mapper = super().get_object(id)["mapper"]
+        mapper = self.get_object(id)["mapper"]
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUsePointData()
         mapper.SetScalarRange(points.GetScalars().GetRange())
-        super().render()
+        self.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"]
+        reader = self.get_object(id)["reader"]
         cells = reader.GetOutput().GetCellData()
         cells.SetActiveScalars(name)
-        mapper = super().get_object(id)["mapper"]
+        mapper = self.get_object(id)["mapper"]
         mapper.ScalarVisibilityOn()
         mapper.SetScalarModeToUseCellData()
         mapper.SetScalarRange(cells.GetScalars().GetRange())
-        super().render()
+        self.render()

src/opengeodeweb_viewer/rpc/model/model_protocols.py

@@ -30,7 +30,7 @@ def registerModel(self, params):
             filter.SetInputConnection(reader.GetOutputPort())
             mapper = vtk.vtkCompositePolyDataMapper()
             mapper.SetInputConnection(filter.GetOutputPort())
-            super().register(id, file_name, reader, filter, mapper)
+            self.register(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
@@ -39,23 +39,23 @@ def deregisterModel(self, params):
         print(schemas_dict["deregister"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["deregister"])
         id = params["id"]
-        super().deregister(id)
+        self.deregister(id)
 
     @exportRpc(schemas_dict["set_mesh_visibility"]["rpc"])
     def SetMeshVisibility(self, params):
         print(schemas_dict["set_mesh_visibility"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["set_mesh_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
-        super().SetEdgeVisibility(id, visibility)
+        self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_components_visibility"]["rpc"])
     def SetComponentsVisibility(self, params):
         print(schemas_dict["set_components_visibility"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["set_components_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
-        super().SetVisibility(id, visibility)
+        self.SetVisibility(id, visibility)
 
     @exportRpc(schemas_dict["set_components_color"]["rpc"])
     def SetComponentsColor(self, params):
@@ -65,12 +65,12 @@ def SetComponentsColor(self, params):
         red = params["red"]
         green = params["green"]
         blue = params["blue"]
-        super().SetColor(id, red, green, blue)
+        self.SetColor(id, red, green, blue)
 
     @exportRpc(schemas_dict["set_corners_size"]["rpc"])
     def setCornersSize(self, params):
         print(schemas_dict["set_corners_size"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["set_corners_size"])
         id = params["id"]
         size = float(params["size"])
-        super().SetPointSize(id, size)
+        self.SetPointSize(id, size)

src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py

@@ -25,18 +25,18 @@ def __init__(self):
     def createVisualization(self, params):
         print(schemas_dict["create_visualization"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["create_visualization"])
-        renderWindow = super().getView("-1")
+        renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.SetBackground([180 / 255, 180 / 255, 180 / 255])
         renderer.ResetCamera()
         renderWindow.Render()
-        super().render()
+        self.render()
 
     @exportRpc(schemas_dict["set_background_color"]["rpc"])
     def setBackgroundColor(self, params):
         print(schemas_dict["set_background_color"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["set_background_color"])
-        renderWindow = super().getView("-1")
+        renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         red = params["red"]
         green = params["green"]
@@ -45,16 +45,16 @@ def setBackgroundColor(self, params):
         renderer.SetBackground([red, green, blue])
         renderer.ResetCamera()
         renderWindow.Render()
-        super().render()
+        self.render()
 
     @exportRpc(schemas_dict["reset_camera"]["rpc"])
     def resetCamera(self, params):
         print(schemas_dict["reset_camera"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["reset_camera"])
-        renderWindow = super().getView("-1")
+        renderWindow = self.getView("-1")
         renderWindow.GetRenderers().GetFirstRenderer().ResetCamera()
         renderWindow.Render()
-        super().render()
+        self.render()
 
     @exportRpc(schemas_dict["take_screenshot"]["rpc"])
     def takeScreenshot(self, params):
@@ -63,8 +63,8 @@ def takeScreenshot(self, params):
         filename = params["filename"]
         output_extension = params["output_extension"]
         include_background = params["include_background"]
-        renderWindow = super().getView("-1")
-        renderer = super().get_renderer()
+        renderWindow = self.getView("-1")
+        renderer = self.get_renderer()
 
         w2if = vtkWindowToImageFilter()
 
@@ -108,7 +108,7 @@ def updateData(self, params):
         validate_schema(params, schemas_dict["update_data"])
         id = params["id"]
 
-        data = super().get_object(id)
+        data = self.get_object(id)
         reader = data["reader"]
         reader.Update()
         mapper = data["mapper"]
@@ -122,7 +122,7 @@ def updateData(self, params):
             tag,
         )
         mapper.SetScalarRange(scalars.GetRange())
-        super().render()
+        self.render()
 
     @exportRpc(schemas_dict["get_point_position"]["rpc"])
     def getPointPosition(self, params):
@@ -132,13 +132,13 @@ def getPointPosition(self, params):
         y = float(params["y"])
         xyz = [x, y, 0.0]
         picker = vtk.vtkWorldPointPicker()
-        picker.Pick(xyz, super().get_renderer())
+        picker.Pick(xyz, self.get_renderer())
         ppos = picker.GetPickPosition()
         return {"x": ppos[0], "y": ppos[1], "z": ppos[2]}
 
     @exportRpc(schemas_dict["reset"]["rpc"])
     def reset(self, params):
         print(schemas_dict["reset"]["rpc"], params, flush=True)
         validate_schema(params, schemas_dict["reset"])
-        renderWindow = super().getView("-1")
+        renderWindow = self.getView("-1")
         renderWindow.GetRenderers().GetFirstRenderer().RemoveAllViewProps()