python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/experimental/music.py

@@ -0,0 +1,25 @@
+import numpy as np
+from scipy import ndimage
+
+def remove_fixed_pattern(data, axis=1, eps=0.1):
+    """
+    Estimate and remove fixed pattern gain from a 2D image
+
+    Algorithm operates by finding the scaling factor for each row/column
+    that makes the data in each pixel as close as possible to the
+    mean of the neighbouring pixels.
+    """
+
+    #neighbour_mean = ndimage.convolve1d(data, [0.5, 0, 0.5], axis=(1-axis))
+    
+    neighbour_mean = ndimage.gaussian_filter1d(data, 1, axis=(1-axis))
+    
+    scaling = neighbour_mean/(data + eps) 
+    # take weighted average of scaling factor for each columm/row
+    scaling = (data*scaling).sum(axis=axis)/(data.sum(axis=axis) + eps)
+
+    if axis == 1:
+        return data*scaling[:, np.newaxis]
+    else:
+        return data*scaling[np.newaxis, :]
+    

PYME/experimental/octree.py

@@ -0,0 +1,188 @@
+import numpy as np
+from . _octree import Octree
+
+INITIAL_NODES = 1000
+NODE_DTYPE = [('depth', 'i4'), ('children', '8i4'),('parent', 'i4'), ('nPoints', 'i4'), ('centre', '3f4'), ('centroid', '3f4')]
+NODE_DTYPE2 = [('depth', 'i4'),
+               ('child0', 'i4'),
+               ('child1', 'i4'),
+               ('child2', 'i4'),
+               ('child3', 'i4'),
+               ('child4', 'i4'),
+               ('child5', 'i4'),
+               ('child6', 'i4'),
+               ('child7', 'i4'),
+               ('parent', 'i4'),
+               ('nPoints', 'i4'),
+               ('centre_x', 'f4'),
+               ('centre_y', 'f4'),
+               ('centre_z', 'f4'),
+               ('centroid_x', 'f4'),
+               ('centroid_y', 'f4'),
+               ('centroid_z', 'f4')]
+
+class PyOctree(object):
+    '''Implement octree as a linked list inside a numpy array, with resizing (as done for vector types in C++ std lib)'''
+    def __init__(self, bounds):
+        bounds = np.array(bounds, 'f4')
+        self._bounds = bounds
+        
+        self._xwidth = bounds[1] - bounds[0]
+        self._ywidth = bounds[3] - bounds[2]
+        self._zwidth = bounds[5] - bounds[4]
+        
+        self._size= np.array([self._xwidth, self._ywidth, self._zwidth], 'f4')
+        
+        self._nodes = np.zeros(INITIAL_NODES, NODE_DTYPE)
+        
+        self._nodes[0]['centre'][:] = [(bounds[1] + bounds[0])/2.0, (bounds[3] + bounds[2])/2.0, (bounds[5] + bounds[4])/2.0]
+        
+        self._flat_nodes = self._nodes.view(NODE_DTYPE2)
+        
+        self._next_node = 1
+        self._resize_limit = INITIAL_NODES - 1
+        
+        self._octant_offsets = np.array([1, 2, 4])
+        
+        self._octant_sign = np.array([[2*(n&1) - 1, (n&2) -1, (n&4)/2 -1] for n in range(8)])
+        
+    def __search(self, pos):
+        node_idx, child_idx, subdivide =  _oct_helpers._search(self._flat_nodes, pos)
+        return node_idx, self._nodes[node_idx], child_idx, subdivide
+    
+    def _search(self, pos):
+        node_idx = 0
+        node = self._nodes[node_idx]
+        #visited = [node_idx,]
+        child_idx = ((pos > node['centre'])*self._octant_offsets).sum()
+        while node['nPoints'] > 1:
+            new_idx = node['children'][child_idx]
+            if new_idx == 0:
+                #node subdivided but child is not yet allocated, no need to subdivide
+                return node_idx, node, child_idx, False
+            else:
+                node_idx = new_idx
+            
+            node = self._nodes[node_idx]
+            child_idx = ((pos > node['centre']) * self._octant_offsets).sum()
+            #visited.append(node_idx)
+            
+        if node_idx == 0:
+            #node subdivided but child is not yet allocated, no need to subdivide
+            return node_idx, node, child_idx, False
+            
+        #node has not been subdivided
+        return node_idx, node, child_idx, True
+                 
+        
+         
+    
+    def _resize_nodes(self):
+        old_nodes = self._nodes
+        new_size = old_nodes.shape[0]*2 #double whenever we grow (TODO - what is the best growth factor)
+        
+        #allocate new memory
+        self._nodes = np.zeros(new_size, NODE_DTYPE)
+        self._flat_nodes = self._nodes.view(NODE_DTYPE2)
+        
+        #copy data over TODO - use a direct call to memcpy instead?
+        self._nodes[:self._next_node] = old_nodes[:self._next_node]
+        self._resize_limit = new_size - 1
+
+    def __add_node(self, pos, parent_idx, child_idx):
+        if self._next_node >= self._resize_limit:
+            self._resize_nodes()
+    
+        new_idx = self._next_node
+        self._next_node += 1
+        
+        new_idx =  _oct_helpers._add_node(self._flat_nodes, new_idx, pos, parent_idx, child_idx, self._size)
+        
+        return new_idx, self._nodes[new_idx]
+    
+    def _add_node(self, pos, parent_idx, child_idx):
+        if self._next_node >= self._resize_limit:
+            self._resize_nodes()
+            
+        parent = self._nodes[parent_idx]
+        new_idx = self._next_node
+        self._next_node += 1
+        
+        delta = self._size/(2**(parent['depth'] + 2))
+        
+        new_node = self._nodes[new_idx]
+        
+        new_node['nPoints'] = 1
+        new_node['centre'] = parent['centre'] + self._octant_sign[child_idx]*delta
+        new_node['centroid'] = pos
+        new_node['depth'] = parent['depth'] + 1
+        new_node['parent'] = parent_idx
+        
+        if not parent['children'][child_idx] == 0:
+            raise RuntimeError('Child already allocated: parent_idx=%d, child_idx=%d, pos = %s' % (parent_idx, child_idx, pos))
+        parent['children'][child_idx] = new_idx
+        
+        return new_idx, new_node
+
+    def add_point(self, pos):
+        #find the node we need to subdivide
+        node_idx, node, child_idx, subdivide = self._search(pos)
+    
+        if not subdivide:
+            #add a new node
+            #print 'adding without subdivision'
+            self._add_node(pos, node_idx, child_idx)
+        else:
+            #print 'adding with subdivision: ',  node_idx, child_idx
+            #we need to move the current node data into a child
+            node_child_idx = ((node['centroid'] > node['centre']) * self._octant_offsets).sum()
+            new_idx, new_node = self._add_node(node['centroid'], node_idx, node_child_idx)
+            while node_child_idx == child_idx:
+                node = new_node
+                node_idx = new_idx
+                #visited.append(new_idx)
+                child_idx = ((pos > node['centre']) * self._octant_offsets).sum()
+            
+                node_child_idx = ((node['centroid'] > node['centre']) * self._octant_offsets).sum()
+                new_idx, new_node = self._add_node(node['centroid'], node_idx, node_child_idx)
+            
+            self._add_node(pos, node_idx, child_idx)
+
+        self._nodes[node_idx]['nPoints'] += 1
+        while node_idx > 0:
+            #print node_idx
+            node_idx = self._nodes[node_idx]['parent']
+            #print node_idx, self._nodes[node_idx]['depth']
+            self._nodes[node_idx]['nPoints'] += 1
+            #TODO - update centroids
+            
+    def add_points(self, pts):
+        for pt in pts:
+            self.add_point(pt)
+
+
+def gen_octree_from_points(table, min_pixel_size=5, max_depth=20, samples_per_node=1):
+    pts = np.vstack([table['x'], table['y'], table['z']]).T.astype('f4')
+    
+    r_min = pts.min(axis=0) - 250
+    r_max = pts.max(axis=0) + 250
+    
+    print(f'rmin:{r_min}, r_max:{r_max}')
+    
+    bbox_size = (r_max - r_min).max()
+    
+    bb_max = r_min + 1.1* bbox_size
+    
+    r_min = r_min - 0.1*bbox_size
+    
+    max_depth = min(max_depth, np.log2(bbox_size / min_pixel_size) + 1)
+    
+    ot = Octree([r_min[0], bb_max[0], r_min[1], bb_max[1], r_min[2], bb_max[2]], maxdepth=max_depth, samples_per_node=samples_per_node)
+    ot.add_points(pts)
+    
+    return ot
+        
+        
+            
+    
+        

PYME/experimental/pSpaceMap.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python
+
+###############
+# pSpaceMap.py
+#
+# Copyright David Baddeley, 2012
+# d.baddeley@auckland.ac.nz
+#
+# 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/>.
+#
+################
+xvs = 70*arange(-2.01, 2,.1)
+yvs = 70*arange(-2.01, 2,.1)
+zvs = arange(-500, 500, 100)
+
+PsfFitCSIR.setModel(seriesName, None)
+
+misf = zeros([len(xvs), len(yvs), len(zvs)])
+m0 = PsfFitCSIR.f_Interp3d([1,0,0,-300,0], X, Y, Z)
+for i in range(len(xvs)):
+    for j in range(len(yvs)):
+        for k in range(len(zvs)):
+            misf[i,j, k] = ((m0 -PsfFitCSIR.f_Interp3d([1,xvs[i],yvs[j],zvs[k],0], X, Y, Z))**2).sum()

PYME/experimental/pointFitConfoc.py

@@ -0,0 +1,112 @@
+#!/usr/bin/python
+
+##################
+# pointFitConfoc.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# 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/>.
+#
+##################
+
+#!/usr/bin/python
+"""Script to find and measure small objects in a 3D confocal data set. Call as follows: pointFitConfoc.py inFile threshold outFile"""
+from PYME.IO.FileUtils import readTiff
+from PYME.Analysis import MetaData
+from PYME.localization.ofind3d import ObjectIdentifier
+from PYME.localization.FitFactories.Gauss3DFitR import FitFactory
+
+import os
+import sys
+from numpy import sqrt
+
+#set up parameters
+md = MetaData.ConfocDefault
+
+#Voxel sizes - alter as appropriate, in um
+md['voxelsize.x'] = 0.09
+md['voxelsize.y'] = 0.09
+md['voxelsize.z'] = 0.20
+
+#Hack the 'ccd' so we don't have to worry about the ADOffset preventing
+#fits from working. FIXME: find sensible values for all parameter for confocal
+#imaging so we can get error estimates.
+md['Camera.ADOffset']=0
+
+
+#set this to the measured PSF FWHM. The correct way measure the PSF 
+#is to put the nominal bead FWHM (bead diameter/sqrt(2)) in here and analyse 
+#the beads. The median 'corrected' FWHM is then that of the microscope PSF.
+scopeFWHM = 250 #in nm
+
+
+#'default' threshold value for object identification- you probably want to 
+#enter this on the command line instead
+ofindThreshold = 100
+
+md['tIndex']=0
+
+####################################
+#End of user-modifiable parameters #
+####################################
+
+
+if __name__ == '__main__':
+
+    if len(sys.argv) >= 2: #we were passed a filename
+        filename = sys.argv[1]
+    else:# we'll have to create a GUI and ask
+        import wx
+        app = wx.App()
+        filename = wx.FileSelector('Choose an image file', default_extension='.tif')
+
+    if len(sys.argv) >=3: #we've got a threshold
+        ofindThreshold = float(sys.argv[2])
+
+    
+    if len(sys.argv) >=4: #we've got a name for the output file
+        outFilename = sys.argv[3]
+    else: #build an output filename from input
+        outFilename = filename.split('.')[0] + '.txt'
+
+    if os.path.exists(outFilename): #don't overwrite an existing file
+        raise "Output file '%s' already exists" % outFilename
+        
+    
+    #read data
+    ima = readTiff.read3DTiff(filename)
+
+    #create an object identifier
+    ofd = ObjectIdentifier(ima)
+    #and identify objects ...
+    ofd.FindObjects(ofindThreshold)
+
+
+    #create a fit factory
+    ff = FitFactory(ima, md)
+
+    #iterate over found objects, fitting at each point
+    res = [ff.FromPoint(p.x, p.y, p.z) for p in ofd]
+
+    of = open(outFilename, 'w')
+
+    of.write('ID\tx\ty\tA\tsigma\tcorrectedFWHM\n')
+
+    for r, i in zip(res, range(len(res))):
+        of.write('%d\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.0f\n' % (i, r['fitResults']['x0']/1e3, r['fitResults']['y0']/1e3, r['fitResults']['A'], r['fitResults']['sigma'], sqrt((2.35*r['fitResults']['sigma'])**2 - scopeFWHM**2)))
+
+    of.close()
+    
+    

PYME/experimental/scanner_control.py

@@ -0,0 +1,107 @@
+'''
+Drive a galvo scanner from a raspberry pi and expose a web interface
+'''
+
+import logging
+import sys
+
+import numpy as np
+import pygame
+from PYME.util import webframework
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+class ScannerController(object):
+    def __init__(self, scan_frequency=100, scan_amplitude=1.0):
+        self._scan_frequency = scan_frequency
+        self._scan_amplitude = scan_amplitude
+        
+        self._sound = None
+        
+        self._fullscale = 2**15
+        
+        pygame.mixer.pre_init(44100, size=-16, channels=1)
+        pygame.init()
+        
+    @webframework.register_endpoint('/start_scanning')
+    def start_scanning(self, frequency=None, amplitude=None, waveform='sine'):
+        if not self._sound is None:
+            self._sound.stop()
+            self._sound = None
+            
+        if frequency is None:
+            frequency = self._scan_frequency
+        else:
+            frequency = float(frequency)
+        
+        if amplitude is None:
+            amplitude = self._scan_amplitude
+        else:
+            amplitude = float(amplitude)
+            
+        
+        num_samples_per_period = (44100.0/frequency)
+        
+        #take at least 2 periods
+        num_periods = max(np.ceil(frequency), 2.0)
+        
+        t = np.linspace(0, num_periods/frequency, int(num_periods*num_samples_per_period))
+        
+        if waveform == 'sine':
+            y = amplitude*self._fullscale*np.sin(2*np.pi*frequency*t)
+        elif waveform == 'tri':
+            t1 = (frequency*t)%2
+            y = 2*(t1 - 2*(t1>1)*(t1-1)) - 1
+            y = amplitude*self._fullscale*y
+        else:
+            raise RuntimeError('waveform %s not supported' % waveform)
+        
+        
+        if pygame.mixer.get_init()[2]  == 2:
+            #hack for when we can't get a mono mixer
+            print(y.shape)
+            y = np.tile(y.astype('int16')[:,None], (1,2))
+            print(y.shape)
+            self._sound = pygame.sndarray.make_sound(y)
+        else:
+            self._sound = pygame.sndarray.make_sound(y.astype('int16'))
+        self._sound.play(-1)
+        
+        return ''
+
+    @webframework.register_endpoint('/stop_scanning')
+    def stop_scanning(self):
+        if not self._sound is None:
+            self._sound.stop()
+            self._sound = None
+            
+        return ''
+        
+    
+    
+class ScanServer(webframework.APIHTTPServer, ScannerController):
+    def __init__(self, port):
+        ScannerController.__init__(self)
+        
+        server_address = ('', port)
+        webframework.APIHTTPServer.__init__(self, server_address)
+        self.daemon_threads = True
+
+def run(port):
+    import socket
+    
+    externalAddr = socket.gethostbyname(socket.gethostname())
+    server = ScanServer(port=port)
+    
+    try:
+        logger.info('Starting nodeserver on %s:%d' % (externalAddr, port))
+        server.serve_forever()
+    finally:
+        logger.info('Shutting down ...')
+        server.shutdown()
+        server.server_close()
+
+if __name__ == '__main__':
+    port = sys.argv[1]
+    run(int(port))

PYME/experimental/setup.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python
+
+##################
+# setup.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# 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/>.
+#
+##################
+
+#!/usr/bin/env python
+
+import sys
+import os
+
+if sys.platform == 'darwin':#MacOS
+    linkArgs = ['-headerpad_max_install_names']
+else:
+    linkArgs = ['-static-libgcc']
+    
+    
+#windows VC++ has really shocking c standard support so we need to include
+#custom stdint.h and intypes.h files from https://code.google.com/archive/p/msinttypes
+#print os.environ.get('CC', 'foo')
+if sys.platform == 'win32' and not os.environ.get('CC', '') == 'mingw':
+    extra_include_dirs = ['win_incl']
+else:
+    extra_include_dirs = []
+
+from Cython.Build import cythonize
+
+def configuration(parent_package='', top_path=None):
+
+    from numpy.distutils.core import Extension
+    from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
+    
+    cur_dir = os.path.dirname(__file__)
+    
+    ext = Extension(name='.'.join([parent_package, 'experimental', '_octree']),
+                    sources=[os.path.join(cur_dir, '_octree.pyx')],
+                    include_dirs= get_numpy_include_dirs() + extra_include_dirs,
+                    extra_compile_args=['-O3', '-fno-exceptions', '-ffast-math'],# '-march=native', '-mtune=native'],
+                    extra_link_args=linkArgs)
+
+    ext2 = Extension(name='.'.join([parent_package, 'experimental', '_treap']),
+                    sources=[os.path.join(cur_dir, '_treap.pyx')],
+                    include_dirs= get_numpy_include_dirs() + extra_include_dirs,
+                    extra_compile_args=['-O3', '-fno-exceptions', '-ffast-math'],# '-march=native', '-mtune=native'],
+                    extra_link_args=linkArgs)
+
+    ext3 = Extension(name='.'.join([parent_package, 'experimental', '_triangle_mesh']),
+                    sources=[os.path.join(cur_dir, '_triangle_mesh.pyx')],
+                    include_dirs= get_numpy_include_dirs() + extra_include_dirs,
+                    extra_compile_args=['-O3', '-fno-exceptions', '-ffast-math'],# '-march=native', '-mtune=native'],
+                    extra_link_args=linkArgs)
+
+    ext4 = Extension(name='.'.join([parent_package, 'experimental', 'func_octree']),
+                    sources=[os.path.join(cur_dir, 'func_octree.pyx')],
+                    include_dirs= get_numpy_include_dirs() + extra_include_dirs,
+                    extra_compile_args=['-O3', '-fno-exceptions', '-ffast-math'],# '-march=native', '-mtune=native'],
+                    extra_link_args=linkArgs)
+    
+    config = Configuration('experimental', parent_package, top_path, ext_modules=cythonize([ext, ext2, ext3, ext4]))
+
+    config.add_extension(name='triangle_mesh_utils',
+                    sources='triangle_mesh_utils.c',
+                    include_dirs= get_numpy_include_dirs() + extra_include_dirs,
+                    extra_compile_args=['-O3', '-fno-exceptions', '-ffast-math'],# '-march=native', '-mtune=native'],
+                    extra_link_args=linkArgs)
+
+    config.add_data_files('*.pxd', '*.pyx', '*.h', '*.c') #permit compilation against cython extension
+    
+    # config = Configuration('pymecompress', parent_package, top_path)
+    #
+    # config.add_extension('bcl',
+    #     sources=['bcl.pyx', 'src/huffman.c', 'quantize.c'],
+    #     include_dirs = ['src', get_numpy_include_dirs()] + extra_include_dirs,
+    # extra_compile_args = ['-O3', '-fno-exceptions', '-ffast-math', '-march=native', '-mtune=native'],
+    #     extra_link_args=linkArgs)
+    
+    return config
+
+
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    
+    setup(description='various experimental functions',
+          author='David Baddeley',
+          author_email='david.baddeley@yale.edu',
+          url='',
+          long_description="""
+""",
+          license="GPL",
+          #cmdclass={'build_ext': build_ext},
+          **configuration(top_path='').todict()
+          )

PYME/experimental/spark.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python
+
+##################
+# spark.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# 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 scipy import *
+
+def sparkMod(p, X,T):
+    maxP, Td, Tr, x0, t0, sig0, b = p
+
+    f = ((T - t0) > 0)*maxP*exp(-(T-t0)/Td)*(1 - exp(-(T-t0)/Tr))*exp(-((X-x0)**2)/(2*(sig0*(1 + (((T - t0) > 0)*(T - t0))**.25)**2)))+ b
+
+    return f

PYME/experimental/tcHist.py

@@ -0,0 +1,71 @@
+#!/usr/bin/python
+
+##################
+# tcHist.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# 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 pylab import *
+
+import numpy as np
+# import pylab
+import matplotlib.cm
+
+
+def doTCHist(xvals, yvals, xbins, ybins, sat=1):
+    h = np.histogram2d(xvals,yvals,[xbins,ybins])[0]
+    lh = np.log10(h + 1).T
+    #print lh.shape
+
+    X,Y = np.meshgrid(xbins[:-1], ybins[:-1])
+
+    c = matplotlib.cm.RdYlGn(np.minimum(np.maximum(X/(X + Y), 0),1))
+
+    #print c.shape
+
+    sc = np.minimum(sat*lh/lh.max(), 1)
+
+    r = c[:,:,:3]
+    r[:,:,0] = r[:,:,0]*sc
+    r[:,:,1] = r[:,:,1]*sc
+    r[:,:,2] = r[:,:,2]*sc
+
+    return r
+
+def doInvTCHist(xvals, yvals, xbins, ybins, sat=1):
+    h = np.histogram2d(xvals,yvals,[xbins,ybins])[0]
+    lh = np.log10(h + 1).T
+    #print lh.shape
+
+    X,Y = np.meshgrid(xbins[:-1], ybins[:-1])
+
+    c = 1 - matplotlib.cm.RdYlGn(np.minimum(np.maximum(X/(X + Y), 0),1))
+
+    #print c.shape
+
+    sc = np.minimum(sat*lh/lh.max(), 1)
+
+    r = c[:,:,:3]
+    r[:,:,0] = r[:,:,0]*sc
+    r[:,:,1] = r[:,:,1]*sc
+    r[:,:,2] = r[:,:,2]*sc
+
+    return 1-r
+
+