diff --git a/src/opengeodeweb_viewer/generic/generic_protocols.py b/src/opengeodeweb_viewer/generic/generic_protocols.py
new file mode 100644
index 0000000..fb9a5bb
--- /dev/null
+++ b/src/opengeodeweb_viewer/generic/generic_protocols.py
@@ -0,0 +1,47 @@
+# 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."
+    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)
+
diff --git a/src/opengeodeweb_viewer/generic/schemas/deregister.json b/src/opengeodeweb_viewer/generic/schemas/deregister.json
new file mode 100644
index 0000000..61715c4
--- /dev/null
+++ b/src/opengeodeweb_viewer/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
+}
\ No newline at end of file
diff --git a/src/opengeodeweb_viewer/generic/schemas/register.json b/src/opengeodeweb_viewer/generic/schemas/register.json
new file mode 100644
index 0000000..93a5ac2
--- /dev/null
+++ b/src/opengeodeweb_viewer/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
+}
\ No newline at end of file
diff --git a/src/opengeodeweb_viewer/object/object_methods.py b/src/opengeodeweb_viewer/object/object_methods.py
index 5cab467..11a3c33 100644
--- a/src/opengeodeweb_viewer/object/object_methods.py
+++ b/src/opengeodeweb_viewer/object/object_methods.py
@@ -12,7 +12,7 @@ class VtkObjectView(VtkView):
     def __init__(self):
         super().__init__()
 
-    def register(self, id, file_name, reader, filter, mapper):
+    def registerObject(self, id, file_name, reader, filter, mapper):
         actor = vtk.vtkActor()
         self.register_object(id, reader, filter, actor, mapper, {})
 
@@ -31,7 +31,7 @@ def register(self, id, file_name, reader, filter, mapper):
         renderWindow.Render()
         self.render()
 
-    def deregister(self, id):
+    def deregisterObject(self, id):
         actor = self.get_object(id)["actor"]
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
diff --git a/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py b/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
index 3f74fdb..26f93be 100644
--- a/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/mesh/mesh_protocols.py
@@ -13,20 +13,17 @@
 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)
-prefix = "opengeodeweb_viewer.mesh."
-
 class VtkMeshView(VtkObjectView):
+    prefix = "opengeodeweb_viewer.mesh."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
     def __init__(self):
         super().__init__()
-        self.prefix = prefix
-        self.schemas_dict = schemas_dict
 
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def registerMesh(self, params):
-        print(schemas_dict["register"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["register"])
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
         try:
@@ -34,61 +31,61 @@ def registerMesh(self, params):
             filter = {}
             mapper = vtk.vtkDataSetMapper()
             mapper.SetInputConnection(reader.GetOutputPort())
-            self.register(id, file_name, reader, filter, mapper)
+            self.registerObject(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregisterMesh(self, params):
-        print(schemas_dict["deregister"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["deregister"])
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
         id = params["id"]
-        self.deregister(id)
+        self.deregisterObject(id)
 
     @exportRpc(prefix + schemas_dict["set_visibility"]["rpc"])
     def SetMeshVisibility(self, params):
-        print(schemas_dict["set_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_visibility"])
+        print(self.schemas_dict["set_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_opacity"]["rpc"])
     def setMeshOpacity(self, params):
-        print(schemas_dict["set_opacity"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_opacity"])
+        print(self.schemas_dict["set_opacity"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_opacity"])
         id = params["id"]
         opacity = float(params["opacity"])
         self.SetOpacity(id, opacity)
 
     @exportRpc(prefix + schemas_dict["set_edge_visibility"]["rpc"])
     def setMeshEdgeVisibility(self, params):
-        print(schemas_dict["set_edge_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_edge_visibility"])
+        print(self.schemas_dict["set_edge_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_edge_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_point_visibility"]["rpc"])
     def setMeshPointVisibility(self, params):
-        print(schemas_dict["set_point_visibility"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_point_visibility"])
+        print(self.schemas_dict["set_point_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_point_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVertexVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_point_size"]["rpc"])
     def setMeshPointSize(self, params):
-        print(schemas_dict["set_point_size"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_point_size"])
+        print(self.schemas_dict["set_point_size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_point_size"])
         id = params["id"]
         size = float(params["size"])
         self.SetPointSize(id, size)
 
     @exportRpc(prefix + schemas_dict["set_color"]["rpc"])
     def setMeshColor(self, params):
-        print(schemas_dict["set_color"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_color"])
+        print(self.schemas_dict["set_color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_color"])
         id = params["id"]
         red = params["red"]
         green = params["green"]
@@ -97,8 +94,8 @@ def setMeshColor(self, params):
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["display_vertex_attribute"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["display_vertex_attribute"])
         id = params["id"]
         name = params["name"]
         reader = self.get_object(id)["reader"]
@@ -112,8 +109,8 @@ def setVertexAttribute(self, params):
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["display_polygon_attribute"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["display_polygon_attribute"])
         id = params["id"]
         name = params["name"]
         reader = self.get_object(id)["reader"]
diff --git a/src/opengeodeweb_viewer/rpc/model/model_protocols.py b/src/opengeodeweb_viewer/rpc/model/model_protocols.py
index 97cb09b..640388f 100644
--- a/src/opengeodeweb_viewer/rpc/model/model_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/model/model_protocols.py
@@ -11,20 +11,17 @@
 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)
-prefix = "opengeodeweb_viewer.model."
-
 class VtkModelView(VtkObjectView):
+    prefix = "opengeodeweb_viewer.model."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
     def __init__(self):
         super().__init__()
-        self.prefix = prefix
-        self.schemas_dict = schemas_dict
     
     @exportRpc(prefix + schemas_dict["register"]["rpc"])
     def registerModel(self, params):
-        print(schemas_dict["register"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["register"])
+        print(self.schemas_dict["register"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["register"])
         id = params["id"]
         file_name = params["file_name"]
         try:
@@ -33,37 +30,37 @@ def registerModel(self, params):
             filter.SetInputConnection(reader.GetOutputPort())
             mapper = vtk.vtkCompositePolyDataMapper()
             mapper.SetInputConnection(filter.GetOutputPort())
-            self.register(id, file_name, reader, filter, mapper)
+            self.registerObject(id, file_name, reader, filter, mapper)
         except Exception as e:
             print("error : ", str(e), flush=True)
 
     @exportRpc(prefix + schemas_dict["deregister"]["rpc"])
     def deregisterModel(self, params):
-        print(schemas_dict["deregister"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["deregister"])
+        print(self.schemas_dict["deregister"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["deregister"])
         id = params["id"]
-        self.deregister(id)
+        self.deregisterObject(id)
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["set_mesh_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_mesh_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetEdgeVisibility(id, visibility)
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["set_components_visibility"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_components_visibility"])
         id = params["id"]
         visibility = bool(params["visibility"])
         self.SetVisibility(id, visibility)
 
     @exportRpc(prefix + schemas_dict["set_components_color"]["rpc"])
     def setComponentsColor(self, params):
-        print(schemas_dict["set_components_color"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["set_components_color"])
+        print(self.schemas_dict["set_components_color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_components_color"])
         id = params["id"]
         red = params["red"]
         green = params["green"]
@@ -72,8 +69,8 @@ def setComponentsColor(self, params):
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["set_corners_size"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_corners_size"])
         id = params["id"]
         size = float(params["size"])
         self.SetPointSize(id, size)
\ No newline at end of file
diff --git a/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py b/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
index bf78d16..32051e7 100644
--- a/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
+++ b/src/opengeodeweb_viewer/rpc/viewer/viewer_protocols.py
@@ -7,27 +7,24 @@
 import vtk
 from vtk.web import protocols as vtk_protocols
 from vtkmodules.vtkIOImage import vtkPNGWriter, vtkJPEGWriter
-from vtkmodules.vtkRenderingCore import (vtkWindowToImageFilter)
+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.vtk_protocol import VtkView
 
-schemas_dir = os.path.join(os.path.dirname(__file__), "schemas")
-schemas_dict = get_schemas_dict(schemas_dir)
-prefix = "opengeodeweb_viewer.viewer."
-
 class VtkViewerView(VtkView):
+    prefix = "opengeodeweb_viewer.viewer."
+    schemas_dict = get_schemas_dict(os.path.join(os.path.dirname(__file__), "schemas"))
+
     def __init__(self):
         super().__init__()
-        self.prefix = prefix
-        self.schemas_dict = schemas_dict
 
     @exportRpc(prefix + schemas_dict["create_visualization"]["rpc"])
     def createVisualization(self, params):
-        print(schemas_dict["create_visualization"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["create_visualization"])
+        print(self.schemas_dict["create_visualization"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["create_visualization"])
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         renderer.SetBackground([180 / 255, 180 / 255, 180 / 255])
@@ -37,8 +34,8 @@ def createVisualization(self, params):
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["set_background_color"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["set_background_color"])
         renderWindow = self.getView("-1")
         renderer = renderWindow.GetRenderers().GetFirstRenderer()
         red = params["red"]
@@ -52,8 +49,8 @@ def setBackgroundColor(self, params):
 
     @exportRpc(prefix + 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"])
+        print(self.schemas_dict["reset_camera"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["reset_camera"])
         renderWindow = self.getView("-1")
         renderWindow.GetRenderers().GetFirstRenderer().ResetCamera()
         renderWindow.Render()
@@ -61,8 +58,8 @@ def resetCamera(self, params):
 
     @exportRpc(prefix + schemas_dict["take_screenshot"]["rpc"])
     def takeScreenshot(self, params):
-        print(schemas_dict["take_screenshot"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["take_screenshot"])
+        print(self.schemas_dict["take_screenshot"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["take_screenshot"])
         filename = params["filename"]
         output_extension = params["output_extension"]
         include_background = params["include_background"]
@@ -107,8 +104,8 @@ def takeScreenshot(self, params):
 
     @exportRpc(prefix + schemas_dict["update_data"]["rpc"])
     def updateData(self, params):
-        print(schemas_dict["update_data"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["update_data"])
+        print(self.schemas_dict["update_data"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["update_data"])
         id = params["id"]
 
         data = self.get_object(id)
@@ -129,8 +126,8 @@ def updateData(self, params):
 
     @exportRpc(prefix + schemas_dict["get_point_position"]["rpc"])
     def getPointPosition(self, params):
-        print(schemas_dict["get_point_position"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["get_point_position"])
+        print(self.schemas_dict["get_point_position"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["get_point_position"])
         x = float(params["x"])
         y = float(params["y"])
         xyz = [x, y, 0.0]
@@ -141,7 +138,7 @@ def getPointPosition(self, params):
 
     @exportRpc(prefix + schemas_dict["reset"]["rpc"])
     def reset(self, params):
-        print(schemas_dict["reset"]["rpc"], params, flush=True)
-        validate_schema(params, schemas_dict["reset"])
+        print(self.schemas_dict["reset"]["rpc"], f"{params=}", flush=True)
+        validate_schema(params, self.schemas_dict["reset"])
         renderWindow = self.getView("-1")
         renderWindow.GetRenderers().GetFirstRenderer().RemoveAllViewProps()
diff --git a/src/opengeodeweb_viewer/vtkw_server.py b/src/opengeodeweb_viewer/vtkw_server.py
index 8e5332f..186f33d 100644
--- a/src/opengeodeweb_viewer/vtkw_server.py
+++ b/src/opengeodeweb_viewer/vtkw_server.py
@@ -15,6 +15,7 @@
 from .rpc.viewer.viewer_protocols import VtkViewerView
 from .rpc.mesh.mesh_protocols import VtkMeshView
 from .rpc.model.model_protocols import VtkModelView
+from .generic.generic_protocols import VtkGenericView
 
 
 # =============================================================================
@@ -49,10 +50,13 @@ def initialize(self):
         self.setSharedObject("db", dict())
 
         # Custom API
+        mesh_protocols = VtkMeshView()
+        model_protocols = VtkModelView()
         self.registerVtkWebProtocol(VtkView())
         self.registerVtkWebProtocol(VtkViewerView())
-        self.registerVtkWebProtocol(VtkMeshView())
-        self.registerVtkWebProtocol(VtkModelView())
+        self.registerVtkWebProtocol(mesh_protocols)
+        self.registerVtkWebProtocol(model_protocols)
+        self.registerVtkWebProtocol(VtkGenericView(mesh_protocols,model_protocols))
 
         # tell the C++ web app to use no encoding.
         # ParaViewWebPublishImageDelivery must be set to decode=False to match.
diff --git a/src/tests/data/images/mesh/set_point_size_1.jpeg b/src/tests/data/images/mesh/set_point_size_1.jpeg
deleted file mode 100644
index 8b0cf16..0000000
Binary files a/src/tests/data/images/mesh/set_point_size_1.jpeg and /dev/null differ
diff --git a/src/tests/test_generic_protocols.py b/src/tests/test_generic_protocols.py
new file mode 100644
index 0000000..ef376db
--- /dev/null
+++ b/src/tests/test_generic_protocols.py
@@ -0,0 +1,21 @@
+from opengeodeweb_viewer.generic.generic_protocols import VtkGenericView
+
+def test_register_mesh(server):
+    server.call(VtkGenericView.prefix + VtkGenericView.schemas_dict["register"]["rpc"], [{"viewer_object": "mesh", "id": "123456789", "file_name": "hat.vtp"}])
+    assert server.compare_image(3, "mesh/register.jpeg") == True
+
+def test_register_model(server):
+    server.call(VtkGenericView.prefix + VtkGenericView.schemas_dict["register"]["rpc"], [{"viewer_object": "model", "id": "123456789", "file_name": "CrossSection.vtm"}])
+    assert server.compare_image(3, "model/register.jpeg") == True
+
+def test_deregister_mesh(server):
+    test_register_mesh(server)
+
+    server.call(VtkGenericView.prefix + VtkGenericView.schemas_dict["deregister"]["rpc"], [{"viewer_object": "mesh", "id": "123456789"}])
+    assert server.compare_image(3, "mesh/deregister.jpeg") == True
+
+def test_deregister_model(server):
+    test_register_model(server)
+
+    server.call(VtkGenericView.prefix + VtkGenericView.schemas_dict["deregister"]["rpc"], [{"viewer_object": "model", "id": "123456789"}])
+    assert server.compare_image(3, "model/deregister.jpeg") == True
\ No newline at end of file
diff --git a/src/tests/test_mesh_protocols.py b/src/tests/test_mesh_protocols.py
index 3086370..0091b5d 100644
--- a/src/tests/test_mesh_protocols.py
+++ b/src/tests/test_mesh_protocols.py
@@ -1,84 +1,83 @@
 
 
 from opengeodeweb_viewer.rpc.mesh.mesh_protocols import VtkMeshView
-class_ = VtkMeshView()
 
 def test_register_mesh(server):
 
-    server.call(class_.prefix + class_.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "hat.vtp"}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "hat.vtp"}])
     assert server.compare_image(3, "mesh/register.jpeg") == True
 
 def test_deregister_mesh(server):
 
     test_register_mesh(server)
 
-    server.call(class_.prefix + class_.schemas_dict["deregister"]["rpc"], [{"id": "123456789"}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["deregister"]["rpc"], [{"id": "123456789"}])
     assert server.compare_image(3, "mesh/deregister.jpeg") == True
 
 def test_set_opacity(server):
 
     test_register_mesh(server)
 
-    server.call(class_.prefix + class_.schemas_dict["set_opacity"]["rpc"], [{"id": "123456789", "opacity": 0.1}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_opacity"]["rpc"], [{"id": "123456789", "opacity": 0.1}])
     assert server.compare_image(3, "mesh/set_opacity.jpeg") == True
 
 def test_set_edge_visibility(server):
 
     test_register_mesh(server)
 
-    server.call(class_.prefix + class_.schemas_dict["set_edge_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_edge_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
     assert server.compare_image(3, "mesh/set_edge_visibility.jpeg") == True
 
 # def test_set_point_visibility(server):
 
 #     test_register_mesh(server)
 
-#     server.call(class_.prefix + class_.schemas_dict["set_point_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
+#     server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_point_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
 #     assert server.compare_image(3, "mesh/set_point_visibility.jpeg") == True
 
 # def test_set_point_size(server):
 
-#     server.call(class_.prefix + class_.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "verts.vtp"}])
+#     server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "vertex_attribute.vtp"}])
 #     assert server.compare_image(3, "mesh/set_point_size_1.jpeg") == True
 
-#     server.call(class_.prefix + class_.schemas_dict["set_point_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
-#     assert server.compare_image(3, "mesh/set_point_size_2.jpeg") == True
+    # server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_point_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
+    # assert server.compare_image(3, "mesh/set_point_size_2.jpeg") == True
 
-#     server.call(class_.prefix + class_.schemas_dict["set_point_size"]["rpc"], [{"id": "123456789", "size": 10}])
-#     assert server.compare_image(2, "mesh/set_point_size_3.jpeg") == True
+    # server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_point_size"]["rpc"], [{"id": "123456789", "size": 10}])
+    # assert server.compare_image(3, "mesh/set_point_size_3.jpeg") == True
 
 
 def test_set_color(server):
 
     test_register_mesh(server)
 
-    server.call(class_.prefix + class_.schemas_dict["set_color"]["rpc"], [{"id": "123456789", "red": 50, "green": 2, "blue": 250}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["set_color"]["rpc"], [{"id": "123456789", "red": 50, "green": 2, "blue": 250}])
     assert server.compare_image(3, "mesh/set_color.jpeg") == True
 
 
 def test_display_vertex_attribute(server):
-    server.call(class_.prefix + class_.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "vertex_attribute.vtp"}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "vertex_attribute.vtp"}])
     assert server.compare_image(3, "mesh/display_vertex_attribute_1.jpeg") == True
 
     server.call(
-        class_.prefix + class_.schemas_dict["display_vertex_attribute"]["rpc"],
+        VtkMeshView.prefix + VtkMeshView.schemas_dict["display_vertex_attribute"]["rpc"],
         [{"id": "123456789", "name": "geode_implicit_attribute"}],
     )
     assert server.compare_image(3, "mesh/display_vertex_attribute_2.jpeg") == True
 
 
     server.call(
-        class_.prefix + class_.schemas_dict["set_color"]["rpc"],
+        VtkMeshView.prefix + VtkMeshView.schemas_dict["set_color"]["rpc"],
         [{"id": "123456789", "red": 250, "green": 0, "blue": 0}],
     )
     assert server.compare_image(3, "mesh/display_vertex_attribute_3.jpeg") == True
 
 def test_display_polygon_attribute(server):
-    server.call(class_.prefix + class_.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "polygon_attribute.vtp"}])
+    server.call(VtkMeshView.prefix + VtkMeshView.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "polygon_attribute.vtp"}])
     assert server.compare_image(3, "mesh/display_polygon_attribute_1.jpeg") == True
 
     server.call(
-        class_.prefix + class_.schemas_dict["display_polygon_attribute"]["rpc"],
+        VtkMeshView.prefix + VtkMeshView.schemas_dict["display_polygon_attribute"]["rpc"],
         [{"id": "123456789", "name": "implicit_on_polygons"}],
     )
     assert server.compare_image(3, "mesh/display_polygon_attribute_2.jpeg") == True
\ No newline at end of file
diff --git a/src/tests/test_model_protocols.py b/src/tests/test_model_protocols.py
index 9463265..2212d7d 100644
--- a/src/tests/test_model_protocols.py
+++ b/src/tests/test_model_protocols.py
@@ -1,16 +1,15 @@
 from opengeodeweb_viewer.rpc.model.model_protocols import VtkModelView
-class_ = VtkModelView()
 
 def test_register_model(server):
 
-    server.call(class_.prefix + class_.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "CrossSection.vtm"}])
+    server.call(VtkModelView.prefix + VtkModelView.schemas_dict["register"]["rpc"], [{"id": "123456789", "file_name": "CrossSection.vtm"}])
     assert server.compare_image(3, "model/register.jpeg") == True
 
 def test_deregister_model(server):
 
     test_register_model(server)
 
-    server.call(class_.prefix + class_.schemas_dict["deregister"]["rpc"], [{"id": "123456789"}])
+    server.call(VtkModelView.prefix + VtkModelView.schemas_dict["deregister"]["rpc"], [{"id": "123456789"}])
     assert server.compare_image(3, "model/deregister.jpeg") == True
 
 
@@ -18,19 +17,19 @@ def test_set_mesh_visibility(server):
 
     test_register_model(server)
     
-    server.call(class_.prefix + class_.schemas_dict["set_mesh_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
+    server.call(VtkModelView.prefix + VtkModelView.schemas_dict["set_mesh_visibility"]["rpc"], [{"id": "123456789", "visibility": True}])
     assert server.compare_image(3, "model/set_mesh_visibility.jpeg") == True
 
 def test_set_components_visibility(server):
 
     test_register_model(server)
 
-    server.call(class_.prefix + class_.schemas_dict["set_components_visibility"]["rpc"], [{"id": "123456789", "visibility": False}])
+    server.call(VtkModelView.prefix + VtkModelView.schemas_dict["set_components_visibility"]["rpc"], [{"id": "123456789", "visibility": False}])
     assert server.compare_image(3, "model/set_components_visibility.jpeg") == True
 
 def test_set_components_color(server):
 
     test_register_model(server)
 
-    server.call(class_.prefix + class_.schemas_dict["set_components_color"]["rpc"], [{"id": "123456789", "red": 255, "green": 0, "blue": 0}])
+    server.call(VtkModelView.prefix + VtkModelView.schemas_dict["set_components_color"]["rpc"], [{"id": "123456789", "red": 255, "green": 0, "blue": 0}])
     assert server.compare_image(3, "model/set_components_color.jpeg") == True
\ No newline at end of file
diff --git a/src/tests/test_viewer_protocols.py b/src/tests/test_viewer_protocols.py
index ec4dfdb..d60b01e 100644
--- a/src/tests/test_viewer_protocols.py
+++ b/src/tests/test_viewer_protocols.py
@@ -7,25 +7,23 @@
 # Local application imports
 from .test_mesh_protocols import test_register_mesh
 
-class_ = VtkViewerView()
-
 def test_create_visualization(server):
-    server.call(class_.prefix + class_.schemas_dict["create_visualization"]["rpc"])
+    server.call(VtkViewerView.prefix + VtkViewerView.schemas_dict["create_visualization"]["rpc"])
     assert server.compare_image(3, "viewer/create_visualization.jpeg") == True
 
 def test_reset_camera(server):
-    server.call(class_.prefix + class_.schemas_dict["reset_camera"]["rpc"])
+    server.call(VtkViewerView.prefix + VtkViewerView.schemas_dict["reset_camera"]["rpc"])
     assert server.compare_image(3, "viewer/reset_camera.jpeg") == True
 
 def test_set_viewer_background_color(server):
-    server.call(class_.prefix + class_.schemas_dict["set_background_color"]["rpc"], [{"red": 0, "green": 0, "blue": 255}])
+    server.call(VtkViewerView.prefix + VtkViewerView.schemas_dict["set_background_color"]["rpc"], [{"red": 0, "green": 0, "blue": 255}])
     assert server.compare_image(3, "viewer/set_background_color.jpeg") == True
 
 def test_get_point_position(server):
 
     test_register_mesh(server)
 
-    server.call(class_.prefix + class_.schemas_dict["get_point_position"]["rpc"], [{"x": 0, "y": 0}])
+    server.call(VtkViewerView.prefix + VtkViewerView.schemas_dict["get_point_position"]["rpc"], [{"x": 0, "y": 0}])
     response = server.get_response()
     assert "x" in response["result"]
     assert "y" in response["result"]
@@ -44,7 +42,7 @@ def test_take_screenshot(server):
 
     # Take a screenshot with background jpg
     server.call(
-        class_.prefix + class_.schemas_dict["take_screenshot"]["rpc"],
+        VtkViewerView.prefix + VtkViewerView.schemas_dict["take_screenshot"]["rpc"],
         [{"filename": "take_screenshot_with_background", "output_extension": "jpg", "include_background": True}],
     )
 
@@ -62,7 +60,7 @@ def test_take_screenshot(server):
 
     # Take a screenshot without background png
     server.call(
-        class_.prefix + class_.schemas_dict["take_screenshot"]["rpc"],
+        VtkViewerView.prefix + VtkViewerView.schemas_dict["take_screenshot"]["rpc"],
         [{"filename": "take_screenshot_without_background", "output_extension": "png", "include_background": True}],
     )
     
@@ -82,7 +80,7 @@ def test_take_screenshot(server):
 
     # Take a screenshot with background png
     server.call(
-        class_.prefix + class_.schemas_dict["take_screenshot"]["rpc"],
+        VtkViewerView.prefix + VtkViewerView.schemas_dict["take_screenshot"]["rpc"],
         [{"filename": "take_screenshot_with_background", "output_extension": "png", "include_background": True}],
     )
     
diff --git a/src/tests/tests_output/test.jpeg b/src/tests/tests_output/test.jpeg
index 6b2509f..ee7e056 100644
Binary files a/src/tests/tests_output/test.jpeg and b/src/tests/tests_output/test.jpeg differ