python-microscopy 26.7.9__cp313-cp313-macosx_26_0_arm64.whl

PYME/misc/eventSpy.py

@@ -0,0 +1,122 @@
+#!/usr/bin/python
+
+###############
+# eventSpy.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/>.
+#
+################
+import wx
+import logging
+
+logging.basicConfig(filename='/tmp/vspy.log',level=logging.DEBUG)
+
+#class MyEventHandler(wx.EvtHandler):
+#    def __init__(self, *args, **kwargs):
+#        wx.EvtHandler.__init__(self, *args, **kwargs)
+
+#    def ProcessEvent(self, evt):
+#        logging.info('Event')
+#        print 'Event: ' #+ evt
+#        return wx.EvtHandler.ProcessEvent(self, evt)
+
+eventIds = {wx.EVT_ENTER_WINDOW.typeId : 'EVT_ENTER_WINDOW',
+wx.EVT_LEAVE_WINDOW.typeId : 'EVT_LEAVE_WINDOW',
+wx.EVT_LEFT_DOWN.typeId : 'EVT_LEFT_DOWN',
+wx.EVT_LEFT_UP.typeId : 'EVT_LEFT_UP',
+wx.EVT_LEFT_DCLICK.typeId : 'EVT_LEFT_DCLICK',
+wx.EVT_MIDDLE_DOWN.typeId : 'EVT_MIDDLE_DOWN',
+wx.EVT_MIDDLE_UP.typeId : 'EVT_MIDDLE_UP',
+wx.EVT_MIDDLE_DCLICK.typeId : 'EVT_MIDDLE_DCLICK',
+wx.EVT_RIGHT_DOWN.typeId : 'EVT_RIGHT_DOWN',
+wx.EVT_RIGHT_UP.typeId : 'EVT_RIGHT_UP',
+wx.EVT_RIGHT_DCLICK.typeId : 'EVT_RIGHT_DCLICK',
+wx.EVT_MOTION.typeId : 'EVT_MOTION',
+wx.EVT_MOUSEWHEEL.typeId : 'EVT_MOUSEWHEEL'}
+
+eventAttrs = ['m_altDown',
+'m_controlDown',
+'m_leftDown',
+'m_middleDown',
+'m_rightDown',
+'m_metaDown',
+'m_shiftDown',
+'m_x',
+'m_y',
+'m_wheelRotation',
+'m_wheelDelta',
+'m_linesPerAction']
+
+
+lastEvents = []
+
+class eventInfo:
+    def __init__(self,event):
+        self.type = event.GetEventType()
+        self.attrs = {}
+
+        for attrName in eventAttrs:
+            self.attrs[attrName] = event.__getattribute__(attrName)
+
+    def __repr__(self):
+        buttons = ''
+
+        if self.attrs['m_leftDown']:
+            buttons += 'l'
+
+        if self.attrs['m_rightDown']:
+            buttons += 'r'
+
+        if self.attrs['m_middleDown']:
+            buttons += 'm'
+
+        return eventIds[self.type] + ' (%d, %d) %s' % (self.attrs['m_x'], self.attrs['m_y'], buttons)
+
+    def recreate(self):
+        e = wx.MouseEvent(self.type)
+        for attrName in eventAttrs:
+            e.__setattr__(attrName, self.attrs[attrName])
+
+        return e
+        
+
+def MouseEvent(event):
+    #global lastEvent
+    #print event.GetEventType()
+    lastEvents.append(eventInfo(event))
+    print((lastEvents[-1]))
+    event.Skip()
+
+def InstallSpy(window):
+    #get the current event handler
+    eh = window.GetEventHandler()
+
+    #install our custom event handler at the top of the stack
+    meh = wx.EvtHandler()
+    #window.SetEventHandler(meh)
+
+    meh.Bind(wx.EVT_MOUSE_EVENTS, MouseEvent)
+
+    #push the original handler back onto the stack so everything works as expected
+    window.PushEventHandler(meh)
+
+def PlayEvents(events, window):
+    for evt in events:
+        window.AddPendingEvent(evt.recreate())
+
+    #return meh
+

PYME/misc/exceptions.py

@@ -0,0 +1,30 @@
+"""
+Custom, PYME-specific exceptions
+
+"""
+
+
+class UserError(Exception):
+    """
+    To be raised, e.g. when doing input validation if the user has entered an incorrect value, or performed an incorrect
+    sequence of events. When using this exception class, the message should be easily readable by the user and should
+    tell them specifically where the error occured and ideally how to fix it. UserErrors will generally be shown in a
+    dialog or message box and will not show tracebacks. IE you can't rely on the traceback context when writing the error
+    message.
+    
+    The main purpose of having these is to make user error handling agnostic of the user interface and to avoid a lot of
+    special case wx.MessageBox calls.
+    
+    Subclassing and defining the help_url attribute to point to the relevant part of the documentation is encouraged.
+    """
+    
+    help_url = None
+    
+    def __init__(self, message, help_url=None):
+        if help_url is not None:
+            self.help_url = help_url
+            
+        self.message=message
+        
+    def __str__(self):
+        return str(self.message)

PYME/misc/facsPlot.py

@@ -0,0 +1,89 @@
+#!/usr/bin/python
+##################
+# facsPlot.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 matplotlib.pyplot as plt
+from scipy import ndimage
+
+def facsPlotScatter(x, y, nbins=None, ms=1):
+    if nbins is None:
+        nbins = 0.25*np.sqrt(len(x))
+    n, xedge, yedge = np.histogram2d(x, y, bins = [nbins,nbins], range=[(min(x), max(x)), (min(y), max(y))])
+
+    dx = np.diff(xedge[:2])
+    dy = np.diff(yedge[:2])
+
+    c = ndimage.map_coordinates(n, [(x - xedge[0])/dx, (y - yedge[0])/dy])
+
+    plt.scatter(x, y, c=c, s=ms, edgecolors='none')
+    
+def facsPlotScatter2(x, y, nxbins=None, nybins=None, ms=1):
+    #if nbins == None:
+    #    nbins = 0.25*sqrt(len(x))
+    n, xedge, yedge = np.histogram2d(x, y, bins = [nxbins,nybins], range=[(min(x), max(x)), (min(y), max(y))])
+
+    dx = np.diff(xedge[:2])
+    dy = np.diff(yedge[:2])
+
+    #c = ndimage.map_coordinates(n, [(x - xedge[0])/dx, (y - yedge[0])/dy])
+
+    bx = np.floor((x - xedge[0])/dx).astype('i')
+    by = np.floor((y - yedge[0])/dy).astype('i')
+    
+    c = n[bx, by]
+
+    plt.scatter(x, y, c=c, s=ms, edgecolors='none')
+
+def facsPlotScatterLog(x, y, nbins=None, ms=1):
+    if nbins is None:
+        nbins = 0.25*np.sqrt(len(x))
+    n, xedge, yedge = np.histogram2d(x, y, bins = [nbins,nbins], range=[(min(x), max(x)), (min(y), max(y))])
+
+    dx = np.diff(xedge[:2])
+    dy = np.diff(yedge[:2])
+
+    c = ndimage.map_coordinates(n, [(x - xedge[0])/dx, (y - yedge[0])/dy])
+
+    plt.scatter(x, y, c=c, s=ms, edgecolors='none')
+
+    ax = plt.gca()
+    ax.get_xaxis().set_scale('log')
+    ax.get_yaxis().set_scale('log')
+    plt.draw()
+    
+    
+
+def facsPlotContour(x, y, nbins=None):
+    if nbins is None:
+        nbins = 0.25*np.sqrt(len(x))
+    n, xedge, yedge = np.histogram2d(x, y, bins = [nbins,nbins], range=[(min(x), max(x)), (min(y), max(y))])
+
+#    dx = diff(xedge[:2])
+#    dy = diff(yedge[:2])
+#
+#    c = ndimage.map_coordinates(n, [(x - xedge[0])/dx, (y - yedge[0])/dy])
+#
+#    scatter(x, y, c=c, s=ms, edgecolors='none')
+    #X, Y = meshgrid(xedge, yedge)
+
+    plt.contour((xedge[:-1] + xedge[1:])/2, (yedge[:-1] + yedge[1:])/2, np.log(n.T + .1), 5, cmap = plt.cm.copper_r)

PYME/misc/fbpIcons.py

@@ -0,0 +1,90 @@
+#!/usr/bin/python
+##################
+# fbpIcons.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
+__author__="david"
+__date__ ="$15/02/2009 00:02:07$"
+
+import wx
+from PYME.ui import wx_compat
+
+
+def GetCollapsedIconData():
+    return \
+b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
+\x00\x01\x8eIDAT8\x8d\xa5\x93-n\xe4@\x10\x85?g\x03\n6lh)\xc4\xd2\x12\xc3\x81\
+\xd6\xa2I\x90\x154\xb9\x81\x8f1G\xc8\x11\x16\x86\xcd\xa0\x99F\xb3A\x91\xa1\
+\xc9J&\x96L"5lX\xcc\x0bl\xf7v\xb2\x7fZ\xa5\x98\xebU\xbdz\xf5\\\x9deW\x9f\xf8\
+H\\\xbfO|{y\x9dT\x15P\x04\x01\x01UPUD\x84\xdb/7YZ\x9f\xa5\n\xce\x97aRU\x8a\
+\xdc`\xacA\x00\x04P\xf0!0\xf6\x81\xa0\xf0p\xff9\xfb\x85\xe0|\x19&T)K\x8b\x18\
+\xf9\xa3\xe4\xbe\xf3\x8c^#\xc9\xd5\n\xa8*\xc5?\x9a\x01\x8a\xd2b\r\x1cN\xc3\
+\x14\t\xce\x97a\xb2F0Ks\xd58\xaa\xc6\xc5\xa6\xf7\xdfya\xe7\xbdR\x13M2\xf9\
+\xf9qKQ\x1fi\xf6-\x00~T\xfac\x1dq#\x82,\xe5q\x05\x91D\xba@\xefj\xba1\xf0\xdc\
+zzW\xcff&\xb8,\x89\xa8@Q\xd6\xaaf\xdfRm,\xee\xb1BDxr#\xae\xf5|\xddo\xd6\xe2H\
+\x18\x15\x84\xa0q@]\xe54\x8d\xa3\xedf\x05M\xe3\xd8Uy\xc4\x15\x8d\xf5\xd7\x8b\
+~\x82\x0fh\x0e"\xb0\xad,\xee\xb8c\xbb\x18\xe7\x8e;6\xa5\x89\x04\xde\xff\x1c\
+\x16\xef\xe0p\xfa>\x19\x11\xca\x8d\x8d\xe0\x93\x1b\x01\xd8m\xf3(;x\xa5\xef=\
+\xb7w\xf3\x1d$\x7f\xc1\xe0\xbd\xa7\xeb\xa0(,"Kc\x12\xc1+\xfd\xe8\tI\xee\xed)\
+\xbf\xbcN\xc1{D\x04k\x05#\x12\xfd\xf2a\xde[\x81\x87\xbb\xdf\x9cr\x1a\x87\xd3\
+0)\xba>\x83\xd5\xb97o\xe0\xaf\x04\xff\x13?\x00\xd2\xfb\xa9`z\xac\x80w\x00\
+\x00\x00\x00IEND\xaeB`\x82'
+
+def GetCollapsedIconBitmap():
+    return wx_compat.BitmapFromImage(GetCollapsedIconImage())
+
+def GetCollapsedIconImage():
+    from io import BytesIO
+    stream = BytesIO(GetCollapsedIconData())
+    return wx.ImageFromStream(stream)
+
+#----------------------------------------------------------------------
+def GetExpandedIconData():
+    return \
+b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
+\x00\x01\x9fIDAT8\x8d\x95\x93\xa1\x8e\xdc0\x14EO\xb2\xc4\xd0\xd2\x12\xb7(mI\
+\xa4%V\xd1lQT4[4-\x9a\xfe\xc1\xc2|\xc6\xc2~BY\x83:A3E\xd3\xa0*\xa4\xd2\x90H!\
+\x95\x0c\r\r\x1fK\x81g\xb2\x99\x84\xb4\x0fY\xd6\xbb\xc7\xf7>=\'Iz\xc3\xbcv\
+\xfbn\xb8\x9c\x15 \xe7\xf3\xc7\x0fw\xc9\xbc7\x99\x03\x0e\xfbn0\x99F+\x85R\
+\x80RH\x10\x82\x08\xde\x05\x1ef\x90+\xc0\xe1\xd8\ryn\xd0Z-\\A\xb4\xd2\xf7\
+\x9e\xfbwoF\xc8\x088\x1c\xbbae\xb3\xe8y&\x9a\xdf\xf5\xbd\xe7\xfem\x84\xa4\
+\x97\xccYf\x16\x8d\xdb\xb2a]\xfeX\x18\xc9s\xc3\xe1\x18\xe7\x94\x12cb\xcc\xb5\
+\xfa\xb1l8\xf5\x01\xe7\x84\xc7\xb2Y@\xb2\xcc0\x02\xb4\x9a\x88%\xbe\xdc\xb4\
+\x9e\xb6Zs\xaa74\xadg[6\x88<\xb7]\xc6\x14\x1dL\x86\xe6\x83\xa0\x81\xba\xda\
+\x10\x02x/\xd4\xd5\x06\r\x840!\x9c\x1fM\x92\xf4\x86\x9f\xbf\xfe\x0c\xd6\x9ae\
+\xd6u\x8d \xf4\xf5\x165\x9b\x8f\x04\xe1\xc5\xcb\xdb$\x05\x90\xa97@\x04lQas\
+\xcd*7\x14\xdb\x9aY\xcb\xb8\\\xe9E\x10|\xbc\xf2^\xb0E\x85\xc95_\x9f\n\xaa/\
+\x05\x10\x81\xce\xc9\xa8\xf6><G\xd8\xed\xbbA)X\xd9\x0c\x01\x9a\xc6Q\x14\xd9h\
+[\x04\xda\xd6c\xadFkE\xf0\xc2\xab\xd7\xb7\xc9\x08\x00\xf8\xf6\xbd\x1b\x8cQ\
+\xd8|\xb9\x0f\xd3\x9a\x8a\xc7\x08\x00\x9f?\xdd%\xde\x07\xda\x93\xc3{\x19C\
+\x8a\x9c\x03\x0b8\x17\xe8\x9d\xbf\x02.>\x13\xc0n\xff{PJ\xc5\xfdP\x11""<\xbc\
+\xff\x87\xdf\xf8\xbf\xf5\x17FF\xaf\x8f\x8b\xd3\xe6K\x00\x00\x00\x00IEND\xaeB\
+`\x82'
+
+def GetExpandedIconBitmap():
+    return wx_compat.BitmapFromImage(GetExpandedIconImage())
+
+def GetExpandedIconImage():
+    from io import BytesIO
+    stream = BytesIO(GetExpandedIconData())
+    return wx.ImageFromStream(stream)

PYME/misc/fftw_compat.py

@@ -0,0 +1,28 @@
+"""
+Compatibility shim to translate between pyfftw3 and pyfftw calls
+"""
+
+try:
+    from fftw3f import Plan, create_aligned_array
+except ImportError:
+    import pyfftw
+    from pyfftw import empty_aligned as create_aligned_array
+    
+    class Plan(object):
+        def __init__(self, A, B, direction, flags = [], nthreads=1):
+            
+            if direction == 'forward':
+                dir = 'FFTW_FORWARD'
+            else:
+                dir = 'FFTW_BACKWARD'
+                
+            out_flags = []
+            for f in flags:
+                if f == 'measure':
+                    out_flags.append('FFTW_MEASURE')
+
+            self._plan = pyfftw.FFTW(A, B, direction=dir, axes=[int(i) for i in range(A.ndim)], threads=int(nthreads),  flags = out_flags)
+            
+        def __call__(self):
+            self._plan.execute()
+            

PYME/misc/findCycles.py

@@ -0,0 +1,91 @@
+#!/usr/bin/python
+##################
+# findCycles.py
+#
+# Copyright David Baddeley, 2011
+# 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/>.
+#
+##################
+
+###
+#http://code.activestate.com/recipes/523004-find-cyclical-references/
+
+
+import gc
+import sys
+from types import FrameType
+
+def print_cycles(objects, outstream=sys.stdout, show_progress=False):
+    """
+    objects:       A list of objects to find cycles in.  It is often useful
+                   to pass in gc.garbage to find the cycles that are
+                   preventing some objects from being garbage collected.
+    outstream:     The stream for output.
+    show_progress: If True, print the number of objects reached as they are
+                   found.
+    """
+    def print_path(path):
+        for i, step in enumerate(path):
+            # next "wraps around"
+            next = path[(i + 1) % len(path)]
+
+            outstream.write("   %s -- " % str(type(step)))
+            if isinstance(step, dict):
+                for key, val in step.items():
+                    if val is next:
+                        outstream.write("[%s]" % repr(key))
+                        break
+                    if key is next:
+                        outstream.write("[key] = %s" % repr(val))
+                        break
+            elif isinstance(step, list):
+                outstream.write("[%d]" % step.index(next))
+            elif isinstance(step, tuple):
+                outstream.write("[%d]" % list(step).index(next))
+            else:
+                outstream.write(repr(step))
+            outstream.write(" ->\n")
+        outstream.write("\n")
+
+    def recurse(obj, start, all, current_path):
+        if show_progress:
+            outstream.write("%d\r" % len(all))
+
+        all[id(obj)] = None
+
+        referents = gc.get_referents(obj)
+        for referent in referents:
+            # If we've found our way back to the start, this is
+            # a cycle, so print it out
+            if referent is start:
+                print_path(current_path)
+
+            # Don't go back through the original list of objects, or
+            # through temporary references to the object, since those
+            # are just an artifact of the cycle detector itself.
+            elif referent is objects or isinstance(referent, FrameType):
+                continue
+
+            # We haven't seen this object before, so recurse
+            elif id(referent) not in all:
+                recurse(referent, start, all, current_path + [obj])
+
+    for obj in objects:
+        outstream.write("Examining: %r\n" % obj)
+        recurse(obj, obj, { }, [])
+
+
+

PYME/misc/fortran_interrupt_defeat.py

@@ -0,0 +1,43 @@
+"""
+
+Workaround for a fortran module linked from scipy.stats which causes a hard exit if a process is terminated using cntrl-c
+
+See: http://stackoverflow.com/questions/15457786/ctrl-c-crashes-python-after-importing-scipy-stats
+
+for details.
+
+"""
+
+import os
+import sys
+
+if sys.platform == 'win32':
+    try:
+        import imp
+        import ctypes
+        import thread
+        import win32api
+        
+        # Load the DLL manually to ensure its handler gets
+        # set before our handler.
+        #basepath = imp.find_module('numpy')[1]
+        #ctypes.CDLL(os.path.join(basepath, 'core', 'libmmd.dll'))
+        #ctypes.CDLL(os.path.join(basepath, 'core', 'libifcoremd.dll'))
+
+        #anaconda stores dlls in a Library/bin directory
+        basepath = os.path.join(sys.prefix, 'Library', 'bin')
+        ctypes.CDLL(os.path.join(basepath, 'libmmd.dll'))
+        ctypes.CDLL(os.path.join(basepath, 'libifcoremd.dll'))
+        
+        # Now set our handler for CTRL_C_EVENT. Other control event
+        # types will chain to the next handler.
+        def handler(dwCtrlType, hook_sigint=thread.interrupt_main):
+            if dwCtrlType == 0: # CTRL_C_EVENT
+                hook_sigint()
+                return 1 # don't chain to the next handler
+            return 0 # chain to the next handler
+        
+        win32api.SetConsoleCtrlHandler(handler, 1)
+    except:
+        import logging
+        logging.exception('Could not locate numpy fortran libs, ignoring')

PYME/misc/glassModel.py

@@ -0,0 +1,64 @@
+#!/usr/bin/python
+
+##################
+# glassModel.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/>.
+#
+##################
+
+import numpy as np
+
+#constants taken from http://www.cvilaser.com/Common/PDFs/Dispersion_Equations.pdf
+sellConstants = {
+'MgF2 e' :         (4.13440230E-01,  5.04974990E-01,  2.49048620E+00,  1.35737865E-03, 8.23767167E-03, 5.65107755E+02),
+'MgF2 o' :         (4.87551080E-01,  3.98750310E-01,  2.31203530E+00,  1.88217800E-03, 8.95188847E-03, 5.66135591E+02),
+'Sapphire e' :     (1.50397590E+00,  5.50691410E-01,  6.59273790E+00,  5.48041129E-03, 1.47994281E-02, 4.02895140E+02),
+'Sapphire o' :     (1.43134930E+00,  6.50547130E-01,  5.34140210E+00,  5.27992610E-03, 1.42382647E-02, 3.25017834E+02),
+'CaF2' :           (5.67588800E-01,  4.71091400E-01,  3.84847230E+00,  2.52642999E-03, 1.00783328E-02, 1.20055597E+03),
+'Fused Silica' :   (6.96166300E-01,  4.07942600E-01,  8.97479400E-01,  4.67914826E-03, 1.35120631E-02, 9.79340025E+01),
+'Schott BK7' :     (1.03961212E+00,  2.31792344E-01,  1.01046945E+00,  6.00069867E-03, 2.00179144E-02, 1.03560653E+02),
+'Schott N-BK7':    (1.03961212E+00,  2.31792344E-01,  1.01046945E+00,  6.00069867E-03, 2.00179144E-02, 1.03560653E+02),
+'Schott F2':       (1.34533359E+00,  2.09073118E-01,  9.37357162E-01,  9.97743871E-03, 4.70450767E-02, 1.11886764E+02),
+'Schott N-F2':     (1.39757037E+00,  1.59201403E-01,  1.26865430E+00,  9.95906143E-03, 5.46931752E-02, 1.19248346E+02),
+'Schott SF2' :     (1.40301821E+00,  2.09073176E-01,  9.39056586E-01,  1.05795466E-02, 4.93226978E-02, 1.12405955E+02),
+'Schott SF10' :    (1.61625977E+00,  2.59229334E-01,  1.07762317E+00,  1.27534559E-02, 5.81983954E-02, 1.16607680E+02),
+'Schott N-SF10' :  (1.62153902E+00,  2.56287842E-01,  1.64447552E+00,  1.22241457E-02, 5.95736775E-02, 1.47468793E+02),
+'Schott SF11' :    (1.73848403E+00,  3.11168974E-01,  1.17490871E+00,  1.36068604E-02, 6.15960463E-02, 1.21922711E+02),
+'Schott N-SF11' :  (1.73759695E+00,  3.13747346E-01,  1.89878101E+00,  1.13188707E-02, 6.23068142E-02, 1.55236290E+02),
+'Schott N-LAK21' : (1.22718116E+00,  4.20783743E-01,  1.01284843E+00,  6.02075682E-03, 1.96862889E-02, 8.84370099E+01)
+}
+
+
+def Sellmeier(lamb, B1, B2, B3, C1, C2, C3):
+    L2 = (lamb/1e3)**2
+    return np.sqrt(1 + (B1*L2)/(L2-C1) + (B2*L2)/(L2-C2) + (B3*L2)/(L2-C3))
+
+
+cauchConstants = {
+'Index Matching Fluid' : (1.502787, 455872.4e-8, 9.844856e-5)
+}
+
+def Cauchy(lamb, *args):
+    L2 = (lamb/1e3)**2
+
+    n = 0
+
+    for a, n in zip(args, range(len(args))):
+        n += a/(L2**n)
+
+    return n

PYME/misc/hash32.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+###############
+# hash32.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/>.
+#
+################
+import numpy as np
+# noinspection PyCompatibility
+from builtins import int
+
+def c_mul(a, b):
+    return eval(hex((int(a) * b) & 0xFFFFFFFF)[:-1])
+
+
+def hashString32(s):
+    if not s:
+        return 0 # empty
+    value = np.array([ord(s[0]) << 7], 'int32')
+    for char in s:
+        value = (value*1000003) ^ ord(char)
+    value = value ^ len(s)
+    value = int(value)
+    if value == -1:
+        value = -2
+    return value

PYME/misc/hillcurve.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+
+###############
+# hillcurve.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/>.
+#
+################
+# -*- coding: utf-8 -*-
+
+# from pylab import *
+import matplotlib.pyplot as plt
+import numpy as np
+from PYME.Analysis._fithelpers import *
+
+def hill(p, ratio):
+    """Modified Hills function for fitting to stress vs ratio data.
+    
+    Parameters (in  array p) are:
+        p[0] = n 
+        p[1] = Ka (EC50)
+        p[2] = Fmax
+        p[3] = Fmin
+    
+    """
+    n, Ka, Fmax, Fmin = p 
+    return Fmin + Fmax*(ratio**n)/(Ka**n + ratio**n)
+
+if __name__ == '__main__':
+    #load control data
+    ratio_control, stress_control = np.loadtxt('control.csv').T
+    plt.plot(ratio_control, stress_control, 'x', label='control')
+
+    #do fit
+    fit_results = FitModel(hill, [1, 2.7, 50, 1], ratio_control)
+    p_control = fit_results[0]
+
+    print(("""
+    Control:
+    ---------
+    n = %3.2f
+    EC50 = %3.2f
+    Fmax = %3.2f
+    Fmin = %3.2f
+
+    """ % p_control))
+
+    ratio = np.linspace(1.5, 4)
+    plt.plot(ratio, hill(p_control, ratio))
+
+
+    #load cptome data
+    ratio_cptome, stress_cptome = np.loadtxt('cptome.csv').T
+    plt.plot(ratio_cptome, stress_cptome, 'x', label='CPTOME')
+
+    #do fit
+    fit_results = FitModel(hill, [1, 2.7, 50, 1], ratio_cptome)
+    p_cptome = fit_results[0]
+
+    print(("""
+    CPTOME:
+    ---------
+    n = %3.2f
+    EC50 = %3.2f
+    Fmax = %3.2f
+    Fmin = %3.2f
+
+    """ % p_cptome))
+
+    plt.plot(ratio, hill(p_cptome, ratio))
+
+    plt.xlabel('Ratio - 340/380')
+    plt.ylabel('Stress')
+    plt.legend()