melage 0.0.65__py3-none-any.whl

melage/graphics/functions.py

@@ -0,0 +1,101 @@
+
+from __future__ import division
+
+import numpy as np
+from PyQt5 import QtGui
+
+"""
+taken from pyqtgraph https://github.com/pyqtgraph/pyqtgraph
+"""
+    
+
+
+
+def transformToArray(tr):
+    """
+    Given a QTransform, return a 3x3 numpy array.
+    Given a QMatrix4x4, return a 4x4 numpy array.
+
+    Example: map an array of x,y coordinates through a transform::
+
+        ## coordinates to map are (1,5), (2,6), (3,7), and (4,8)
+        coords = np.array([[1,2,3,4], [5,6,7,8], [1,1,1,1]])  # the extra '1' coordinate is needed for translation to work
+
+        ## Make an example transform
+        tr = QtGui.QTransform()
+        tr.translate(3,4)
+        tr.scale(2, 0.1)
+
+        ## convert to array
+        m = pg.transformToArray()[:2]  # ignore the perspective portion of the transformation
+
+        ## map coordinates through transform
+        mapped = np.dot(m, coords)
+    """
+    #return np.array([[tr.m11(), tr.m12(), tr.m13()],[tr.m21(), tr.m22(), tr.m23()],[tr.m31(), tr.m32(), tr.m33()]])
+    ## The order of elements given by the method names m11..m33 is misleading--
+    ## It is most common for x,y translation to occupy the positions 1,3 and 2,3 in
+    ## a transformation matrix. However, with QTransform these values appear at m31 and m32.
+    ## So the correct interpretation is transposed:
+    if isinstance(tr, QtGui.QTransform):
+        return np.array([[tr.m11(), tr.m21(), tr.m31()], [tr.m12(), tr.m22(), tr.m32()], [tr.m13(), tr.m23(), tr.m33()]])
+    elif isinstance(tr, QtGui.QMatrix4x4):
+        return np.array(tr.copyDataTo()).reshape(4,4)
+    else:
+        raise Exception("Transform argument must be either QTransform or QMatrix4x4.")
+
+def transformCoordinates(tr, coords, transpose=False):
+    """
+    Map a set of 2D or 3D coordinates through a QTransform or QMatrix4x4.
+    The shape of coords must be (2,...) or (3,...)
+    The mapping will _ignore_ any perspective transformations.
+    
+    For coordinate arrays with ndim=2, this is basically equivalent to matrix multiplication.
+    Most arrays, however, prefer to put the coordinate axis at the end (eg. shape=(...,3)). To 
+    allow this, use transpose=True.
+    
+    """
+    
+    if transpose:
+        ## move last axis to beginning. This transposition will be reversed before returning the mapped coordinates.
+        coords = coords.transpose((coords.ndim-1,) + tuple(range(0,coords.ndim-1)))
+    
+    nd = coords.shape[0]
+    if isinstance(tr, np.ndarray):
+        m = tr
+    else:
+        m = transformToArray(tr)
+        m = m[:m.shape[0]-1]  # remove perspective
+    
+    ## If coords are 3D and tr is 2D, assume no change for Z axis
+    if m.shape == (2,3) and nd == 3:
+        m2 = np.zeros((3,4))
+        m2[:2, :2] = m[:2,:2]
+        m2[:2, 3] = m[:2,2]
+        m2[2,2] = 1
+        m = m2
+    
+    ## if coords are 2D and tr is 3D, ignore Z axis
+    if m.shape == (3,4) and nd == 2:
+        m2 = np.empty((2,3))
+        m2[:,:2] = m[:2,:2]
+        m2[:,2] = m[:2,3]
+        m = m2
+    
+    ## reshape tr and coords to prepare for multiplication
+    m = m.reshape(m.shape + (1,)*(coords.ndim-1))
+    coords = coords[np.newaxis, ...]
+    
+    # separate scale/rotate and translation    
+    translate = m[:,-1]  
+    m = m[:, :-1]
+    
+    ## map coordinates and return
+    mapped = (m*coords).sum(axis=1)  ## apply scale/rotate
+    mapped += translate
+    
+    if transpose:
+        ## move first axis to end.
+        mapped = mapped.transpose(tuple(range(1,mapped.ndim)) + (0,))
+    return mapped
+    

melage/graphics/items/GLAxisItem.py

@@ -0,0 +1,149 @@
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+import numpy as np
+from PyQt5 import QtGui
+
+
+__AUTHOR__ = 'Bahram Jafrasteh'
+"""
+Inspiration from pyqtgraph https://github.com/pyqtgraph/pyqtgraph
+"""
+__all__ = ['GLAxisItem']
+
+class GLAxisItem(GLGraphicsItem):
+    """
+    """
+    
+    def __init__(self, size=None, antialias=True, glOptions='translucent'):
+        GLGraphicsItem.__init__(self)
+        self.txt = False
+        self.antialias = antialias
+        self.setGLOptions(glOptions)
+        self.GLViewWidget = None
+        self.xO = 0
+        self.yO = 0
+        self.zO = 0
+
+
+    def setOriging(self, xO, yO, zO):
+        """
+        By Bahram jafrasteh
+        :param xO:
+        :param yO:
+        :param zO:
+        :return:
+        """
+        self.xO = xO
+        self.yO = yO
+        self.zO = zO
+
+    def setSize(self, xmin=None, xmax= None,
+                ymin=None, ymax = None,  zmin=None,
+                zmax = None, size=None):
+        """
+        By Bahram Jafrasteh
+        Set the size of the axes (in its local coordinate system; this does not affect the transform)
+        Arguments can be x,y,z or size=QVector3D().
+        """
+        if size is not None:
+            xmin = size.xmin()
+            ymin = size.ymin()
+            zmin = size.zmin()
+            xmax = size.xmax()
+            ymax = size.ymax()
+            zmax = size.zmax()
+        self.__size = [xmin, xmax, ymin, ymax, zmin, zmax]
+        self.update()
+        
+    def size(self):
+        return self.__size[:]
+    def setGLViewWidget(self, GLViewWidget):
+        """
+        By Bahram Jafrasteh
+        :param GLViewWidget:
+        :return:
+        """
+        self.GLViewWidget = GLViewWidget
+    
+    def paint(self):
+
+        self.setupGLState()
+
+        glEnable(GL_DEPTH_TEST)
+        glLineWidth(5)
+
+
+        xmin, xmax, ymin, ymax, zmin, zmax = self.size()
+
+        x = np.arange(xmin, xmax + (xmax - xmin) / 10, (xmax - xmin) / 5).astype("int")
+        y = np.arange(ymin, ymax + (ymax - ymin) / 10, (ymax - ymin) / 5).astype("int")
+        z = np.arange(zmin, zmax + (zmax - zmin) / 10, (zmax - zmin) / 5).astype("int")
+        xmax = x[-1];
+        ymax = y[-1];
+        zmax = z[-1]
+        glColor4f(1, 0, 1, 1)  # z is green
+
+
+        glBegin(GL_LINES)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(self.xO, self.yO, zmax)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(self.xO, self.yO, zmin)
+        glEnd()
+
+        glColor4f(1, 0, 0, 1)  # y is red
+        glBegin(GL_LINES)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(self.xO, ymax, self.zO)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(self.xO, ymin, self.zO)
+        glEnd()
+
+        glColor4f(0, 0, 1, 1)  # x is blue
+        glBegin(GL_LINES)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(xmax, self.yO, self.zO)
+        glVertex3f(self.xO, self.yO, self.zO)
+        glVertex3f(xmin, self.yO, self.zO)
+        glEnd()
+        if self.txt:
+            glColor4f(0, 0, 1, 1)  # x is blue
+
+            strs = [str(i) for i in x[::-1]]
+            strs[0] = ''
+            for i in range(len(x)):#sagittal
+                self.GLViewWidget.renderText(pos=[x[i], self.yO, self.zO - (zmax - zmin) / 10], text=strs[i],
+                                             size=[1, 1], rotation=[0, 0, 0])
+
+            glColor4f(0, 0, 0, 1)  # black
+            self.GLViewWidget.renderText(
+                pos=[self.xO + (xmax - xmin) / 2, self.yO - (ymax - ymin) / 20, self.zO - (zmax - zmin) / 20],
+                text='Sagittal',
+                size=[1, 1], rotation=[0, 0, 0])
+
+            glColor4f(1, 0, 0, 1)  # y is red
+            strs = [str(i) for i in y]
+            strs[0]=''
+            for i in range(len(y)):#coronal
+                self.GLViewWidget.renderText(pos=[self.xO, y[i], self.zO - (zmax - zmin) / 20], text=strs[i],
+                                             size=[1, 1], rotation=[0, 0, 0])
+
+            glColor4f(0, 0, 0, 1)  # black
+            self.GLViewWidget.renderText(pos=[self.xO - (xmax - xmin) / 30, self.yO + (ymax - ymin) / 2, self.zO],
+                                         text='Coronal',
+                                         size=[1, 1], rotation=[0, 0, 0])
+
+            glColor4f(1, 0, 1, 1)  # z is green
+            strs = [str(i) for i in z[::-1]]
+            strs[0] = ''
+            for i in range(len(z)):#axial
+                self.GLViewWidget.renderText(pos=[self.xO, self.yO - (ymax - ymin) / 20, z[i]], text=strs[i],
+                                             size=[1, 1], rotation=[0, 0, 0])
+
+            glColor4f(0, 0, 0, 1)  # black
+            self.GLViewWidget.renderText(
+                pos=[self.xO - (xmax - xmin) / 30, self.yO - (ymax - ymin) / 30, self.zO + (zmax - zmin) / 2], text='Axial',
+                size=[1, 1], rotation=[0, 0, 0])
+
+
+

melage/graphics/items/GLGridItem.py

@@ -0,0 +1,178 @@
+import numpy as np
+
+from OpenGL.GL import *
+from .. GLGraphicsItem import GLGraphicsItem
+import numpy as np
+
+from OpenGL.GL import *
+
+from PyQt5 import QtGui
+
+__AUTHOR__ = 'Bahram Jafrasteh'
+"""
+Inspiration from pyqtgraph https://github.com/pyqtgraph/pyqtgraph
+"""
+
+__all__ = ['GLGridItem']
+
+class GLGridItem(GLGraphicsItem):
+    """
+    """
+    
+    def __init__(self, size=None, color=(255, 255, 255, 76.5), antialias=True, glOptions='translucent'):
+        GLGraphicsItem.__init__(self)
+        self.setGLOptions(glOptions)
+        self.antialias = antialias
+        if size is None:
+            size = QtGui.QVector3D(20,20,1)
+        self.setSize(size=size)
+        self.setSpacing(1, 1, 1)
+        self.setColor(color)
+    
+    def setSize(self, x=None, y=None, z=None, size=None):
+        """
+        Set the size of the axes (in its local coordinate system; this does not affect the transform)
+        Arguments can be x,y,z or size=QVector3D().
+        """
+        if size is not None:
+            x = size.x()
+            y = size.y()
+            z = size.z()
+        self.__size = [x,y,z]
+        self.update()
+        
+    def size(self):
+        return self.__size[:]
+
+    def setSpacing(self, x=None, y=None, z=None, spacing=None):
+        """
+        Set the spacing between grid lines.
+        Arguments can be x,y,z or spacing=QVector3D().
+        """
+        if spacing is not None:
+            x = spacing.x()
+            y = spacing.y()
+            z = spacing.z()
+        self.__spacing = [x,y,z]
+        self.update() 
+        
+    def spacing(self):
+        return self.__spacing[:]
+        
+    def setColor(self, color):
+        """By Bahram Jafrasteh"""
+        self.color = color #fn.Color(color)
+        self.update()
+
+    def setGrid(self, xvals, yvals, zvals):
+        """
+        By Bahram Jafrasteh
+        :param xvals:
+        :param yvals:
+        :param zvals:
+        :return:
+        """
+        self.xvals = xvals
+        self.yvals = yvals
+        self.zvals = zvals
+
+
+    def xyGrid(self):
+        """
+        By Bahram jafrasteh
+        :return:
+        """
+        for x in self.xvals:
+            glColor4f(self.color[0], self.color[1], self.color[2],
+                      self.color[3])
+            glVertex3f(x, self.yvals[0], 0)
+            glVertex3f(x, self.yvals[-1], 0)
+            glColor4f(self.color[0], self.color[1], self.color[2],
+                      self.color[3])
+        for y in self.yvals:
+            glVertex3f(self.xvals[0], y, 0)
+            glVertex3f(self.xvals[-1], y, 0)
+        #############Additional
+        """
+        for x in self.xvals:
+            glColor4f(self.color[0], self.color[1], self.color[2],
+                      self.color[3])
+            glVertex3f(x, self.yvals[0], self.zvals[-1])
+            glVertex3f(x, self.yvals[-1], self.zvals[-1])
+            glColor4f(self.color[0], self.color[1], self.color[2],
+                      self.color[3])
+        for y in self.yvals:
+            glVertex3f(self.xvals[0], y, self.zvals[-1])
+            glVertex3f(self.xvals[-1], y, self.zvals[-1])
+
+        """
+
+    def xzGrid(self):
+        """
+        By Bahram jafrasteh
+        :return:
+        """
+        for x in self.xvals:
+            glVertex3f(x, 0, self.zvals[0])
+            glVertex3f(x, 0, self.zvals[-1])
+        for z in self.zvals:
+            glVertex3f(self.xvals[0], 0, z)
+            glVertex3f(self.xvals[-1], 0, z)
+
+        # Additional
+        """
+        for x in self.xvals:
+            glVertex3f(x, self.yvals[-1], self.zvals[0])
+            glVertex3f(x, self.yvals[-1], self.zvals[-1])
+        for z in self.zvals:
+            glVertex3f(self.xvals[0], self.yvals[-1], z)
+            glVertex3f(self.xvals[-1], self.yvals[-1], z)
+        """
+
+    def yzGrid(self):
+        """
+        By Bahram jafrasteh
+        :return:
+        """
+        for y in self.yvals:
+            glVertex3f(0, y, self.zvals[-1])
+            glVertex3f(0, y, self.zvals[0])
+
+        for z in self.zvals:
+            glVertex3f(0, self.yvals[0], z)
+            glVertex3f(0, self.yvals[-1], z)
+
+
+        ## Additional
+        """
+        
+        for y in self.yvals:
+            glVertex3f(self.xvals[-1], y, self.zvals[-1])
+            glVertex3f(self.xvals[-1], y, self.zvals[0])
+
+        for z in self.zvals:
+            glVertex3f(self.xvals[-1], self.yvals[0], z)
+            glVertex3f(self.xvals[-1], self.yvals[-1], z)
+        """
+
+    def color(self):
+        return self.__color
+
+    def paint(self):
+        self.setupGLState()
+        
+        if self.antialias:
+            glEnable(GL_LINE_SMOOTH)
+            glEnable(GL_BLEND)
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+            glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
+
+        glColor4f(self.color[0], self.color[1], self.color[2],
+                  self.color[3])
+        glBegin( GL_LINES )
+        
+        self.xyGrid()
+        self.xzGrid()
+        self.yzGrid()
+        
+        glEnd()

melage/graphics/items/GLPolygonItem.py

@@ -0,0 +1,77 @@
+from OpenGL.GL import *
+from ..GLGraphicsItem import GLGraphicsItem
+import numpy as np
+from PyQt5 import QtGui
+
+
+__AUTHOR__ = 'Bahram Jafrasteh'
+"""
+Inspiration from pyqtgraph https://github.com/pyqtgraph/pyqtgraph
+"""
+
+__all__ = ['GLPolygonItem']
+
+
+class GLPolygonItem(GLGraphicsItem):
+    """
+
+    """
+
+    def __init__(self, size=None, antialias=True, glOptions='translucent'):
+        GLGraphicsItem.__init__(self)
+        self.antialias = antialias
+        self.setGLOptions(glOptions)
+        self.colors = [[1,0,1],[0,1,1], [1, 0, 1],[1,0,0], [0,1,0], [0,0,1], [1,1,1],[1,1,0],
+        ]
+
+
+    def update_points(self, polys):
+        self.polys = polys
+
+    def paint(self):
+
+        # glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        # glEnable( GL_BLEND )
+        # glEnable( GL_ALPHA_TEST )
+        self.setupGLState()
+
+        if self.antialias:
+            glEnable(GL_LINE_SMOOTH)
+            glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
+
+        glDisable(GL_DEPTH_TEST)
+        glLineWidth(5)
+
+
+
+        #glLineStipple(1, 0xF00F)
+        glEnable(GL_LINE_STIPPLE)
+        glLineWidth(5.0)
+
+        glEnable(GL_LINE_SMOOTH)
+        glEnable(GL_BLEND)
+
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
+
+
+
+        r = 0
+        for key in self.polys.keys():
+            poly = self.polys[key]
+            if len(poly)<5:
+                continue
+            r = r + 1
+            if r > 7:
+                r = 0
+            color = self.colors[r]
+            glBegin(GL_LINE_STRIP)
+            glColor4f(color[0], color[1], color[2], 1)  # z is green
+            for (x, y, z) in poly:
+                glVertex3f(x, y, z)
+            glEnd()
+
+
+
+
+

melage/graphics/items/GLScatterPlotItem.py

@@ -0,0 +1,135 @@
+from OpenGL.GL import *
+from OpenGL.arrays import vbo
+from .. GLGraphicsItem import GLGraphicsItem
+from .. import shaders
+
+from PyQt5 import QtGui
+
+
+import numpy as np
+__AUTHOR__ = 'Bahram Jafrasteh'
+"""
+Inspiration from pyqtgraph https://github.com/pyqtgraph/pyqtgraph
+"""
+
+__all__ = ['GLScatterPlotItem']
+
+class GLScatterPlotItem(GLGraphicsItem):
+    """Draws points at a list of 3D positions."""
+    
+    def __init__(self, **kwds):
+        GLGraphicsItem.__init__(self)
+        glopts = kwds.pop('glOptions', 'translucent')
+        self.setGLOptions(glopts)
+        self.pos = []
+        self.size = 10
+        self.intensitySeg = 1
+        self.color = [1.0,1.0,1.0,1.0]
+        self.pxMode = True
+        #self.vbo = {}      ## VBO does not appear to improve performance very much.
+        self.setData(**kwds)
+        self.shader = None
+    
+    def setData(self, **kwds):
+        """
+        """
+        args = ['pos', 'color', 'size', 'pxMode']
+        for k in kwds.keys():
+            if k not in args:
+                raise Exception('Invalid keyword argument: %s (allowed arguments are %s)' % (k, str(args)))
+            
+        args.remove('pxMode')
+        for arg in args:
+            if arg in kwds:
+                setattr(self, arg, kwds[arg])
+                #self.vbo.pop(arg, None)
+                
+        self.pxMode = kwds.get('pxMode', self.pxMode)
+        self.update()
+
+    def initializeGL(self):
+        if self.shader is not None:
+            return
+        
+        ## Generate texture for rendering points
+        w = 1
+        def fn(x,y):
+            r = ((x-(w-1)/2.)**2 + (y-(w-1)/2.)**2) ** 0.5
+            return 255 * (w/2. - np.clip(r, w/2.-1.0, w/2.))
+        pData = np.empty((w, w, 4))
+        pData[:] = 255
+        pData[:,:,3] = np.fromfunction(fn, pData.shape[:2])
+        #print pData.shape, pData.min(), pData.max()
+        pData = pData.astype(np.ubyte)
+        
+        if getattr(self, "pointTexture", None) is None:
+            self.pointTexture = glGenTextures(1)
+        glActiveTexture(GL_TEXTURE0)
+        glEnable(GL_TEXTURE_2D)
+        glBindTexture(GL_TEXTURE_2D, self.pointTexture)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pData.shape[0], pData.shape[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, pData)
+        
+        self.shader = shaders.getShaderProgram('pointSprite')
+
+    def paint(self):
+
+        self.setupGLState()
+
+        glEnable(GL_POINT_SPRITE)
+
+        glActiveTexture(GL_TEXTURE0)
+        glEnable( GL_TEXTURE_2D )
+        glBindTexture(GL_TEXTURE_2D, self.pointTexture)
+    
+        glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)
+        #glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)    ## use texture color exactly
+        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE )  ## texture modulates current color
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+        glEnable(GL_PROGRAM_POINT_SIZE)
+        glPixelStorei(GL_PACK_ALIGNMENT, 1)
+        glPixelTransferf(GL_DEPTH_BIAS, 0.5)
+        with self.shader:
+            #glUniform1i(self.shader.uniform('texture'), 0)  ## inform the shader which texture to use
+            glEnableClientState(GL_VERTEX_ARRAY)
+            glEnable(GL_DEPTH_TEST)
+            try:
+                pos = self.pos
+                #if pos.ndim > 2:
+                    #pos = pos.reshape((-1, pos.shape[-1]))
+                glVertexPointerf(pos)
+            
+                if isinstance(self.color, np.ndarray):
+                    glEnableClientState(GL_COLOR_ARRAY)
+                    self.color[...,-1]=self.intensitySeg
+                    glColorPointerf(self.color)
+                else:
+                    if isinstance(self.color, QtGui.QColor):
+                        glColor4f(*fn.glColor(self.color))
+                    else:
+                        glColor4f(*self.color)
+                
+                if not self.pxMode or isinstance(self.size, np.ndarray):
+                    glEnableClientState(GL_NORMAL_ARRAY)
+                    norm = np.empty(pos.shape)
+                    if self.pxMode:
+                        norm[...,0] = self.size
+                    else:
+                        gpos = self.mapToView(pos.transpose()).transpose()
+                        pxSize = self.view().pixelSize(gpos)
+                        norm[...,0] = self.size / pxSize
+                    
+                    glNormalPointerf(norm)
+                else:
+                    glNormal3f(self.size, 0, 0)  ## vertex shader uses norm.x to determine point size
+                    #glPointSize(self.size)
+                glDrawArrays(GL_POINTS, 0, int(pos.size / pos.shape[-1]))
+            finally:
+                glDisableClientState(GL_NORMAL_ARRAY)
+                glDisableClientState(GL_VERTEX_ARRAY)
+                glDisableClientState(GL_COLOR_ARRAY)
+                #posVBO.unbind()
+                ##fixes #145
+                glDisable( GL_TEXTURE_2D )