python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/LMVis/layers/mesh.py

@@ -0,0 +1,378 @@
+from .base import BaseEngine, EngineLayer
+from PYME.LMVis.shader_programs.DefaultShaderProgram import DefaultShaderProgram
+from PYME.LMVis.shader_programs.WireFrameShaderProgram import WireFrameShaderProgram
+from PYME.LMVis.shader_programs.GouraudShaderProgram import GouraudShaderProgram, OITGouraudShaderProgram, PhongShaderProgram #, OITCompositorProgram,
+from PYME.LMVis.shader_programs.TesselShaderProgram import TesselShaderProgram
+
+from PYME.recipes.traits import CStr, Float, Enum, ListFloat, List, Bool
+# from pylab import cm
+from PYME.misc.colormaps import cm
+import numpy as np
+from PYME.contrib import dispatch
+
+from OpenGL.GL import *
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class WireframeEngine(BaseEngine):
+    _outlines = True
+    def __init__(self):
+        BaseEngine.__init__(self)
+        self.set_shader_program(WireFrameShaderProgram)
+
+
+    
+    def render(self, gl_canvas, layer):
+        core_profile = gl_canvas.core_profile
+
+        vertices = layer.get_vertices()
+        n_vertices = vertices.shape[0]
+
+        if n_vertices == 0:
+            logger.warning('Layer (%s) has no vertices to render' % layer)
+            return
+
+        normals = layer.get_normals()
+        colors = layer.get_colors()
+
+        with self.get_shader_program(gl_canvas) as sp:
+            sp.set_clipping(gl_canvas.view.clipping.squeeze(), gl_canvas.view.clip_plane_matrix)
+            
+            self._bind_data('mesh', vertices, normals, colors, sp, core_profile=core_profile)
+            
+            if core_profile:        
+                sp.set_modelviewprojectionmatrix(np.array(gl_canvas.mvp))
+                sp.set_modelviewmatrix(np.array(gl_canvas.mv))
+                sp.set_normalmatrix(np.array(gl_canvas.normal_matrix))
+                #glBindVertexArray(self._bound_data['mesh'][0])
+            
+
+            glDrawArrays(GL_TRIANGLES, 0, n_vertices)
+            
+            if self._outlines:
+                # TODO - move this to a shader uniform to avoid duplicating the data
+                sc = np.array([0.5, 0.5, 0.5, 1])
+
+                self._bind_data('outline', vertices, normals, sc*colors, sp, core_profile=core_profile)
+
+                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+                glDrawArrays(GL_TRIANGLES, 0, n_vertices)
+
+            if layer.display_normals:
+                # TODO - do this using a geometry shader???
+                normal_buffer = np.empty((vertices.shape[0]+normals.shape[0],3), dtype=vertices.dtype)
+                if layer.normal_mode == 'Per vertex':
+                    normal_buffer[0::2,:] = vertices
+                    normal_buffer[1::2,:] = vertices
+                else:
+                    vtemp = np.repeat((1./3)*(vertices[0::3]+vertices[1::3]+vertices[2::3]), 3, axis=0)
+                    normal_buffer[0::2,:] = vtemp
+                    normal_buffer[1::2,:] = vtemp
+                assert(np.allclose(np.linalg.norm(normals,axis=1),1))
+                normal_buffer[1::2,:] += layer.normal_scaling*normals
+                
+                sc = np.array([1, 1, 1, 1])
+                cols = (np.ones((normal_buffer.shape[0],4),dtype=colors.dtype)*sc[None,:])  # white normals
+                norms = (np.ones((normal_buffer.shape[0],3),dtype=normals.dtype))
+
+                self._bind_data('normals', normal_buffer, norms, cols, sp, core_profile=core_profile)
+                
+                glLineWidth(3)  # slightly thick
+                glDrawArrays(GL_LINES, 0, 2*n_vertices)
+
+
+
+class FlatFaceEngine(WireframeEngine):
+    def __init__(self):
+        BaseEngine.__init__(self)
+
+    def render(self, gl_canvas, layer):
+        self.set_shader_program(DefaultShaderProgram)
+        WireframeEngine.render(self, gl_canvas, layer)
+
+class ShadedFaceEngine(WireframeEngine):
+    _outlines = False
+    def __init__(self):
+        BaseEngine.__init__(self)
+
+    def render(self, gl_canvas, layer):
+        #self.set_shader_program(GouraudShaderProgram)
+        self.set_shader_program(PhongShaderProgram)
+        WireframeEngine.render(self, gl_canvas, layer)
+        
+class OITShadedFaceEngine(WireframeEngine):
+    _outlines = False
+    
+    def __init__(self):
+        BaseEngine.__init__(self)
+        
+    def use_oit(self, layer):
+        return layer.alpha < 0.99
+
+    def render(self, gl_canvas, layer):
+        if self.use_oit(layer):
+            self.set_shader_program(OITGouraudShaderProgram)
+        else:
+            self.set_shader_program(GouraudShaderProgram)
+        WireframeEngine.render(self, gl_canvas, layer)
+        
+    
+        
+class TesselEngine(WireframeEngine):
+    _outlines = False
+    def __init__(self):
+        BaseEngine.__init__(self)
+
+    def render(self, gl_canvas, layer):
+        self.set_shader_program(TesselShaderProgram)
+        WireframeEngine.render(self, gl_canvas, layer)
+
+
+ENGINES = {
+    'wireframe' : WireframeEngine,
+    'flat' : FlatFaceEngine,
+    'phong' : ShadedFaceEngine,
+    'tessel' : TesselEngine,
+    'shaded' : OITShadedFaceEngine,
+}
+
+
+class TriangleRenderLayer(EngineLayer):
+    """
+    Layer for viewing triangle meshes.
+    """
+    # properties to show in the GUI. Note that we also inherit 'visible' from BaseLayer
+    vertexColour = CStr('constant', desc='Name of variable used to colour our points')
+    cmap = Enum(*cm.cmapnames, default='gist_rainbow', desc='Name of colourmap used to colour faces')
+    clim = ListFloat([0, 1], desc='How our variable should be scaled prior to colour mapping')
+    alpha = Float(1.0, desc='Face tranparency')
+    method = Enum(*ENGINES.keys(), desc='Method used to display faces')
+    normal_mode = Enum(['Per vertex', 'Per face'])
+    display_normals = Bool(False)
+    normal_scaling = Float(10.0)
+    dsname = CStr('output', desc='Name of the datasource within the pipeline to use as a source of triangles (should be a TriangularMesh object)')
+    _datasource_choices = List()
+    _datasource_keys = List()
+
+    def __init__(self, pipeline, method='wireframe', dsname='', **kwargs):
+        EngineLayer.__init__(self, **kwargs)
+        self._pipeline = pipeline
+        self.engine = None
+        self.cmap = 'gist_rainbow'
+
+        self.x_key = 'x'  # TODO - make these traits?
+        self.y_key = 'y'
+        self.z_key = 'z'
+
+        self.xn_key = 'xn'
+        self.yn_key = 'yn'
+        self.zn_key = 'zn'
+
+        self._bbox = None
+
+        # define a signal so that people can be notified when we are updated (currently used to force a redraw when
+        # parameters change)
+        self.on_update = dispatch.Signal()
+
+        # define responses to changes in various traits
+        self.on_trait_change(self._update, 'vertexColour')
+        self.on_trait_change(lambda: self.on_update.send(self), 'visible')
+        self.on_trait_change(self.update, 'cmap, clim, alpha, dsname, normal_mode, display_normals, normal_scaling')
+        self.on_trait_change(self._set_method, 'method')
+
+        # update any of our traits which were passed as command line arguments
+        self.trait_set(**kwargs)
+
+        # update datasource and method
+        self.dsname = dsname
+        if self.method == method:
+            #make sure we still call _set_method even if we start with the default method
+            self._set_method()
+        else:
+            self.method = method
+
+        # if we were given a pipeline, connect ourselves to the onRebuild signal so that we can automatically update
+        # ourselves
+        if not self._pipeline is None:
+            try:
+                self._pipeline.onRebuild.connect(self.update)
+            except AttributeError:
+                pass
+
+    @property
+    def datasource(self):
+        """
+        Return the datasource we are connected to (does not go through the pipeline for triangles_mesh).
+        """
+        try:
+            return self._pipeline.get_layer_data(self.dsname)
+        except AttributeError:
+            try:
+                return self._pipeline[self.dsname]
+            except AttributeError:
+                return None
+        #return self.datasource
+    
+    @property
+    def _ds_class(self):
+        # from PYME.experimental import triangle_mesh
+        from PYME.experimental import _triangle_mesh as triangle_mesh
+        return triangle_mesh.TrianglesBase
+
+    def _set_method(self):
+        self.engine = ENGINES[self.method]()
+        self.update()
+
+    def _get_cdata(self):
+        try:
+            cdata = self.datasource[self.vertexColour]
+            cdata = cdata[self.datasource._vertices['halfedge']!= -1]
+        except (KeyError, TypeError):
+            cdata = np.array([0, 1])
+
+        return cdata
+
+    def _update(self, *args, **kwargs):
+        #pass
+        cdata = self._get_cdata()
+        self.clim = [float(np.nanmin(cdata)), float(np.nanmax(cdata))]
+        self.update(*args, **kwargs)
+
+    def update(self, *args, **kwargs):
+        try:
+            self._datasource_choices = [k for k, v in self._pipeline.dataSources.items() if isinstance(v, self._ds_class)]
+        except AttributeError:
+            pass
+        
+        if not self.datasource is None:
+            dks = ['constant',]
+            if hasattr(self.datasource, 'keys'):
+                 dks = dks + sorted(self.datasource.keys())
+            self._datasource_keys = dks
+        
+        if not (self.engine is None or self.datasource is None):
+            print('mesh_layer update')
+            self.update_from_datasource(self.datasource)
+            self.on_update.send(self)
+
+    @property
+    def bbox(self):
+        return self._bbox
+
+    def update_from_datasource(self, ds):
+        """
+        Pulls vertices/normals from a binary STL file. See PYME.IO.FileUtils.stl for more info. Calls update_data on the input.
+
+        Parameters
+        ----------
+        ds :
+            PYME.experimental.triangular_mesh.TriangularMesh object
+
+        Returns
+        -------
+        None
+        """
+        #t = ds.vertices[ds.faces]
+        #n = ds.vertex_normals[ds.faces]
+        
+        x, y, z = ds.vertices[ds.faces].reshape(-1, 3).T
+        
+        if self.normal_mode == 'Per vertex':
+            xn, yn, zn = ds.vertex_normals[ds.faces].reshape(-1, 3).T
+        else:
+            xn, yn, zn = np.repeat(ds.face_normals.T, 3, axis=1)
+            
+        if self.vertexColour in ['', 'constant']:
+            c = np.ones(len(x))
+            clim = [0, 1]
+        #elif self.vertexColour == 'vertex_index':
+        #    c = np.arange(0, len(x))
+        else:
+            c = ds[self.vertexColour][ds.faces].ravel()
+            clim = self.clim
+
+        cmap = cm[self.cmap]
+        alpha = float(self.alpha)
+
+        # Do we have coordinates? Concatenate into vertices.
+        if x is not None and y is not None and z is not None:
+            vertices = np.vstack((x.ravel(), y.ravel(), z.ravel()))
+            self._vertices = vertices.T.ravel().reshape(len(x.ravel()), 3)
+
+            if not xn is None:
+                self._normals = np.vstack((xn.ravel(), yn.ravel(), zn.ravel())).T.ravel().reshape(len(x.ravel()), 3)
+            else:
+                self._normals = -0.69 * np.ones(self._vertices.shape)
+
+            self._bbox = np.array([x.min(), y.min(), z.min(), x.max(), y.max(), z.max()])
+        else:
+            self._bbox = None
+
+        # TODO: This temporarily sets all triangles to the color red. User should be able to select color.
+        if c is None:
+            c = np.ones(self._vertices.shape[0]) * 255  # vector of pink
+            
+        
+
+        if clim is not None and c is not None and cmap is not None:
+            cs_ = ((c - clim[0]) / (clim[1] - clim[0]))
+            cs = cmap(cs_)
+
+            if self.method in ['flat', 'tessel']:
+                alpha = cs_ * alpha
+            
+            cs[:, 3] = alpha
+            
+            if self.method == 'tessel':
+                cs = np.power(cs, 0.333)
+
+            self._colors = cs.ravel().reshape(len(c), 4)
+        else:
+            # cs = None
+            if not self._vertices is None:
+                self._colors = np.ones((self._vertices.shape[0], 4), 'f')
+            
+        self._alpha = alpha
+        self._color_map = cmap
+        self._color_limit = clim
+
+
+    def get_vertices(self):
+        return self._vertices
+
+    def get_normals(self):
+        return self._normals
+
+    def get_colors(self):
+        return self._colors
+
+    def get_color_map(self):
+        return self._color_map
+
+    @property
+    def colour_map(self):
+        return self._color_map
+
+    def get_color_limit(self):
+        return self._color_limit
+
+    @property
+    def default_view(self):
+        from traitsui.api import View, Item, Group, InstanceEditor, EnumEditor
+        from PYME.ui.custom_traits_editors import HistLimitsEditor, CBEditor
+
+        return View([Group([Item('dsname', label='Data', editor=EnumEditor(name='_datasource_choices'), visible_when='_datasource_choices')]),
+                     Item('method'),
+                     Item('normal_mode', visible_when='method=="shaded"'),
+                     Item('vertexColour', editor=EnumEditor(name='_datasource_keys'), label='Colour'),
+                     Group([Item('clim', editor=HistLimitsEditor(data=self._get_cdata), show_label=False), ], visible_when='vertexColour != "constant"'),
+                     Group([Item('cmap', label='LUT'),
+                            Item('alpha', visible_when='method in ["flat", "tessel", "shaded"]')
+                            ])
+                     ], )
+        # buttons=['OK', 'Cancel'])
+
+    def default_traits_view(self):
+        return self.default_view

PYME/LMVis/layers/octree.py

@@ -0,0 +1,194 @@
+from .base import EngineLayer
+from .mesh import TriangleRenderLayer  #, ENGINES
+
+from PYME.experimental._octree import Octree
+
+from PYME.recipes.traits import CStr, Float, Enum, ListFloat, List, Int
+# from pylab import cm
+from PYME.misc.colormaps import cm
+import numpy as np
+
+
+from OpenGL.GL import *
+
+
+# OCT_SHIFT is just _octant_sign from _octree
+OCT_SHIFT = np.zeros((8,3))
+for n in range(8):
+    OCT_SHIFT[n,0] = 2*(n&1) - 1
+    OCT_SHIFT[n,1] = (n&2) -1
+    OCT_SHIFT[n,2] = (n&4)/2.0 -1
+
+class OctreeRenderLayer(TriangleRenderLayer):
+    """
+    Layer for viewing octrees. Takes in an octree, splits the faces into triangles, and then uses the rendering engines
+    from PYME.LMVis.layers.triangle_mesh.
+    """
+    # Additional properties (the rest are inherited from TriangleRenderLayer)
+    depth = Int(3, desc='Depth at which to render Octree. Set to -1 for dynamic depth rendering.')
+    density = Float(0.0, desc='Minimum density of octree node to display.')
+    min_points = Int(10, desc='Number of points/node to truncate octree at')
+
+    def __init__(self, pipeline, method='wireframe', dsname='', **kwargs):
+        TriangleRenderLayer.__init__(self, pipeline, method, dsname, **kwargs)
+
+        self.on_trait_change(self.update, 'depth')
+        self.on_trait_change(self.update, 'density')
+        self.on_trait_change(self.update, 'min_points')
+        
+    @property
+    def _ds_class(self):
+        from PYME.experimental import octree
+        return (octree.Octree, octree.PyOctree)
+
+    def update_from_datasource(self, ds):
+        """
+        Opens an octree. Subdivides the faces into triangles. Feeds the triangle points/normals to update_data.
+
+        Parameters
+        ----------
+        ds :
+            Octree (see PYME.experimental.octree)
+
+        Returns
+        -------
+        None
+        """
+        nodes = ds._nodes[ds._nodes[ds._nodes['parent']]['nPoints'] >= float(self.min_points)]
+        
+        if self.depth > 0:
+            # Grab the nodes at the specified depth
+            nodes = nodes[nodes['depth'] == self.depth]
+            box_sizes = np.ones((nodes.shape[0], 3))*ds.box_size(self.depth)
+            node_density = 1.*nodes['nPoints']/np.prod(box_sizes,axis=1)
+            nodes = nodes[node_density >= self.density]
+            box_sizes = np.ones((nodes.shape[0], 3))*ds.box_size(self.depth)
+            alpha = nodes['nPoints']/box_sizes[:,0]
+        elif self.depth == 0:
+            # plot all bins
+            nodes = nodes[nodes['nPoints'] >= 1]
+            box_sizes = np.vstack(ds.box_size(nodes['depth'])).T
+
+            alpha = nodes['nPoints'] * ((2 ** nodes['depth'])**3)
+        else:
+            # Plot leaf nodes
+            nodes = nodes[(np.sum(nodes['children'],axis=1) == 0)&(nodes['depth'] > 0)]
+            box_sizes = np.vstack(ds.box_size(nodes['depth'])).T
+            
+            alpha = nodes['nPoints']*((2.0**nodes['depth']))**3
+
+        if len(nodes) > 0:
+            c = nodes['centre']  # center
+            shifts = (box_sizes[:,None]*OCT_SHIFT[None,:])*0.5
+            v = (c[:,None,:] + shifts)
+
+            #
+            #     z
+            #     ^
+            #     |
+            #    v4 ----------v6
+            #    /|           /|
+            #   / |          / |
+            #  v5----------v7  |
+            #  |  |    c    |  |
+            #  | v0---------|-v2
+            #  | /          | /
+            #  v1-----------v3---> y
+            #  /
+            # x
+            #
+            # Now note that the counterclockwise triangles (when viewed straight-on) formed along the faces of the cube are:
+            #
+            # v0 v2 v1
+            # v0 v1 v5
+            # v0 v5 v4
+            # v0 v6 v2
+            # v0 v4 v6
+            # v1 v2 v3
+            # v1 v3 v7
+            # v1 v7 v5
+            # v2 v6 v7
+            # v2 v7 v3
+            # v4 v5 v6
+            # v5 v7 v6
+
+            # Counterclockwise triangles (when viewed straight-on) formed along
+            # the faces of an octree box
+            t0 = np.vstack(v[:,[0,0,0,0,0,1,1,1,2,2,4,5],:])
+            t1 = np.vstack(v[:,[2,1,5,6,4,2,3,7,6,7,5,7],:])
+            t2 = np.vstack(v[:,[1,5,4,2,6,3,7,5,7,3,6,6],:])
+
+            x, y, z = np.hstack([t0,t1,t2]).reshape(-1, 3).T  # positions
+
+            # Now we create the normal as the cross product
+            tn = np.cross((t2-t1),(t0-t1))
+
+            # We copy the normals 3 times per triangle to get 3x(3N) normals to match the vertices shape
+            xn, yn, zn = np.repeat(tn.T, 3, axis=1)  # normals
+
+            # Color is fixed constnat for octree
+            c = np.ones(len(x))
+            clim = [0, 1]
+            
+            alpha = self.alpha*alpha/alpha.max()
+            alpha = (alpha[None,:]*np.ones(12)[:,None])
+            alpha = np.repeat(alpha.ravel(), 3)
+            print('Octree scaled alpha range: %g, %g' % (alpha.min(), alpha.max()))
+
+            cmap = cm[self.cmap]
+
+            # Do we have coordinates? Concatenate into vertices.
+            if x is not None and y is not None and z is not None:
+                vertices = np.vstack((x.ravel(), y.ravel(), z.ravel()))
+                self._vertices = vertices.T.ravel().reshape(len(x.ravel()), 3)
+
+                if not xn is None:
+                    self._normals = np.vstack((xn.ravel(), yn.ravel(), zn.ravel())).T.ravel().reshape(len(x.ravel()), 3)
+                else:
+                    self._normals = -0.69 * np.ones(self._vertices.shape)
+
+                self._bbox = np.array([x.min(), y.min(), z.min(), x.max(), y.max(), z.max()])
+            else:
+                self._bbox = None
+
+            if clim is not None and c is not None and cmap is not None:
+                cs_ = ((c - clim[0]) / (clim[1] - clim[0]))
+                cs = cmap(cs_)
+
+                if self.method in ['flat', 'tessel']:
+                    alpha = cs_ * alpha
+                
+                cs[:, 3] = alpha
+                
+                if self.method == 'tessel':
+                    cs = np.power(cs, 0.333)
+
+                self._colors = cs.ravel().reshape(len(c), 4)
+            else:
+                # cs = None
+                if not self._vertices is None:
+                    self._colors = np.ones((self._vertices.shape[0], 4), 'f')
+
+            print('Colors: {}'.format(self._colors))
+                
+            self._alpha = alpha
+            self._color_map = cmap
+            self._color_limit = clim
+        else:
+            print('No nodes for density {0}, depth {1}'.format(self.density, self.depth))
+        
+
+    @property
+    def default_view(self):
+        from traitsui.api import View, Item, Group, InstanceEditor, EnumEditor
+        from PYME.ui.custom_traits_editors import HistLimitsEditor, CBEditor
+
+        return View([#Group([
+                     Item('dsname', label='Data', editor=EnumEditor(name='_datasource_choices')),
+                     Item('method'),
+                     Item('depth'),Item('min_points'),
+                     #Item('vertexColour', editor=EnumEditor(name='_datasource_keys'), label='Colour'),
+                     #Group([Item('clim', editor=HistLimitsEditor(data=self._get_cdata), show_label=False), ]),
+                     Group([Item('cmap', label='LUT'), Item('alpha')])], )
+        # buttons=['OK', 'Cancel'])
+