q3dviewer 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

q3dviewer/custom_items/cloud_item.py

@@ -1,297 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-from OpenGL.GLU import *
-from OpenGL.GLUT import *
-import numpy as np
-import threading
-from PyQt5.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, QSpinBox
-from PyQt5.QtGui import QValidator
-from OpenGL.GL import shaders
-
-
-vertex_shader = """
-#version 330 core
-
-layout (location = 0) in vec3 position;
-layout (location = 1) in uint value;
-
-uniform mat4 view_matrix;
-uniform mat4 projection_matrix;
-uniform float alpha;
-uniform int color_mode;
-uniform float vmin = 0;
-uniform float vmax = 255;
-out vec4 color;
-
-vec3 getRainbowColor(uint value_raw) {
-    // Normalize value to [0, 1]
-    float range = vmax - vmin;
-    float value = 1.0 - (float(value_raw) - vmin) / range;
-    value = clamp(value, 0.0, 1.0);
-    // Convert value to hue in the range [0, 1]
-    float hue = value * 5.0 + 1.0;
-    int i = int(floor(hue));
-    float f = hue - float(i);
-    if (mod(i, 2) == 0) f = 1.0 - f; // if i is even
-    float n = 1.0 - f;
-
-    // Determine RGB components based on hue value
-    vec3 color;
-    if (i <= 1) color = vec3(n, 0.0, 1.0);
-    else if (i == 2) color = vec3(0.0, n, 1.0);
-    else if (i == 3) color = vec3(0.0, 1.0, n);
-    else if (i == 4) color = vec3(n, 1.0, 0.0);
-    else if (i >= 5) color = vec3(1.0, n, 0.0);
-
-    return color;
-}
-
-void main()
-{
-    vec4 pw = vec4(position, 1.0);
-    vec4 pc = view_matrix * pw;
-    gl_Position = projection_matrix * pc;
-    vec3 c = vec3(1.0, 1.0, 1.0);
-    if (color_mode == -1)
-    {
-        c = getRainbowColor(value);
-    }
-    else if(color_mode == -2)
-    {
-        c.z = float(value & uint(0x000000FF))/255.;
-        c.y = float((value & uint(0x0000FF00)) >> 8)/255.;
-        c.x = float((value & uint(0x00FF0000)) >> 16)/255.;
-    }
-    else if(color_mode == -3)
-    {
-        uint intensity = value >> 24;
-        c = getRainbowColor(intensity);
-    }
-    else
-    {
-        c.z = float( uint(color_mode) & uint(0x000000FF))/255.;
-        c.y = float((uint(color_mode) & uint(0x0000FF00)) >> 8)/255.;
-        c.x = float((uint(color_mode) & uint(0x00FF0000)) >> 16)/255.;
-    }
-    color = vec4(c, alpha);
-}
-"""
-
-fragment_shader = """
-#version 330 core
-
-in vec4 color;
-
-out vec4 finalColor;
-
-void main()
-{
-    finalColor = color;
-}
-"""
-
-
-def set_uniform_mat4(shader, content, name):
-    content = content.T
-    glUniformMatrix4fv(
-        glGetUniformLocation(shader, name),
-        1,
-        GL_FALSE,
-        content.astype(np.float32)
-    )
-
-
-# draw points with color (x, y, z, color)
-class CloudItem(gl.GLGraphicsItem.GLGraphicsItem):
-    def __init__(self, size, alpha, color_mode='I'):
-        super().__init__()
-        self.valid_buff_top = 0
-        self.add_buff_loc = 0
-        self.alpha = alpha
-        self.size = size
-        self.mutex = threading.Lock()
-        self.data_type = [('xyz', '<f4', (3,)), ('color', '<u4')]
-        self.color_mode = color_mode
-        self.setColorMode(color_mode)
-        self.CAPACITY = 10000000  # 10MB * 3 (x,y,z, color) * 4
-        self.vmax = 255
-        self.buff = np.empty((0), self.data_type)
-        self.wait_add_data = None
-        self.need_update_setting = True
-
-    def addSetting(self, layout):
-        label1 = QLabel("Set Size:")
-        layout.addWidget(label1)
-        box1 = QSpinBox()
-        box1.setSingleStep(1)
-        layout.addWidget(box1)
-        box1.setValue(self.size)
-        box1.valueChanged.connect(self.setSize)
-        box1.setRange(0, 100)
-
-        label2 = QLabel("Set Alpha:")
-        layout.addWidget(label2)
-        box2 = QDoubleSpinBox()
-        layout.addWidget(box2)
-        box2.setSingleStep(0.01)
-        box2.setValue(self.alpha)
-        box2.valueChanged.connect(self.setAlpha)
-        box2.setRange(0, 1)
-
-        label3 = QLabel("Set ColorMode:")
-        label3.setToolTip(
-            "'I': intensity mode; 'IRGB': IRGB mode; 'RGB': rgb mode; '#xxxxxx'; matplotlib color, i.e. #FF4500;")
-        layout.addWidget(label3)
-        box3 = QLineEdit()
-        box3.setToolTip(
-            "'I': intensity mode; 'IRGB': IRGB mode; 'RGB': rgb mode; '#xxxxxx'; matplotlib color, i.e. #FF4500;")
-
-        box3.setText(str(self.color_mode))
-        box3.textChanged.connect(self.setColorMode)
-        layout.addWidget(box3)
-
-    def setAlpha(self, alpha):
-        self.alpha = alpha
-        self.need_update_setting = True
-
-    def setVmax(self, vmax):
-        self.vmax = vmax
-        self.need_update_setting = True
-
-    def setColorMode(self, color_mode):
-        """
-        intensity mode: -1;
-        rgb mode: -2;
-        matplotlib color: i.e. '#FF4500';
-        """
-        if (type(color_mode) == str):
-            if color_mode.startswith("#"):
-                try:
-                    self.color_mode_int = int(color_mode[1:], 16)
-                except ValueError:
-                    return
-            elif color_mode == 'RGB':
-                self.color_mode_int = -2
-            elif color_mode == 'IRGB':
-                self.color_mode_int = -3
-            elif color_mode == 'I':
-                self.color_mode_int = -1
-        else:
-            return
-        self.color_mode = color_mode
-        self.need_update_setting = True
-
-    def setSize(self, size):
-        self.size = size
-
-    def clear(self):
-        data = np.empty((0), self.data_type)
-        self.setData(data)
-
-    def setData(self, data, append=False):
-        if data.dtype is np.dtype('float32') or data.dtype is np.dtype('float64'):
-            xyz = data[:, :3]
-            if (data.shape[1] == 4):
-                color = data[:, 3].view(np.uint32)
-            else:
-                color = np.zeros(data.shape[0], dtype=np.uint32)
-            data = np.rec.fromarrays(
-                [xyz, color],
-                dtype=self.data_type)
-        self.mutex.acquire()
-        if (append is False):
-            self.wait_add_data = data
-            self.add_buff_loc = 0
-        else:
-            if (self.wait_add_data is None):
-                self.wait_add_data = data
-            else:
-                self.wait_add_data = np.concatenate([self.wait_add_data, data])
-            self.add_buff_loc = self.valid_buff_top
-        self.mutex.release()
-
-    def updateSetting(self):
-        if (self.need_update_setting is False):
-            return
-        glUseProgram(self.program)
-        glUniform1i(glGetUniformLocation(
-            self.program, "color_mode"), self.color_mode_int)
-        glUniform1f(glGetUniformLocation(self.program, "vmax"), self.vmax)
-        glUniform1f(glGetUniformLocation(self.program, "alpha"), self.alpha)
-        glUseProgram(0)
-        self.need_update_setting = False
-
-    def updateRenderBuffer(self):
-        # is not new data dont update buff
-        if (self.wait_add_data is None):
-            return
-        self.mutex.acquire()
-
-        new_buff_top = self.add_buff_loc + self.wait_add_data.shape[0]
-        if new_buff_top > self.buff.shape[0]:
-            # if need to update buff capacity, create new cpu buff and new vbo
-            buff_capacity = self.buff.shape[0]
-            while (new_buff_top > buff_capacity):
-                buff_capacity += self.CAPACITY
-            print("Update capacity to %d" % buff_capacity)
-            new_buff = np.empty((buff_capacity), self.data_type)
-            new_buff[:self.add_buff_loc] = self.buff[:self.add_buff_loc]
-            new_buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
-            self.buff = new_buff
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-            glBufferData(GL_ARRAY_BUFFER, self.buff.nbytes,
-                         self.buff, GL_DYNAMIC_DRAW)
-            glBindBuffer(GL_ARRAY_BUFFER, 0)
-        else:
-            self.buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-            glBufferSubData(GL_ARRAY_BUFFER, self.add_buff_loc * 16,
-                            self.wait_add_data.shape[0] * 16, self.wait_add_data)
-        self.valid_buff_top = new_buff_top
-        self.wait_add_data = None
-        self.mutex.release()
-
-    def initializeGL(self):
-        self.program = shaders.compileProgram(
-            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
-            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
-        )
-        # Bind attribute locations
-        # set constant parameter for cloud shader
-        self.setAlpha(self.alpha)
-        self.setColorMode(self.color_mode)
-        self.setVmax(self.vmax)
-        self.vbo = glGenBuffers(1)
-
-    def paint(self):
-        self.setupGLState()
-        self.updateRenderBuffer()
-        self.updateSetting()
-        glEnable(GL_BLEND)
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-        glUseProgram(self.program)
-        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 16, ctypes.c_void_p(0))
-        glVertexAttribPointer(
-            1, 1, GL_FLOAT, GL_UNSIGNED_INT, 16, ctypes.c_void_p(12))
-        glEnableVertexAttribArray(0)
-        glEnableVertexAttribArray(1)
-
-        view_matrix = np.array(
-            self._GLGraphicsItem__view.viewMatrix().data(), np.float32).reshape([4, 4]).T
-        set_uniform_mat4(self.program, view_matrix, 'view_matrix')
-        project_matrix = np.array(self._GLGraphicsItem__view.projectionMatrix(
-        ).data(), np.float32).reshape([4, 4]).T
-        set_uniform_mat4(self.program, project_matrix, 'projection_matrix')
-
-        glPointSize(self.size)
-        glDrawArrays(GL_POINTS, 0, self.valid_buff_top)
-
-        # unbind VBO
-        glDisableVertexAttribArray(0)
-        glDisableVertexAttribArray(1)
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-        glUseProgram(0)

q3dviewer/custom_items/gaussian_item.py

@@ -1,267 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-from OpenGL.GLU import *
-from OpenGL.GLUT import *
-import numpy as np
-import os
-from PyQt5.QtWidgets import QComboBox, QLabel
-from OpenGL.GL import shaders
-
-
-def div_round_up(x, y):
-    return int((x + y - 1) / y)
-
-
-def set_uniform_mat4(shader, content, name):
-    content = content.T
-    glUniformMatrix4fv(
-        glGetUniformLocation(shader, name),
-        1,
-        GL_FALSE,
-        content.astype(np.float32)
-    )
-
-
-def set_uniform_1int(shader, content, name):
-    glUniform1i(
-        glGetUniformLocation(shader, name),
-        content
-    )
-
-
-def set_uniform_v2(shader, contents, name):
-    glUniform2f(
-        glGetUniformLocation(shader, name),
-        *contents
-    )
-
-
-def set_uniform_v3(shader, contents, name):
-    glUniform3f(
-        glGetUniformLocation(shader, name),
-        *contents
-    )
-
-
-class GaussianItem(gl.GLGraphicsItem.GLGraphicsItem):
-    def __init__(self, **kwds):
-        super().__init__()
-        self.need_update_gs = False
-        self.sh_dim = 0
-        self.gs_data = np.empty([0])
-        self.prev_Rz = np.array([np.inf, np.inf, np.inf])
-        self.path = os.path.dirname(__file__)
-        try:
-            import torch
-            if not torch.cuda.is_available():
-                raise ImportError
-            self.cuda_pw = None
-            self.sort = self.torch_sort
-        except ImportError:
-                self.sort = self.opengl_sort
-
-    def addSetting(self, layout):
-        label1 = QLabel("set render mode:")
-        layout.addWidget(label1)
-        combo = QComboBox()
-        combo.addItem("render normal guassian")
-        combo.addItem("render ball")
-        combo.addItem("render inverse guassian")
-        combo.currentIndexChanged.connect(self.on_combobox_selection)
-        layout.addWidget(combo)
-
-    def on_combobox_selection(self, index):
-        glUseProgram(self.program)
-        set_uniform_1int(self.program, index, "render_mod")
-        glUseProgram(0)
-
-    def initializeGL(self):
-        fragment_shader = open(self.path + '/../shaders/gau_frag.glsl', 'r').read()
-        vertex_shader = open(self.path + '/../shaders/gau_vert.glsl', 'r').read()
-        sort_shader = open(self.path + '/../shaders/sort_by_key.glsl', 'r').read()
-        prep_shader = open(self.path + '/../shaders/gau_prep.glsl', 'r').read()
-
-        self.sort_program = shaders.compileProgram(
-            shaders.compileShader(sort_shader, GL_COMPUTE_SHADER))
-
-        self.prep_program = shaders.compileProgram(
-            shaders.compileShader(prep_shader, GL_COMPUTE_SHADER))
-
-        self.program = shaders.compileProgram(
-            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
-            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
-        )
-        positions = np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=np.float32)
-
-        self.vao = glGenVertexArrays(1)
-
-        # trade a gaussian as a square (4 2d points)
-        square_vert = np.array([-1, 1, 1, 1, 1, -1, -1, -1], dtype=np.float32)
-        indices = np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32)
-
-        # set the vertices for square
-        vbo = glGenBuffers(1)
-        glBindVertexArray(self.vao)
-        glBindBuffer(GL_ARRAY_BUFFER, vbo)
-        glBufferData(GL_ARRAY_BUFFER, square_vert.nbytes, square_vert, GL_STATIC_DRAW)
-        pos = glGetAttribLocation(self.program, 'vert')
-        glVertexAttribPointer(pos, 2, GL_FLOAT, False, 0, None)
-        glEnableVertexAttribArray(pos)
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-
-        # the vert's indices for drawing square
-        self.ebo = glGenBuffers(1)
-        glBindVertexArray(self.vao)
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
-                     indices.nbytes, indices, GL_STATIC_DRAW)
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
-        glBindVertexArray(0)
-
-        # add SSBO for gaussian data
-        self.ssbo_gs = glGenBuffers(1)
-        self.ssbo_gi = glGenBuffers(1)
-        self.ssbo_dp = glGenBuffers(1)
-        self.ssbo_pp = glGenBuffers(1)
-
-        width = self._GLGraphicsItem__view.deviceWidth()
-        height = self._GLGraphicsItem__view.deviceHeight()
-
-        # set constant parameter for gaussian shader
-        project_matrix = np.array(self._GLGraphicsItem__view.projectionMatrix().data(), np.float32).reshape([4, 4]).T
-        focal_x = project_matrix[0, 0] * width / 2
-        focal_y = project_matrix[1, 1] * height / 2
-        glUseProgram(self.prep_program)
-        set_uniform_mat4(self.prep_program, project_matrix, 'projection_matrix')
-        set_uniform_v2(self.prep_program, [focal_x, focal_y], 'focal')
-        glUseProgram(0)
-
-        glUseProgram(self.program)
-        set_uniform_v2(self.program, [width, height], 'win_size')
-        set_uniform_1int(self.program, 0, "render_mod")
-        glUseProgram(0)
-
-        # opengl settings
-        glDisable(GL_CULL_FACE)
-        glEnable(GL_BLEND)
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-
-    def update_gs(self):
-        if (self.need_update_gs):
-            # compute sorting size
-            self.num_sort = int(2**np.ceil(np.log2(self.gs_data.shape[0])))
-
-            # set input gaussian data
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gs)
-            glBufferData(GL_SHADER_STORAGE_BUFFER, self.gs_data.nbytes, self.gs_data.reshape(-1), GL_STATIC_DRAW)
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, self.ssbo_gs)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
-
-            # set depth for sorting
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_dp)
-            glBufferData(GL_SHADER_STORAGE_BUFFER, self.num_sort * 4, None, GL_STATIC_DRAW)
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, self.ssbo_dp)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
-
-            # set index for sorting (the index need be initialized)
-            gi = np.arange(self.num_sort, dtype=np.uint32)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gi)
-            glBufferData(GL_SHADER_STORAGE_BUFFER, self.num_sort * 4, gi, GL_STATIC_DRAW)
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, self.ssbo_gi)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
-
-            # set preprocess buffer
-            # the dim of preprocess data is 12 u(3), covinv(3), color(3), area(2), alpha(1)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_pp)
-            glBufferData(GL_SHADER_STORAGE_BUFFER, self.gs_data.shape[0] * 4 * 12,
-                         None, GL_STATIC_DRAW)
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, self.ssbo_pp)
-            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
-
-            glUseProgram(self.prep_program)
-            set_uniform_1int(self.prep_program, self.sh_dim, "sh_dim")
-            set_uniform_1int(self.prep_program, self.gs_data.shape[0], "gs_num")
-            glUseProgram(0)
-            self.need_update_gs = False
-
-    def paint(self):
-        # get current view matrix
-        self.view_matrix = np.array(self._GLGraphicsItem__view.viewMatrix().data(), np.float32).reshape([4, 4]).T
-
-        # if gaussian data is update, renew vao, ssbo, etc...
-        self.update_gs()
-
-        if (self.gs_data.shape[0] == 0):
-            return
-
-        # preprocess and sort gaussian by compute shader.
-        self.preprocess_gs()
-        self.try_sort()
-
-        # draw by vert shader
-        glUseProgram(self.program)
-        # bind vao and ebo
-        glBindVertexArray(self.vao)
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
-        # draw instances
-        glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None, self.gs_data.shape[0])
-        # upbind vao and ebo
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
-        glBindVertexArray(0)
-        glUseProgram(0)
-
-    def try_sort(self):
-        # don't sort if the depths are not change.
-        Rz = self.view_matrix[2, :3]
-        if (np.linalg.norm(self.prev_Rz - Rz) > 0.1):
-            # import torch
-            # torch.cuda.synchronize()
-            # start = time.time()
-            self.sort()
-            self.prev_Rz = Rz
-            # torch.cuda.synchronize()
-            # end = time.time()
-            # time_diff = end - start
-            # print(time_diff)
-
-    def opengl_sort(self):
-        glUseProgram(self.sort_program)
-        # can we move this loop to gpu?
-        for level in 2**np.arange(1, int(np.ceil(np.log2(self.num_sort))+1)):  # level = level*2
-            for stage in level/2**np.arange(1, np.log2(level)+1):   # stage =stage / 2
-                set_uniform_1int(self.sort_program, int(level), "level")
-                set_uniform_1int(self.sort_program, int(stage), "stage")
-                glDispatchCompute(div_round_up(self.num_sort//2, 256), 1, 1)
-                glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT)
-        # glFinish()
-        glUseProgram(0)
-
-    def torch_sort(self):
-        import torch
-        if self.cuda_pw is None:
-            self.cuda_pw = torch.tensor(self.gs_data[:, :3]).cuda()
-        Rz = torch.tensor(self.view_matrix[2, :3]).cuda()
-        depth = Rz @ self.cuda_pw.T
-        index = torch.argsort(depth).type(torch.int32).cpu().numpy()
-        glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gi)
-        glBufferData(GL_SHADER_STORAGE_BUFFER, index.nbytes, index, GL_STATIC_DRAW)
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, self.ssbo_gi)
-        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
-        return index
-
-    def preprocess_gs(self):
-        glUseProgram(self.prep_program)
-        set_uniform_mat4(self.prep_program, self.view_matrix, 'view_matrix')
-        glDispatchCompute(div_round_up(self.gs_data.shape[0], 256), 1, 1)
-        glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT)
-        glUseProgram(0)
-
-    def setData(self, **kwds):
-        if 'gs_data' in kwds:
-            gs_data = kwds.pop('gs_data')
-            self.gs_data = np.ascontiguousarray(gs_data, dtype=np.float32)
-            self.sh_dim = self.gs_data.shape[-1] - (3 + 4 + 3 + 1)
-        self.need_update_gs = True

q3dviewer/custom_items/grid_item.py

@@ -1,37 +0,0 @@
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-from PyQt5.QtWidgets import QLabel, QDoubleSpinBox
-
-
-class GridItem(gl.GLGridItem):
-    def __init__(self, size, spacing, color=(255, 255, 255, 76.5)):
-        super(GridItem, self).__init__(color=color)
-        self.setSize0(size)
-        self.setSpacing0(spacing)
-
-    def addSetting(self, layout):
-        label1 = QLabel("Set size:")
-        layout.addWidget(label1)
-        box1 = QDoubleSpinBox()
-        box1.setSingleStep(1.0)
-        layout.addWidget(box1)
-        box1.setValue(self.size0)
-        box1.valueChanged.connect(self.setSize0)
-        box1.setRange(0, 100000)
-
-        label2 = QLabel("Set spacing:")
-        layout.addWidget(label2)
-        box2 = QDoubleSpinBox()
-        layout.addWidget(box2)
-        box2.setSingleStep(0.1)
-        box2.setValue(self.spacing0)
-        box2.valueChanged.connect(self.setSpacing0)
-        box2.setRange(0, 1000)
-
-    def setSize0(self, size):
-        self.size0 = size
-        self.setSize(self.size0, self.size0)
-
-    def setSpacing0(self, spacing):
-        self.spacing0 = spacing
-        self.setSpacing(self.spacing0, self.spacing0)