fabio 0.1.1__zip

Library/Python/2.7/site-packages/fabio/file_series.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+
+"""
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:erik.knudsen@risoe.dk
+
+        + Jon Wright, ESRF
+"""
+import logging, sys
+logger = logging.getLogger("fileseries")
+import traceback as pytraceback
+
+from fabioutils import filename_object, next_filename
+
+from openimage import openimage
+
+
+def new_file_series0(first_object, first=None, last=None, step=1):
+    """
+    Created from a fabio image
+    first and last are file numbers
+    """
+    im = first_object
+    nimages = 0
+    # for counting images
+    if None in (first, last):
+        step = 0
+        total = 1
+    else:
+        total = last - first
+
+    yield im
+    while nimages < total:
+        nimages += step
+        try:
+            newim = im.next()
+            im = newim
+        except Exception, error:
+            pytraceback.print_exc()
+
+            # Skip bad images
+            logger.warning("Got a problem here: %s", error)
+            try:
+                im.filename = next_filename(im.filename)
+            except Exception, error:
+                # KE: This will not work and will throw an exception
+                # fabio.next_filename doesn't understand %nnnn on the end
+                logger.warning("Got another problem here: %s", error)
+                im.filename = next_filename(im.sequencefilename)
+            yield None
+        yield im
+
+
+
+def new_file_series(first_object, nimages=0, step=1, traceback=False):
+    """
+    A generator function that creates a file series starting from a a fabioimage.
+    Iterates through all images in a file (if more than 1), then proceeds to
+    the next file as determined by fabio.next_filename.
+    
+    first_object: the starting fabioimage, which will be the first one yielded
+      in the sequence
+    nimages:  the maximum number of images to consider
+    step: step size, will yield the first and every step'th image until nimages
+      is reached.  (e.g. nimages = 5, step = 2 will yield 3 images (0, 2, 4) 
+    traceback: if True causes it to print a traceback in the event of an
+      exception (missing image, etc.).  Otherwise the calling routine can handle
+      the exception as it chooses 
+    yields: the next fabioimage in the series.
+      In the event there is an exception, it yields the sys.exec_info for the
+      exception instead.  sys.exec_info is a tuple:
+        ( exceptionType, exceptionValue, exceptionTraceback )
+      from which all the exception information can be obtained.
+      Suggested usage:
+        for obj in new_file_series( ... ):
+          if not isinstance( obj, fabio.fabioimage.fabioimage ):
+            # deal with errors like missing images, non readable files, etc
+            # e.g.
+            traceback.print_exception(obj[0], obj[1], obj[2])
+    """
+    im = first_object
+    nprocessed = 0
+    abort = False
+    if nimages > 0:
+        yield im
+        nprocessed += 1
+    while nprocessed < nimages:
+        try:
+            newim = im.next()
+            im = newim
+            retVal = im
+        except Exception, ex:
+            retVal = sys.exc_info()
+            if(traceback):
+                pytraceback.print_exc()
+                # Skip bad images
+                logger.warning("Got a problem here: next() failed %s", ex)
+            # Skip bad images
+            try:
+                im.filename = next_filename(im.filename)
+            except Exception, ex:
+                logger.warning("Got another problem here: next_filename(im.filename) %s", ex)
+        if nprocessed % step == 0:
+            yield retVal
+            # Avoid cyclic references with exc_info ?
+            retVal = None
+            if abort: break
+        nprocessed += 1
+
+
+
+class file_series(list):
+    """
+    represents a series of files to iterate
+    has an idea of a current position to do next and prev
+
+    You also get from the list python superclass:
+       append
+       count
+       extend
+       insert
+       pop
+       remove
+       reverse
+       sort
+    """
+    def __init__(self, list_of_strings):
+        """
+        arg should be a list of strings which are filenames
+        """
+        super(file_series, self).__init__(list_of_strings)
+        # track current position in list
+        self._current = 0
+
+
+    # methods which return a filename
+
+    def first(self):
+        """ first image in series """
+        return self[0]
+
+    def last(self):
+        """ last in series """
+        return self[-1]
+
+    def previous(self):
+        """ prev in a sequence"""
+        self._current -= 1
+        return self[self._current]
+
+    def current(self):
+        """ current position in a sequence """
+        return self[self._current]
+
+    def next(self):
+        """ next in a sequence """
+        self._current += 1
+        return self[self._current]
+
+    def jump(self, num):
+        """ goto a position in sequence """
+        assert num < len(self) and num > 0, "num out of range"
+        self._current = num
+        return self[self._current]
+
+    def len(self):
+        """ number of files"""
+        return len(self)
+
+
+    # Methods which return a fabioimage
+
+    def first_image(self):
+        """ first image in a sequence """
+        return openimage(self.first())
+
+    def last_image(self):
+        """ last image in a sequence """
+        return openimage(self.last())
+
+    def next_image(self):
+        """ Return the next image """
+        return openimage(self.next())
+
+    def previous_image(self):
+        """ Return the previous image """
+        return openimage(self.previous())
+
+    def jump_image(self, num):
+        """ jump to and read image """
+        return openimage(self.jump(num))
+
+    def current_image(self):
+        """ current image in sequence """
+        return openimage(self.current())
+
+    # methods which return a file_object
+
+    def first_object(self):
+        """ first image in a sequence """
+        return filename_object(self.first())
+
+    def last_object(self):
+        """ last image in a sequence """
+        return filename_object(self.last())
+
+    def next_object(self):
+        """ Return the next image """
+        return filename_object(self.next())
+
+    def previous_object(self):
+        """ Return the previous image """
+        return filename_object(self.previous())
+
+    def jump_object(self, num):
+        """ jump to and read image """
+        return filename_object(self.jump(num))
+
+    def current_object(self):
+        """ current image in sequence """
+        return filename_object(self.current())
+
+
+
+
+class numbered_file_series(file_series):
+    """
+    mydata0001.edf = "mydata" + 0001 + ".edf"
+    mydata0002.edf = "mydata" + 0002 + ".edf"
+    mydata0003.edf = "mydata" + 0003 + ".edf"
+    """
+    def __init__(self, stem, first, last, extension,
+                 digits=4, padding='Y', step=1):
+        """
+        stem - first part of the name
+        step - in case of every nth file
+        padding - possibility for specifying that numbers are not padded
+                  with zeroes up to digits
+        """
+        if padding == 'Y':
+            fmt = "%s%0" + str(digits) + "d%s"
+        else:
+            fmt = "%s%i%s"
+
+        super(numbered_file_series, self).__init__(
+            [ fmt % (stem, i, extension) for i in range(first,
+                                                          last + 1,
+                                                          step) ])
+
+
+class filename_series:
+    """ Much like the others, but created from a string filename """
+    def __init__(self, filename):
+        """ create from a filename (String)"""
+        self.obj = filename_object(filename)
+
+    def next(self):
+        """ increment number """
+        self.obj.num += 1
+        return self.obj.tostring()
+
+    def previous(self):
+        """ decrement number """
+        self.obj.num -= 1
+        return self.obj.tostring()
+
+    def current(self):
+        """ return current filename string"""
+        return self.obj.tostring()
+
+    def jump(self, num):
+        """ jump to a specific number """
+        self.obj.num = num
+        return self.obj.tostring()
+
+    # image methods
+    def next_image(self):
+        """ returns the next image as a fabioimage """
+        return openimage(self.next())
+    def prev_image(self):
+        """ returns the previos image as a fabioimage """
+        return openimage(self.previous())
+    def current_image(self):
+        """ returns the current image as a fabioimage"""
+        return openimage(self.current())
+    def jump_image(self, num):
+        """ returns the image number as a fabioimage"""
+        return openimage(self.jump(num))
+    # object methods
+    def next_object(self):
+        """ returns the next filename as a fabio.filename_object"""
+        self.obj.num += 1
+        return self.obj
+    def previous_object(self):
+        """ returns the previous filename as a fabio.filename_object"""
+        self.obj.num -= 1
+        return self.obj
+    def current_object(self):
+        """ returns the current filename as a fabio.filename_object"""
+        return self.obj
+    def jump_object(self, num):
+        """ returns the filename num as a fabio.filename_object"""
+        self.obj.num = num
+        return self.obj
+
+
+
+

Library/Python/2.7/site-packages/fabio/fit2dmaskimage.py

@@ -0,0 +1,94 @@
+## Automatically adapted for numpy.oldnumeric Oct 05, 2007 by alter_code1.py
+
+#!/usr/bin/env python
+"""
+
+Author: Andy Hammersley, ESRF
+Translation into python/fabio: Jon Wright, ESRF
+"""
+
+import numpy
+
+from fabioimage import fabioimage
+
+
+class fit2dmaskimage(fabioimage):
+    """ Read and try to write Andy Hammersley's mask format """
+
+
+    def _readheader(self, infile):
+        """
+        Read in a header from an already open file
+        """
+        # 1024 bytes gives 256x32 bit integers
+        header = infile.read(1024)
+        for i, j in [ ("M", 0),
+                      ("A", 4),
+                      ("S", 8),
+                      ("K", 12)  ]:
+            if header[j] != i:
+                raise Exception("Not a fit2d mask file")
+        fit2dhdr = numpy.fromstring(header, numpy.int32)
+        self.dim1 = fit2dhdr[4] # 1 less than Andy's fortran
+        self.dim2 = fit2dhdr[5]
+
+
+    def read(self, fname, frame=None):
+        """
+        Read in header into self.header and
+            the data   into self.data
+        """
+        fin = self._open(fname)
+        self._readheader(fin)
+        # Compute image size
+        self.bytecode = numpy.uint8
+        self.bpp = len(numpy.array(0, self.bytecode).tostring())
+
+        # integer division
+        num_ints = (self.dim1 + 31) // 32
+        total = self.dim2 * num_ints * 4
+        data = fin.read(total)
+        assert len(data) == total
+        fin.close()
+
+        # Now to unpack it
+        data = numpy.fromstring(data, numpy.uint8)
+        data = numpy.reshape(data, (self.dim2, num_ints * 4))
+
+        result = numpy.zeros((self.dim2, num_ints * 4 * 8), numpy.uint8)
+
+        # Unpack using bitwise comparisons to 2**n
+        bits = numpy.ones((1), numpy.uint8)
+        for i in range(8):
+            temp = numpy.bitwise_and(bits, data)
+            result[:, i::8] = temp.astype(numpy.uint8)
+            bits = bits * 2
+        # Extra rows needed for packing odd dimensions
+        spares = num_ints * 4 * 8 - self.dim1
+        if spares == 0:
+            self.data = numpy.where(result == 0, 0, 1)
+        else:
+            self.data = numpy.where(result[:, :-spares] == 0, 0, 1)
+        # Transpose appears to be needed to match edf reader (scary??)
+#        self.data = numpy.transpose(self.data)
+        self.data = numpy.reshape(self.data.astype(numpy.uint16),
+                                    (self.dim2, self.dim1))
+        self.pilimage = None
+        return self
+
+
+
+    def write(self, fname):
+        """
+        Try to write a file
+        check we can write zipped also
+        mimics that fabian was writing uint16 (we sometimes want floats)
+        """
+        raise Exception("Not implemented yet")
+
+    @staticmethod
+    def checkData(data=None):
+        if data is None:
+            return None
+        else:
+            return data.astype(int)

Library/Python/2.7/site-packages/fabio/fit2dspreadsheetimage.py

@@ -0,0 +1,85 @@
+
+
+"""
+Read the fit2d ascii image output
+        + Jon Wright, ESRF
+"""
+
+import numpy
+
+from fabioimage import fabioimage
+
+
+
+
+class fit2dspreadsheetimage(fabioimage):
+    """
+    Read a fit2d ascii format
+    """
+
+    def _readheader(self, infile):
+        """
+
+        TODO : test for minimal attributes?
+        """
+        line = infile.readline()
+        try:
+            items = line.split()
+            xdim = int(items[0])
+            ydim = int(items[1])
+        except:
+            raise
+        self.header['title'] = line
+        self.header['Dim_1'] = xdim
+        self.header['Dim_2'] = ydim
+
+    def read(self, fname, frame=None):
+        """
+        Read in header into self.header and
+            the data   into self.data
+        """
+        self.header = {}
+        self.resetvals()
+        infile = self._open(fname)
+        self._readheader(infile)
+        # Compute image size
+        try:
+            self.dim1 = int(self.header['Dim_1'])
+            self.dim2 = int(self.header['Dim_2'])
+        except:
+            raise Exception("file", str(fname) + \
+                                "is corrupt, cannot read it")
+        bytecode = numpy.float32
+
+        self.bpp = len(numpy.array(0, bytecode).tostring())
+
+        #now read the data into the array
+        try:
+            vals = []
+            for line in infile.readlines():
+                try:
+                    vals.append([float(x) for x in line.split()])
+                except:
+                    pass
+            self.data = numpy.array(vals).astype(bytecode)
+            assert self.data.shape == (self.dim2, self.dim1)
+
+        except:
+            raise IOError, "Error reading ascii"
+
+        self.resetvals()
+        # ensure the PIL image is reset
+        self.pilimage = None
+        return self
+
+
+if __name__ == "__main__":
+    import sys, time
+    start = time.time()
+    img = fit2dspreadsheetimage()
+    img.read(sys.argv[1])
+    print time.time() - start
+    print img.dim1, img.dim2, img.data.shape
+    from matplotlib.pylab import imshow, show
+    imshow(img.data.T)
+    show()

Library/Python/2.7/site-packages/fabio/kcdimage.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+"""
+Authors: Jerome Kieffer, ESRF 
+         email:jerome.kieffer@esrf.fr
+
+kcd images are 2D images written by the old KappaCCD diffractometer built by Nonius in the 1990's
+Based on the edfimage.py parser.
+"""
+
+import numpy, logging
+import os, string
+from fabioimage import fabioimage
+logger = logging.getLogger("kcdimage")
+
+DATA_TYPES = {"u16"  :  numpy.uint16 }
+
+MINIMUM_KEYS = [
+                'ByteOrder',
+                'Data type',
+                'X dimension',
+                'Y dimension',
+                'Number of readouts']
+
+DEFAULT_VALUES = { "Data type": "u16" }
+
+
+
+
+class kcdimage(fabioimage):
+    """ 
+    Read the Nonius kcd data format """
+
+
+    def _readheader(self, infile):
+        """
+        Read in a header in some KCD format from an already open file
+        @
+        """
+        oneLine = infile.readline()
+        alphanum = string.digits + string.letters + ". "
+        asciiHeader = True
+        for oneChar in oneLine.strip():
+            if not oneChar in alphanum:
+                asciiHeader = False
+
+
+        if asciiHeader is False:
+            # This does not look like an edf file
+            logger.warning("First line of %s does not seam to be ascii text!" % infile.name)
+        endOfHeaders = False
+        while not endOfHeaders:
+            oneLine = infile.readline()
+            if len(oneLine) > 100:
+                endOfHeaders = True
+                break
+            if oneLine.strip() == "Binned mode":
+                oneLine = "Mode = Binned"
+            try:
+                key, val = oneLine.split('=' , 1)
+            except:
+                endOfHeaders = True
+                break
+            key = key.strip()
+            self.header_keys.append(key)
+            self.header[key] = val.strip()
+        missing = []
+        for item in MINIMUM_KEYS:
+            if item not in self.header_keys:
+                missing.append(item)
+        if len(missing) > 0:
+            logger.debug("KCD file misses the keys " + " ".join(missing))
+
+
+    def read(self, fname, frame=None):
+        """
+        Read in header into self.header and
+            the data   into self.data
+        """
+        self.header = {}
+        self.resetvals()
+        infile = self._open(fname, "rb")
+        self._readheader(infile)
+        # Compute image size
+        try:
+            self.dim1 = int(self.header['X dimension'])
+            self.dim2 = int(self.header['Y dimension'])
+        except:
+            raise Exception("KCD file %s is corrupt, cannot read it" % fname)
+        try:
+            bytecode = DATA_TYPES[self.header['Data type']]
+            self.bpp = len(numpy.array(0, bytecode).tostring())
+        except KeyError:
+            bytecode = numpy.uint16
+            self.bpp = 2
+            logger.warning("Defaulting type to uint16")
+        try:
+            nbReadOut = int(self.header['Number of readouts'])
+        except KeyError:
+            logger.warning("Defaulting number of ReadOut to 1")
+            nbReadOut = 1
+        fileSize = os.stat(fname)[6]
+        expected_size = self.dim1 * self.dim2 * self.bpp * nbReadOut
+        infile.seek(fileSize - expected_size)
+        block = infile.read()
+        assert len(block) == expected_size
+        infile.close()
+
+        #now read the data into the array
+        self.data = numpy.zeros((self.dim2, self.dim1))
+        try:
+            for i in range(nbReadOut):
+                self.data += numpy.reshape(numpy.fromstring(
+                    block[i * expected_size / nbReadOut:(i + 1) * expected_size / nbReadOut], bytecode),
+                    [self.dim2, self.dim1])
+        except:
+            print len(block), bytecode, self.bpp, self.dim2, self.dim1
+            raise IOError, \
+              'Size spec in kcd-header does not match size of image data field'
+        self.bytecode = self.data.dtype.type
+        self.resetvals()
+        # ensure the PIL image is reset
+        self.pilimage = None
+        return self
+
+
+    @staticmethod
+    def checkData(data=None):
+        if data is None:
+            return None
+        else:
+            return data.astype(int)