python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/LMVis/layers/LUTOverlayLayer.py

@@ -0,0 +1,346 @@
+#!/usr/bin/python
+
+# LUTOverlayLayer.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import numpy
+import numpy as np
+# import pylab
+
+from PYME.recipes.traits import Bool
+
+from PYME.LMVis.layers.OverlayLayer import OverlayLayer
+from OpenGL.GL import *
+from PYME.LMVis.shader_programs.DefaultShaderProgram import DefaultShaderProgram, ImageShaderProgram
+
+
+class _LUTOverlayLayer(OverlayLayer):
+    """
+    This OverlayLayer produces a bar that indicates the given color map.
+    """
+
+    show_bounds = Bool(False)
+    
+    def __init__(self, offset=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+
+        offset      offset of the canvas origin where it should be drawn.
+                    Currently only offset[0] is used
+        """
+        if not offset:
+            offset = [10, 10]
+            
+        OverlayLayer.__init__(self, offset, **kwargs)
+
+        self.set_offset(offset)
+
+        self._lut_width_px = 10.0
+        self._border_colour = [.5, .5, 0]
+        self.set_shader_program(DefaultShaderProgram)
+        
+        self._labels = {}
+        
+    def _get_label(self, layer):
+        from . import text
+        try:
+            return self._labels[layer]
+        except KeyError:
+            self._labels[layer] = [text.Text(), text.Text()]
+
+            return self._labels[layer]
+
+
+    def render(self, gl_canvas):
+        if not self.visible:
+            return
+        
+        labels = []
+        
+        with self.get_shader_program(gl_canvas) as sp:
+            sp.clear_shader_clipping()
+            glDisable(GL_DEPTH_TEST)
+            glDisable(GL_LIGHTING)
+            glDisable(GL_BLEND)
+            #view_size_x = gl_canvas.xmax - gl_canvas.xmin
+            #view_size_y = gl_canvas.ymax - gl_canvas.ymin
+            
+            view_size_x, view_size_y = gl_canvas.Size
+
+            # upper right y
+            lb_ur_y = .1 * view_size_y
+            # lower right y
+            lb_lr_y = 0.9 * view_size_y
+
+            lb_len =lb_lr_y -  lb_ur_y
+            
+            lb_width = self._lut_width_px #* view_size_x / gl_canvas.Size[0]
+            
+            visible_layers = [l for l in gl_canvas.layers if (getattr(l, 'visible', True) and getattr(l, 'show_lut', True))]
+            
+            
+            
+            for j, l in enumerate(visible_layers):
+                cmap = l.colour_map
+                
+                # upper right x
+                lb_ur_x = view_size_x - self.get_offset()[0] - j*1.5*lb_width
+                
+                # upper left x
+                lb_ul_x = lb_ur_x - lb_width
+                
+                #print(lb_ur_x, lb_ur_y, lb_lr_y, lb_ul_x, lb_width, lb_len, view_size_x, view_size_y)
+
+                glBegin(GL_QUAD_STRIP)
+    
+                for i in numpy.arange(0, 1.01, .01):
+                    glColor3fv(cmap(i)[:3])
+                    glVertex2f(lb_ul_x, lb_ur_y + (1.- i) * lb_len)
+                    glVertex2f(lb_ur_x, lb_ur_y + (1.- i) * lb_len)
+    
+                glEnd()
+    
+                glBegin(GL_LINE_LOOP)
+                glColor3fv(self._border_colour)
+                glVertex2f(lb_ul_x, lb_lr_y)
+                glVertex2f(lb_ur_x, lb_lr_y)
+                glVertex2f(lb_ur_x, lb_ur_y)
+                glVertex2f(lb_ul_x, lb_ur_y)
+                glEnd()
+                
+                if hasattr(l, 'clim') and self.show_bounds:
+                    tl, tu = self._get_label(l)
+                    cl, cu = l.clim
+                    tu.text = '%.3G' % cu
+                    tl.text = '%.3G' % cl
+                    
+                    xc = lb_ur_x - 0.5*lb_width
+
+                    _, hu, wu = tu.get_img_array(gl_canvas)
+                    _, hl, wl = tl.get_img_array(gl_canvas)
+                    
+                    tu.pos = (xc - wu/2, lb_ur_y - hu)
+                    tl.pos = (xc - wl/2, lb_lr_y)
+                    
+                    labels.extend([tl, tu])
+                
+        for l in labels:
+            l.render(gl_canvas)
+                
+class LUTOverlayLayer(OverlayLayer):
+    """
+    This OverlayLayer produces a bar that indicates the given color map.
+    """
+
+    show_bounds = Bool(False)
+    
+    def __init__(self, offset=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+
+        offset      offset of the canvas origin where it should be drawn.
+                    Currently only offset[0] is used
+        """
+        if not offset:
+            offset = [10, 10]
+            
+        OverlayLayer.__init__(self, offset, **kwargs)
+
+        self.set_offset(offset)
+
+        self._lut_width_px = 10.0
+        self._border_colour = [.5, .5, 0]
+        self.set_shader_program(ImageShaderProgram)
+        
+        self._labels = {}
+
+        self._texture_id = None
+        self._lut_id = None
+        #self._lut_key = None
+        
+    def _get_label(self, layer):
+        from . import text
+        try:
+            return self._labels[layer]
+        except KeyError:
+            self._labels[layer] = [text.Text(), text.Text()]
+
+            return self._labels[layer]
+        
+    def set_texture(self):
+        if self._texture_id is None:
+            self._texture_id = glGenTextures(1)
+    
+            image = np.linspace(0, 1, 255).reshape([1, 255]).astype('f')# image.T.reshape(*image.shape) #get our byte order right
+    
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self._texture_id)
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            #glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            #glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            #glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, image.shape[0], image.shape[1], 0, GL_RED, GL_FLOAT, image.astype('f4'))
+        else:
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self._texture_id)
+
+    def set_lut(self, cmap):
+        if self._lut_id is None:
+            self._lut_id = glGenTextures(1)
+    
+        lut_array = cmap(np.linspace(0, 1.0, 255))
+        
+        glActiveTexture(GL_TEXTURE1)
+        glBindTexture(GL_TEXTURE_1D, self._lut_id)
+
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        #glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP)
+        #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+        glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+        glTexParameteri (GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        #glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
+        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, lut_array.shape[0], 0, GL_RGBA, GL_FLOAT,
+                    lut_array.astype('f4'))
+
+
+    def render(self, gl_canvas):
+        if not self.visible:
+            return
+        
+        labels = []
+        
+        with self.get_shader_program(gl_canvas) as sp:
+            sp.clear_shader_clipping()
+            glDisable(GL_DEPTH_TEST)
+            #glDisable(GL_LIGHTING)
+            glDisable(GL_BLEND)
+
+            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+            
+            #view_size_x = gl_canvas.xmax - gl_canvas.xmin
+            #view_size_y = gl_canvas.ymax - gl_canvas.ymin
+            
+            view_size_x, view_size_y = gl_canvas.Size
+
+            # upper right y
+            lb_ur_y = .1 * view_size_y
+            # lower right y
+            lb_lr_y = 0.9 * view_size_y
+
+            lb_len =lb_lr_y -  lb_ur_y
+            
+            lb_width = self._lut_width_px #* view_size_x / gl_canvas.Size[0]
+            
+            visible_layers = [l for l in gl_canvas.layers if (getattr(l, 'visible', True) and getattr(l, 'show_lut', True))]
+            
+            self.set_texture()
+            glUniform1i(sp.get_uniform_location('im_sampler'), 0)
+
+            if gl_canvas.core_profile:
+                sp.set_modelviewprojectionmatrix(np.array(gl_canvas.mvp, 'f'))
+            
+            for j, l in enumerate(visible_layers):
+                cmap = l.colour_map
+                self.set_lut(cmap)
+                glUniform1i(sp.get_uniform_location('lut'), 1)
+                glUniform2f(sp.get_uniform_location('clim'), 0, 1)
+                
+                # upper right x
+                lb_ur_x = view_size_x - self.get_offset()[0] - j*1.5*lb_width
+                
+                # upper left x
+                lb_ul_x = lb_ur_x - lb_width
+                
+                #print(lb_ur_x, lb_ur_y, lb_lr_y, lb_ul_x, lb_width, lb_len, view_size_x, view_size_y)
+
+                verts = self._gen_rect_triangles(lb_ul_x, lb_ur_y, lb_width , lb_len)
+                tex_coords = self._gen_rect_texture_coords()
+                
+                # glBegin(GL_QUAD_STRIP)
+    
+                # for i in numpy.arange(0, 1.01, .01):
+                #     glColor3fv(cmap(i)[:3])
+                #     glVertex2f(lb_ul_x, lb_ur_y + (1.- i) * lb_len)
+                #     glVertex2f(lb_ur_x, lb_ur_y + (1.- i) * lb_len)
+    
+                # glEnd()
+
+                if gl_canvas.core_profile:
+                    vao = glGenVertexArrays(1)
+                    vbo = glGenBuffers(2)
+
+                    glBindVertexArray(vao)
+                    glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
+                    glBufferData(GL_ARRAY_BUFFER, verts, GL_STATIC_DRAW)
+                    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
+                    glEnableVertexAttribArray(0)
+                    glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
+                    glBufferData(GL_ARRAY_BUFFER, tex_coords, GL_STATIC_DRAW)
+                    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, None)
+                    glEnableVertexAttribArray(1)
+                else:
+                    glVertexPointerf(verts)
+                    glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+                    glTexCoordPointerf(tex_coords)
+                
+                glDrawArrays(GL_TRIANGLES, 0, 6)
+
+                if gl_canvas.core_profile:
+                    glBindVertexArray(0)
+                    glDeleteVertexArrays(1, [vao,])
+                    glDeleteBuffers(1, vbo)
+                else:
+                    glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+    
+                # glBegin(GL_LINE_LOOP)
+                # glColor3fv(self._border_colour)
+                # glVertex2f(lb_ul_x, lb_lr_y)
+                # glVertex2f(lb_ur_x, lb_lr_y)
+                # glVertex2f(lb_ur_x, lb_ur_y)
+                # glVertex2f(lb_ul_x, lb_ur_y)
+                # glEnd()
+                
+                if hasattr(l, 'clim') and self.show_bounds:
+                    tl, tu = self._get_label(l)
+                    cl, cu = l.clim
+                    tu.text = '%.3G' % cu
+                    tl.text = '%.3G' % cl
+                    
+                    xc = lb_ur_x - 0.5*lb_width
+
+                    _, hu, wu = tu.get_img_array(gl_canvas)
+                    _, hl, wl = tl.get_img_array(gl_canvas)
+                    
+                    tu.pos = (xc - wu/2, lb_ur_y - hu)
+                    tl.pos = (xc - wl/2, lb_lr_y)
+                    
+                    labels.extend([tl, tu])
+                
+        for l in labels:
+            l.render(gl_canvas)

PYME/LMVis/layers/OverlayLayer.py

@@ -0,0 +1,46 @@
+#!/usr/bin/python
+
+# OverlayLayer.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import abc
+
+from PYME.LMVis.layers.base import SimpleLayer, BindMixin
+from PYME.LMVis.shader_programs.DefaultShaderProgram import DefaultShaderProgram
+
+
+class OverlayLayer(SimpleLayer, BindMixin):
+    def __init__(self, offset, **kwargs):
+        SimpleLayer.__init__(self, **kwargs)
+        BindMixin.__init__(self)
+
+        if offset:
+            self._offset = offset
+        else:
+            self._offset = [10, 10]
+        self.set_shader_program(DefaultShaderProgram)
+
+    def set_offset(self, offset):
+        self._offset = offset
+
+    def get_offset(self):
+        return self._offset
+
+    @abc.abstractmethod
+    def render(self, gl_canvas):
+        pass

PYME/LMVis/layers/ScaleBarOverlayLayer.py

@@ -0,0 +1,97 @@
+#!/usr/bin/python
+
+# ScaleBarOverlayLayer.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+from PYME.LMVis.layers.OverlayLayer import OverlayLayer
+from OpenGL.GL import *
+from PYME.LMVis.shader_programs.DefaultShaderProgram import DefaultShaderProgram
+import numpy as np
+
+
+class ScaleBarOverlayLayer(OverlayLayer):
+    """
+    This class creates a scale bar that indicate the size, depending on the zoom level
+    """
+    def __init__(self, offset=None, color=None, **kwargs):
+        super(ScaleBarOverlayLayer, self).__init__(offset, **kwargs)
+        if not color:
+            self._color = [1.0, 1.0, 1.0]
+        else:
+            self._color = color
+        self._scale_bar_depth = 10
+        self._scale_bar_length = 1000
+        self.set_shader_program(DefaultShaderProgram)
+
+    def set_scale_bar_length(self, length):
+        self._scale_bar_length = length
+
+    def set_scale_bar_depth(self, depth):
+        self._scale_bar_depth = depth
+
+
+    def render(self, gl_canvas):
+        """
+
+        Parameters
+        ----------
+        gl_canvas: GLCanvas
+            the scaleBarLength is currently used, but should be passed with a setter in the future
+            xmin, xmax, ymin, ymax and Size is used to get the total size of the canvas and to calculate
+            the real size of the scale bar
+
+             
+        Returns
+        -------
+
+        """
+        if not self.visible:
+            return
+        
+        core_profile = gl_canvas.core_profile
+        
+        with self.get_shader_program(gl_canvas) as sp:
+            sp.clear_shader_clipping()
+            if self._scale_bar_length:
+                view_size_x = gl_canvas.xmax - gl_canvas.xmin
+                view_size_y = gl_canvas.ymax - gl_canvas.ymin
+
+                sb_ur_x = -gl_canvas.view.translation[0] + gl_canvas.xmax - self.get_offset()[0] * view_size_x / gl_canvas.Size[0]
+                #sb_ur_y = - gl_canvas.yc + gl_canvas.ymax - self.get_offset()[1] * view_size_y / gl_canvas.Size[1]
+                sb_ur_y = -gl_canvas.view.translation[1] + gl_canvas.ymin + self.get_offset()[1] * view_size_y / gl_canvas.Size[1]
+                sb_depth = self._scale_bar_depth * view_size_y / gl_canvas.Size[1]
+
+                #glDisable(GL_LIGHTING)
+
+                self._verts = self._gen_rect_triangles(sb_ur_x - self._scale_bar_length, sb_ur_y, self._scale_bar_length, sb_depth)
+
+                #v = np.hstack([self._verts, np.ones((6, 1), 'f')])
+                #print(self._verts, np.dot(np.array(gl_canvas.mvp), v.T))
+                #print(self._verts.shape, self._verts.dtype)
+                col = np.ones(4, 'f')
+                col[:3] = self._color
+                self._cols =np.tile(col, 6)
+
+                if core_profile:
+                    sp.set_modelviewprojectionmatrix(np.array(gl_canvas.mvp))
+
+                self._bind_data('scalebar', self._verts, 0*self._verts, self._cols, sp, core_profile=core_profile)
+
+                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+                glDrawArrays(GL_TRIANGLES, 0, 6)
+

PYME/LMVis/layers/ScaleBoxOverlayLayer.py

@@ -0,0 +1,181 @@
+#!/usr/bin/python
+
+# ScaleBoxOverlayLayer.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+from math import floor
+
+import numpy as np
+
+from .OverlayLayer import OverlayLayer
+from OpenGL.GL import *
+
+
+class ScaleBoxOverlayLayer(OverlayLayer):
+    def __init__(self, tick_distance=1000, color=None, **kwargs):
+        """
+        
+        Parameters
+        ----------
+        color       [r, g, b] , rgb = float [0.0,1.0]
+        """
+        
+        
+        offset = None
+        super(ScaleBoxOverlayLayer, self).__init__(offset, **kwargs)
+        if not color:
+            self._color = [1.0, 1.0, 1.0, 0.5]
+        else:
+            self._color = color
+
+        self._tick_distance = tick_distance
+        #self._box_dimensions = None
+        #self._starts = [0.0, 0.0, 0.0]
+        #self.set_box_dimensions(box_dimensions)
+        self._show = False
+        self._flips = [False, False, False]
+
+    def show(self, boolean):
+        self._show = boolean
+
+    def set_tick_distance(self, value):
+        """
+        Set the distance between two ticks in the box
+        Parameters
+        ----------
+        value   float, >0
+
+        Returns
+        -------
+
+        """
+        if value is not None:
+            self._tick_distance = value
+
+    def get_tick_distance(self):
+        return self._tick_distance
+
+    def set_box_dimensions(self, box_dimensions):
+        """
+        
+        Parameters
+        ----------
+        box_dimensions  (width, height, depth) or (x/y/z) in nm 
+                        is smaller than tick size, tick size is used
+
+        Returns
+        -------
+
+        """
+        raise NotImplementedError('box dimensions are now inferred from the data bounding-box')
+        
+        new_box_dimensions = np.zeros((3, 1))
+        index = 0
+        for value in box_dimensions:
+            if value < self._tick_distance:
+                new_box_dimensions[index] = self._tick_distance
+            else:
+                new_box_dimensions[index] = value
+            index += 1
+
+        self._box_dimensions = new_box_dimensions
+
+    def set_color(self, color):
+        self._color = color
+
+    def set_starts(self, start_x, start_y, start_z):
+        self._starts = [start_x, start_y, start_z]
+
+    def flip_starts(self, flip_x=None, flip_y=None, flip_z=None):
+        """
+        There's six possible sides of the bounding box. Only three are used
+        to draw the grids. With this method you can change to the other ones.
+        Parameters
+        ----------
+        flip_x      change grid position in the x plane
+        flip_y      change grid position in the y plane
+        flip_z      change grid position in the z plane
+
+        Returns
+        -------
+
+        """
+
+        if flip_x:
+            self._flips[0] = not self._flips[0]
+
+        if flip_y:
+            self._flips[1] = not self._flips[1]
+
+        if flip_z:
+            self._flips[2] = not self._flips[2]
+
+    def render(self, gl_canvas):
+        if self._show and self.visible: #handle old _show as well as the standard .visible
+            bbox = gl_canvas.bbox
+    
+            if bbox is None:
+                return
+            
+            
+            with self.get_shader_program(gl_canvas) as sp:
+                sp.clear_shader_clipping()
+
+                if gl_canvas.core_profile:
+                    sp.set_modelviewprojectionmatrix(gl_canvas.mvp)
+                
+
+                glLineWidth(1.0)
+
+                x0, y0, z0, x1, y1, z1 = bbox                  
+                delta_x, delta_y, delta_z = bbox[3:] - bbox[:3]
+
+
+                n_lines_x = int(floor(delta_x / self._tick_distance)) + 1
+                n_lines_y = int(floor(delta_y / self._tick_distance)) + 1
+                n_lines_z = int(floor(delta_z / self._tick_distance)) + 1
+
+                #xy wall
+                zp = z0 if self._flips[2] else z1
+                #verticals
+                vertices = [(x0 + j*self._tick_distance, y0, zp, x0 + j*self._tick_distance, y1, zp) for j in range(n_lines_x)]
+                #horizontals
+                vertices += [(x0, y0 + j*self._tick_distance, zp, x1, y0 + j*self._tick_distance, zp) for j in range(n_lines_y)]
+
+                #xz wall
+                yp = y0 if self._flips[1] else y1
+                #verticals
+                vertices += [(x0 + j*self._tick_distance, yp, z0, x0 + j*self._tick_distance, yp, z1) for j in range(n_lines_x)]
+                #horizontals
+                vertices += [(x0, yp, z0 + j*self._tick_distance, x1, yp, z0 + j*self._tick_distance) for j in range(n_lines_z)]
+
+                #yz wall
+                xp = x0 if self._flips[1] else x1
+                #verticals
+                vertices += [(xp, y0 + j*self._tick_distance, z0, xp, y0 + j*self._tick_distance, z1) for j in range(n_lines_y)]
+                #horizontals
+                vertices += [(xp, y0, z0 + j*self._tick_distance, xp, y1, z0 + j*self._tick_distance) for j in range(n_lines_z)]
+
+                vertices = np.hstack(vertices).astype('f')
+                cols = np.tile(self._color, len(vertices)//3)
+
+                #print('vertices.shape: ', vertices.shape, ', n_lines:', n_lines_x, n_lines_y, n_lines_z)
+
+                self._bind_data('scalebox', vertices, 0*vertices, cols, sp, core_profile=gl_canvas.core_profile)
+
+                glDrawArrays(GL_LINES, 0, len(vertices))