q3dviewer 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

q3dviewer/base_glwidget.py

@@ -25,6 +25,9 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         self.active_keys = set()
         self.show_center = False
         self.enable_show_center = True
+        self.view_need_update = True
+        self.view_matrix = self.get_view_matrix()
+        self.projection_matrix = self.get_projection_matrix()
 
     def keyPressEvent(self, ev: QtGui.QKeyEvent):
         if ev.key() == QtCore.Qt.Key_Up or  \
@@ -87,15 +90,29 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         """
         for item in self.items:
             item.initialize()
+        # initialize the projection matrix and model view matrix
+        self.projection_matrix = self.get_projection_matrix()
+        self.update_model_projection()
+        self.view_matrix = self.get_view_matrix()
+        self.update_model_view()
+
+    def set_view_matrix(self, view_matrix):
+        self.view_matrix = view_matrix
+        self.view_need_update = False
 
     def mouseReleaseEvent(self, ev):
         if hasattr(self, 'mousePos'):
             delattr(self, 'mousePos')
 
+    def set_dist(self, dist):
+        self.dist = dist
+        self.view_need_update = True
+
     def update_dist(self, delta):
         self.dist += delta
         if self.dist < 0.1:
             self.dist = 0.1
+        self.view_need_update = True
 
     def wheelEvent(self, ev):
         delta = ev.angleDelta().x()
@@ -121,17 +138,32 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
             dist = max(self.dist, 0.5)
             self.center += Rwc @ Kinv @ np.array([-diff.x(), diff.y(), 0]) * dist
         self.show_center = True
+        self.view_need_update = True
+
+    def set_center(self, center):
+        self.center = center
+        self.view_need_update = True
 
     def paintGL(self):
-        pass
-        self.update_model_projection()
+        # if the camera is moved, update the model view matrix.
+        if self.view_need_update:
+            self.view_matrix = self.get_view_matrix()
+            self.view_need_update = False
         self.update_model_view()
+
+        # set the background color
         bgcolor = self.color
         glClearColor(*bgcolor)
         glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
         for item in self.items:
             if not item.visible():
                 continue
+            if not item.is_initialized():
+                """
+                The item may not be initialized if it is added
+                after the widget is shown, so we need to initialize it here.
+                """
+                item.initialize()
             glMatrixMode(GL_MODELVIEW)
             glPushMatrix()
             glPushAttrib(GL_ALL_ATTRIB_BITS)
@@ -189,11 +221,11 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
                 self.center += Rz @ np.array([-trans_speed, 0, 0])
             if QtCore.Qt.Key_D in self.active_keys:
                 self.center += Rz @ np.array([trans_speed, 0, 0])
+        self.view_need_update = True
 
     def update_model_view(self):
-        m = self.get_view_matrix()
         glMatrixMode(GL_MODELVIEW)
-        glLoadMatrixf(m.T)
+        glLoadMatrixf(self.view_matrix.T)
         
     def get_view_matrix(self):
         two = self.center # the origin(center) in the world frame
@@ -209,9 +241,9 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         pos = kwargs.get('pos', None)
         distance = kwargs.get('distance', None)
         if pos is not None:
-            self.center = pos
+            self.set_center(pos)
         if distance is not None:
-            self.dist = distance
+            self.set_dist(distance)
 
     def set_color(self, color):
         self.color = color
@@ -221,9 +253,8 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         super().update()
 
     def update_model_projection(self):
-        m = self.get_projection_matrix()
         glMatrixMode(GL_PROJECTION)
-        glLoadMatrixf(m.T)
+        glLoadMatrixf(self.projection_matrix.T)
 
     def get_projection_matrix(self):
         w, h = self.current_width(), self.current_height()
@@ -259,3 +290,17 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
 
     def change_show_center(self, state):
         self.enable_show_center = state
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self.projection_matrix = self.get_projection_matrix()
+        self.update_model_projection()
+
+    def capture_frame(self):
+        self.makeCurrent()  # Ensure the OpenGL context is current
+        width = self.current_width()
+        height = self.current_height()
+        pixels = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
+        frame = np.frombuffer(pixels, dtype=np.uint8).reshape(height, width, 3)
+        frame = np.flip(frame, 0)
+        return frame

q3dviewer/base_item.py

@@ -16,6 +16,7 @@ class BaseItem(QtCore.QObject):
         self._glwidget = None
         self._visible = True
         self._initialized = False
+        self._disable_setting = False
         
     def set_glwidget(self, v):
         self._glwidget = v
@@ -38,6 +39,17 @@ class BaseItem(QtCore.QObject):
     def initialize(self):
         if not self._initialized:
             self.initialize_gl()
+            self._initialized = True
+
+    def is_initialized(self):
+        return self._initialized
+
+    def add_setting(self, layout):
+        """
+        Add setting widgets to the layout.
+        This method should be overridden by subclasses to add any necessary setting widgets to the layout.
+        """
+        pass
     
     def initialize_gl(self):
         """
@@ -53,5 +65,8 @@ class BaseItem(QtCore.QObject):
         """
         pass
 
+    def disable_setting(self):
+        self._disable_setting = True
+
 
 

q3dviewer/custom_items/axis_item.py

@@ -4,44 +4,9 @@ Distributed under MIT license. See LICENSE for more information.
 """
 
 from q3dviewer.base_item import BaseItem
-from q3dviewer.utils import set_uniform
 from OpenGL.GL import *
 import numpy as np
-from OpenGL.GL import shaders
-from PySide6.QtWidgets import QLabel, QDoubleSpinBox
-
-
-# Vertex and Fragment shader source code
-vertex_shader_source = """
-#version 330 core
-layout(location = 0) in vec3 position;
-layout(location = 1) in vec3 color;
-
-out vec3 ourColor;
-
-uniform mat4 view_matrix;
-uniform mat4 project_matrix;
-uniform mat4 model_matrix;
-uniform float size;
-
-void main()
-{
-    vec3 scaled_position = position * size;
-    gl_Position = project_matrix * view_matrix * model_matrix * vec4(scaled_position, 1.0);
-    ourColor = color;
-}
-"""
-
-fragment_shader_source = """
-#version 330 core
-in vec3 ourColor;
-out vec4 color;
-
-void main()
-{
-    color = vec4(ourColor, 1.0);
-}
-"""
+from PySide6.QtWidgets import QDoubleSpinBox
 
 
 class AxisItem(BaseItem):
@@ -49,76 +14,45 @@ class AxisItem(BaseItem):
         super().__init__()
         self.size = size
         self.width = width
-        self.model_matrix = np.eye(4, dtype=np.float32)
+        self.T = np.eye(4, dtype=np.float32)
         self.need_update_setting = True
 
     def initialize_gl(self):
-        # Axis vertices and colors
+        # Axis vertices
         self.vertices = np.array([
-            # positions         # colors
-            [0.0, 0.0, 0.0,    1.0, 0.0, 0.0],  # X axis (red)
-            [1.0, 0.0, 0.0,    1.0, 0.0, 0.0],
-            [0.0, 0.0, 0.0,    0.0, 1.0, 0.0],  # Y axis (green)
-            [0.0, 1.0, 0.0,    0.0, 1.0, 0.0],
-            [0.0, 0.0, 0.0,    0.0, 0.0, 1.0],  # Z axis (blue)
-            [0.0, 0.0, 1.0,    0.0, 0.0, 1.0],
+            # positions
+            [0.0, 0.0, 0.0], [1.0, 0.0, 0.0],  # X axis
+            [0.0, 0.0, 0.0], [0.0, 1.0, 0.0],  # Y axis
+            [0.0, 0.0, 0.0], [0.0, 0.0, 1.0],  # Z axis
         ], dtype=np.float32)
 
-        self.vao = glGenVertexArrays(1)
-        vbo = glGenBuffers(1)
-
-        glBindVertexArray(self.vao)
-
-        glBindBuffer(GL_ARRAY_BUFFER, vbo)
-        glBufferData(GL_ARRAY_BUFFER, self.vertices.nbytes, self.vertices, GL_STATIC_DRAW)
-
-        # Vertex positions
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(0))
-        glEnableVertexAttribArray(0)
-
-        # Vertex colors
-        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(12))
-        glEnableVertexAttribArray(1)
-
-        # Compile shaders and create shader program
-        self.program = shaders.compileProgram(
-            shaders.compileShader(vertex_shader_source, GL_VERTEX_SHADER),
-            shaders.compileShader(fragment_shader_source, GL_FRAGMENT_SHADER),
-        )
+        # Axis colors
+        self.colors = np.array([
+            [1.0, 0.0, 0.0], [1.0, 0.0, 0.0],  # X axis (red)
+            [0.0, 1.0, 0.0], [0.0, 1.0, 0.0],  # Y axis (green)
+            [0.0, 0.0, 1.0], [0.0, 0.0, 1.0],  # Z axis (blue)
+        ], dtype=np.float32)
 
-        glBindVertexArray(0)
 
     def add_setting(self, layout):
-        label_size = QLabel("Set size:")
-        layout.addWidget(label_size)
         spinbox_size = QDoubleSpinBox()
+        spinbox_size.setPrefix("Size: ")
         spinbox_size.setSingleStep(0.1)
-        layout.addWidget(spinbox_size)
         spinbox_size.setValue(self.size)
-        spinbox_size.valueChanged.connect(self.set_size)
         spinbox_size.setRange(0.0, 100)
+        spinbox_size.valueChanged.connect(self.set_size)
+        layout.addWidget(spinbox_size)
 
-        label_width = QLabel("Set width:")
-        layout.addWidget(label_width)
         spinbox_width = QDoubleSpinBox()
-        layout.addWidget(spinbox_width)
+        spinbox_width.setPrefix("Width: ")
         spinbox_width.setSingleStep(0.1)
         spinbox_width.setValue(self.width)
-        spinbox_width.valueChanged.connect(self.set_width)
         spinbox_width.setRange(0, 1000)
+        spinbox_width.valueChanged.connect(self.set_width)
+        layout.addWidget(spinbox_width)
 
     def set_size(self, size):
         self.size = size
-        self.need_update_setting = True
-
-    def update_setting(self):
-        if not self.need_update_setting:
-            return
-        glUseProgram(self.program)
-        set_uniform(self.program, float(self.size), 'size')
-        set_uniform(self.program, self.model_matrix, 'model_matrix')
-        glUseProgram(0)
-        self.need_update_setting = False
 
     def set_width(self, width):
         self.width = width
@@ -127,22 +61,25 @@ class AxisItem(BaseItem):
         """
         Set the transformation matrix for the axis item.
         """
-        self.model_matrix = transform
+        self.T = transform
         self.need_update_setting = True
 
     def paint(self):
-        self.update_setting()
         glLineWidth(self.width)
-        glUseProgram(self.program)
-        glBindVertexArray(self.vao)
 
-        view_matrix = self.glwidget().get_view_matrix()
-        project_matrix = self.glwidget().get_projection_matrix()
-        set_uniform(self.program, view_matrix, 'view_matrix')
-        set_uniform(self.program, project_matrix, 'project_matrix')
+        glPushMatrix()
+        glMultMatrixf(self.T.T)
+
+        glEnableClientState(GL_VERTEX_ARRAY)
+        glVertexPointer(3, GL_FLOAT, 0, self.vertices * self.size)
+
+        glEnableClientState(GL_COLOR_ARRAY)
+        glColorPointer(3, GL_FLOAT, 0, self.colors)
+
+        glDrawArrays(GL_LINES, 0, len(self.vertices))
 
-        glDrawArrays(GL_LINES, 0, 6)
+        glDisableClientState(GL_VERTEX_ARRAY)
+        glDisableClientState(GL_COLOR_ARRAY)
+        glPopMatrix()
 
-        glBindVertexArray(0)
-        glUseProgram(0)
         glLineWidth(1)

q3dviewer/custom_items/cloud_item.py

@@ -20,7 +20,11 @@ from PySide6.QtGui import QRegularExpressionValidator
 
 # draw points with color (x, y, z, color)
 class CloudItem(BaseItem):
-    def __init__(self, size, alpha, color_mode='I', color='#ffffff', point_type='PIXEL'):
+    def __init__(self, size, alpha, 
+                 color_mode='I', 
+                 color='#ffffff', 
+                 point_type='PIXEL', 
+                 depth_test=False):
         super().__init__()
         self.STRIDE = 16  # stride of cloud array
         self.valid_buff_top = 0
@@ -42,11 +46,11 @@ class CloudItem(BaseItem):
         self.need_update_setting = True
         self.max_cloud_size = 300000000
         # Enable depth test when full opaque
-        self.depth_test_enabled = (alpha == 1)
+        self.depth_test = depth_test
         self.path = os.path.dirname(__file__)
 
     def add_setting(self, layout):
-        label_ptype = QLabel("Set point display type:")
+        label_ptype = QLabel("Point Type:")
         layout.addWidget(label_ptype)
         combo_ptype = QComboBox()
         combo_ptype.addItem("pixels")
@@ -55,26 +59,25 @@ class CloudItem(BaseItem):
         combo_ptype.setCurrentIndex(self.point_type_table[self.point_type])
         combo_ptype.currentIndexChanged.connect(self._on_point_type_selection)
         layout.addWidget(combo_ptype)
-        self.label_size = QLabel("Set size: (pixel)")
-        layout.addWidget(self.label_size)
+
         self.box_size = QDoubleSpinBox()
+        self.box_size.setPrefix("Size: ")
         self.box_size.setSingleStep(1)
         self.box_size.setDecimals(0)
-        layout.addWidget(self.box_size)
         self.box_size.setValue(self.size)
-        self.box_size.valueChanged.connect(self.set_size)
         self.box_size.setRange(0, 100)
+        self.box_size.valueChanged.connect(self.set_size)
+        layout.addWidget(self.box_size)
 
-        label_alpha = QLabel("Set Alpha:")
-        layout.addWidget(label_alpha)
         box_alpha = QDoubleSpinBox()
-        layout.addWidget(box_alpha)
+        box_alpha.setPrefix("Alpha: ")
         box_alpha.setSingleStep(0.01)
         box_alpha.setValue(self.alpha)
-        box_alpha.valueChanged.connect(self.set_alpha)
         box_alpha.setRange(0, 1)
+        box_alpha.valueChanged.connect(self.set_alpha)
+        layout.addWidget(box_alpha)
 
-        label_color = QLabel("Set ColorMode:")
+        label_color = QLabel("Color Mode:")
         layout.addWidget(label_color)
         self.combo_color = QComboBox()
         self.combo_color.addItem("flat color")
@@ -84,6 +87,8 @@ class CloudItem(BaseItem):
         self.combo_color.currentIndexChanged.connect(self._on_color_mode)
         layout.addWidget(self.combo_color)
 
+        label_rgb = QLabel("Color:")
+        layout.addWidget(label_rgb)
         self.edit_rgb = QLineEdit()
         self.edit_rgb.setToolTip("Hex number, i.e. #FF4500")
         self.edit_rgb.setText(f"#{self.flat_rgb:06x}")
@@ -96,14 +101,11 @@ class CloudItem(BaseItem):
         self.slider_v = RangeSlider()
         self.slider_v.setRange(0, 255)
         self.slider_v.rangeChanged.connect(self._on_range)
-
         layout.addWidget(self.slider_v)
-        self.combo_color.setCurrentIndex(self.color_mode)
 
-        # Add a checkbox for enabling/disabling depth test
         self.checkbox_depth_test = QCheckBox(
             "Show front points first (Depth Test)")
-        self.checkbox_depth_test.setChecked(self.depth_test_enabled)
+        self.checkbox_depth_test.setChecked(self.depth_test)
         self.checkbox_depth_test.stateChanged.connect(self.set_depthtest)
         layout.addWidget(self.checkbox_depth_test)
 
@@ -124,20 +126,25 @@ class CloudItem(BaseItem):
 
     def set_color_mode(self, color_mode):
         if color_mode in {'FLAT', 'RGB', 'I'}:
-            self.combo_color.setCurrentIndex(self.mode_table[color_mode])
+            try:
+                self.combo_color.setCurrentIndex(self.mode_table[color_mode])
+            except RuntimeError:
+                pass
+            except ValueError:
+                pass
         else:
             print(f"Invalid color mode: {color_mode}")
 
     def _on_point_type_selection(self, index):
         self.point_type = list(self.point_type_table.keys())[index]
         if self.point_type == 'PIXEL':
-            self.label_size.setText("Set size: (pixel)")
+            self.box_size.setPrefix("Set size (pixel): ")
             self.box_size.setDecimals(0)
             self.box_size.setSingleStep(1)
             self.box_size.setValue(1)
             self.size = 1
         else:
-            self.label_size.setText("Set size: (meter)")
+            self.box_size.setPrefix("Set size (meter): ")
             self.box_size.setDecimals(2)
             self.box_size.setSingleStep(0.01)
             self.box_size.setValue(0.01)
@@ -167,7 +174,7 @@ class CloudItem(BaseItem):
         self.need_update_setting = True
 
     def set_depthtest(self, state):
-        self.depth_test_enabled = state
+        self.depth_test = state
 
     def clear(self):
         data = np.empty((0), self.data_type)
@@ -236,13 +243,17 @@ class CloudItem(BaseItem):
             self.buff = new_buff
 
             # if exceed the maximum cloud size, randomly select half of the points
-            while self.buff.shape[0] >= self.max_cloud_size:
-                print("[Cloud Item] Exceed maximum cloud size, reduce to half")
-                new_buff = np.empty((self.buff.shape[0] // 2), self.data_type)
-                indices = np.random.choice(new_buff_top, new_buff_top // 2, replace=False)
-                new_buff = self.buff[indices]
-                new_buff_top = new_buff_top // 2
-                self.buff = new_buff
+            exceed_flag = False
+            while new_buff.shape[0] > self.max_cloud_size:
+                exceed_flag = True
+                new_buff_half = new_buff[:new_buff_top:2]
+                new_buff_top = new_buff_half.shape[0]
+                new_buff = new_buff_half
+            if exceed_flag:
+                print("[Cloud Item] Exceed maximum cloud size %d, reduce the data size" % self.max_cloud_size)
+                self.buff = self.buff[:self.max_cloud_size]
+                self.buff[:new_buff_top] = new_buff
+
 
             glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
             glBufferData(GL_ARRAY_BUFFER, self.buff.nbytes,
@@ -276,7 +287,7 @@ class CloudItem(BaseItem):
         glEnable(GL_BLEND)
         glEnable(GL_PROGRAM_POINT_SIZE)
         glEnable(GL_POINT_SPRITE)
-        if self.depth_test_enabled:
+        if self.depth_test:
             glEnable(GL_DEPTH_TEST)
         else:
             glDisable(GL_DEPTH_TEST)
@@ -291,9 +302,9 @@ class CloudItem(BaseItem):
         glEnableVertexAttribArray(0)
         glEnableVertexAttribArray(1)
 
-        view_matrix = self.glwidget().get_view_matrix()
+        view_matrix = self.glwidget().view_matrix
         set_uniform(self.program, view_matrix, 'view_matrix')
-        project_matrix = self.glwidget().get_projection_matrix()
+        project_matrix = self.glwidget().projection_matrix
         set_uniform(self.program, project_matrix, 'projection_matrix')
         width = self.glwidget().current_width()
         focal = project_matrix[0, 0] * width / 2
@@ -309,5 +320,5 @@ class CloudItem(BaseItem):
         glDisable(GL_POINT_SPRITE)
         glDisable(GL_PROGRAM_POINT_SIZE)
         glDisable(GL_BLEND)
-        if self.depth_test_enabled:
+        if self.depth_test:
             glDisable(GL_DEPTH_TEST)  # Disable depth testing if it was enabled

q3dviewer/custom_items/frame_item.py

@@ -42,7 +42,7 @@ void main()
 
 
 class FrameItem(BaseItem):
-    def __init__(self, T=np.eye(4), size=(1, 0.8), width=3, img=None):
+    def __init__(self, T=np.eye(4), size=(1, 0.8), width=3, img=None, color='#0000FF'):
         BaseItem.__init__(self)
         self.w, self.h = size
         self.width = width
@@ -50,6 +50,7 @@ class FrameItem(BaseItem):
         self.img = img
         self.texture = None
         self.need_updating = False
+        self.set_color(color)
 
     def initialize_gl(self):
         # Rectangle vertices and texture coordinates
@@ -57,11 +58,11 @@ class FrameItem(BaseItem):
         hh = self.h / 2
         self.vertices = np.array([
             # positions          # texture coords
-            [-hw, -hh,  0.0,  0.0, 0.0],  # bottom-left
-            [hw, -hh,  0.0,  1.0, 0.0],  # bottom-right
-            [hw,  hh,  0.0,  1.0, 1.0],  # top-right
-            [-hw,  hh,  0.0,  0.0, 1.0],   # top-left
-            [0,  0, -hh * 0.66, 0.0, 0.0],   # top-left
+            [-hw,  hh,  0.0,  0.0, 0.0],  # bottom-left
+            [ hw,  hh,  0.0,  1.0, 0.0],  # bottom-right
+            [ hw, -hh,  0.0,  1.0, 1.0],  # top-right
+            [-hw, -hh,  0.0,  0.0, 1.0],  # top-left
+            [ 0.0,  0.0, hh * 0.66, 0.0, 0.0],  # center -Z is the front.
         ], dtype=np.float32)
 
         self.indices = np.array([
@@ -123,23 +124,28 @@ class FrameItem(BaseItem):
 
         glBindVertexArray(0)
 
-    def set_transform(self, T):
-        self.T = T
-
-    def set_data(self, img=None, transform=None):
+    def set_transform(self, Twc, is_opencv_coord=False):
+        if is_opencv_coord:
+            # convert the opencv camera coordinate to the opengl camera coordinate
+            M_conv = np.array([
+                [1, 0, 0, 0],
+                [0, -1, 0, 0],
+                [0, 0, -1, 0],
+                [0, 0, 0, 1]
+            ])
+            Twc = Twc @ M_conv
+        self.Twc = Twc
+
+    def set_data(self, img=None, transform=None, is_opencv_coord=False):
         if transform is not None:
-            self.T = transform
+            self.set_transform(transform, is_opencv_coord)
         self.img = img
         self.need_updating = True
 
     def update_img_buffer(self):
-        if self.img is not None and self.need_updating:
+        if self.need_updating:
             self.texture = glGenTextures(1)
             glBindTexture(GL_TEXTURE_2D, self.texture)
-            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
-            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
-            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
-            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
             if self.img.ndim == 2:
                 # Convert grayscale to RGBA
                 self.img = np.stack((self.img,) * 3 + (np.ones_like(self.img) * 255,), axis=-1)
@@ -147,44 +153,57 @@ class FrameItem(BaseItem):
                 # Add an alpha channel
                 alpha_channel = np.ones((self.img.shape[0], self.img.shape[1], 1), dtype=np.uint8) * 255
                 self.img = np.concatenate((self.img, alpha_channel), axis=2)
-            
             img = np.ascontiguousarray(self.img, dtype=np.uint8)
-
             # Load image
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img.shape[1],
                          img.shape[0], 0, GL_RGBA, GL_UNSIGNED_BYTE, img)
             glGenerateMipmap(GL_TEXTURE_2D)
             glBindTexture(GL_TEXTURE_2D, 0)
             self.need_updating = False
+        
+    def set_color(self, color):
+        if isinstance(color, str):
+            self.rgba = hex_to_rgba(color)
+        elif isinstance(color, list):
+            self.rgba = color
+        elif isinstance(color, tuple):
+            self.rgba = list(color)
+        else:
+            raise ValueError("Invalid color format")
+
+    def set_line_width(self, width):
+        self.width = width
 
     def paint(self):
-        self.view_matrix = self.glwidget().get_view_matrix()
-        project_matrix = self.glwidget().get_projection_matrix()
-        self.update_img_buffer()
+        self.view_matrix = self.glwidget().view_matrix
+        project_matrix = self.glwidget().projection_matrix
 
         glEnable(GL_DEPTH_TEST)
         glEnable(GL_BLEND)
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 
-        glUseProgram(self.program)
-        set_uniform(self.program, self.view_matrix, 'view_matrix')
-        set_uniform(self.program, project_matrix, 'project_matrix')
-        set_uniform(self.program, self.T, 'model_matrix')
-        glBindVertexArray(self.vao)
-        
-        if self.texture is not None:
-            glBindTexture(GL_TEXTURE_2D, self.texture)
-            glMultMatrixf(self.T.T)  # Apply the transformation matrix
-            glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
-            glBindTexture(GL_TEXTURE_2D, 0)
+        if self.img is not None:
+            self.update_img_buffer()
+            glUseProgram(self.program)
+            set_uniform(self.program, self.view_matrix, 'view_matrix')
+            set_uniform(self.program, project_matrix, 'project_matrix')
+            set_uniform(self.program, self.T, 'model_matrix')
+            glBindVertexArray(self.vao)
+            glBindVertexArray(0)
+            glUseProgram(0)
+
+        # if self.texture is not None:
+        #     glBindTexture(GL_TEXTURE_2D, self.texture)
+        #     glMultMatrixf(self.T.T)  # Apply the transformation matrix
+        #     glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
+        #     glBindTexture(GL_TEXTURE_2D, 0)
         
-        glBindVertexArray(0)
-        glUseProgram(0)
-
         glLineWidth(self.width)
-        glColor4f(1, 1, 1, 1)  # Set the color before drawing the lines
+        # set color to bule
+        glColor4f(*self.rgba)
         glBindBuffer(GL_ARRAY_BUFFER, self.line_vbo)
         glEnableClientState(GL_VERTEX_ARRAY)
+        glMultMatrixf(self.T.T)
         glVertexPointer(3, GL_FLOAT, 0, None)
         glDrawArrays(GL_LINES, 0, len(self.line_vertices))
         glDisableClientState(GL_VERTEX_ARRAY)
@@ -192,3 +211,4 @@ class FrameItem(BaseItem):
 
         glDisable(GL_DEPTH_TEST)
         glDisable(GL_BLEND)
+