fabio 0.1.1__zip

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

@@ -0,0 +1,162 @@
+"""
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:henning.sorensen@risoe.dk
+
+mods for fabio by JPW
+
+"""
+import sys, logging
+logger = logging.getLogger("openimage")
+from fabioutils  import deconstruct_filename, filename_object
+from fabioimage import fabioimage
+import edfimage
+import adscimage
+import tifimage
+import marccdimage
+import mar345image
+import fit2dmaskimage
+import brukerimage
+import bruker100image
+import pnmimage
+import GEimage
+import OXDimage
+import dm3image
+import HiPiCimage
+import pilatusimage
+import fit2dspreadsheetimage
+import kcdimage
+import cbfimage
+import xsdimage
+import binaryimage
+
+MAGIC_NUMBERS = [
+    # "\42\5a" : 'bzipped'
+    # "\1f\8b" : 'gzipped'
+    ("FORMAT :        86" , 'bruker'),
+    ("\x4d\x4d\x00\x2a"   , 'tif') ,
+    # The marCCD and Pilatus formats are both standard tif with a header
+    # hopefully these byte patterns are unique for the formats
+    # If not the image will be read, but the is missing 
+    ("\x49\x49\x2a\x00\x08\x00"   , 'marccd') ,
+    ("\x49\x49\x2a\x00\x82\x00"   , 'pilatus') ,
+    ("\x49\x49\x2a\x00"   , 'tif') ,
+    # ADSC must come before edf
+    ("{\nHEA"             , 'adsc'),
+    ("{"                  , 'edf'),
+    ("\r{"                , 'edf'),
+    ("\n{"                , 'edf'),
+    ("ADEPT"              , 'GE'),
+    ("OD"                 , 'OXD'),
+    ("IM"                 , 'HiPiC'),
+    ('\x2d\x04'           , 'mar345'),
+    ('\xd2\x04'           , 'mar345'),
+    ('\x04\x2d'           , 'mar345'), #some machines may need byteswapping
+    ('\x04\xd2'           , 'mar345'),
+    # hint : MASK in 32 bit
+    ('M\x00\x00\x00A\x00\x00\x00S\x00\x00\x00K\x00\x00\x00' , 'fit2dmask') ,
+    ('\x00\x00\x00\x03'   , 'dm3'),
+    ("No"                 , "kcd"),
+    ("<"                  , "xsd")
+    ]
+
+def do_magic(byts):
+    """ Try to interpret the bytes starting the file as a magic number """
+    for magic, format_type in MAGIC_NUMBERS:
+        if byts.find(magic) == 0:
+            return format_type
+        if 0: # debugging - bruker needed 18 bytes below
+            logger.debug("m: %s f: %s", magic, format_type)
+            logger.debug("bytes: %s len(bytes) %s", magic, len(magic))
+            logger.debug("found: %s", byts.find(magic))
+            for i in range(len(magic)):
+                logger.debug("%s %s %s %s ", ord(magic[i]), ord(byts[i]), magic[i], byts[i])
+    raise Exception("Could not interpret magic string")
+
+
+def openimage(filename, frame=None):
+    """ Try to open an image """
+    if isinstance(filename, filename_object):
+        try:
+            logger.debug("Attempting to open %s" % (filename.tostring()))
+            obj = _openimage(filename.tostring())
+            logger.debug("Attempting to read frame %s from %s" % (frame,
+                filename.tostring()))
+            obj = obj.read(filename.tostring(), frame)
+        except Exception, ex:
+            # multiframe file
+            #logger.debug( "DEBUG: multiframe file, start # %d"%(
+            #    filename.num)
+            logger.debug("Exception %s, trying name %s" % (ex, filename.stem))
+            obj = _openimage(filename.stem)
+            logger.debug("Reading frame %s from %s" % (filename.num, filename.stem))
+            obj.read(filename.stem, frame=filename.num)
+    else:
+        logger.debug("Attempting to open %s" % (filename))
+        obj = _openimage(filename)
+        logger.debug("Attempting to read frame %s from %s" % (frame, filename))
+        obj = obj.read(filename, frame)
+    return obj
+
+
+def openheader(filename):
+    """ return only the header"""
+    obj = _openimage(filename)
+    obj.readheader(filename)
+    return obj
+
+
+def _openimage(filename):
+    """ 
+    determine which format for a filename
+    and return appropriate class which can be used for opening the image
+    """
+    try:
+        imo = fabioimage()
+        byts = imo._open(filename).read(18)
+        filetype = do_magic(byts)
+        if filetype == "marccd" and filename.find("mccd") == -1:
+            # Cannot see a way around this. Need to find something
+            # to distinguish mccd from regular tif...
+            filetype = "tif"
+    except IOError, error:
+        logger.error("%s: File probably does not exist", error)
+        raise error
+    except:
+        try:
+            file_obj = deconstruct_filename(filename)
+            if file_obj == None:
+                raise Exception("Unable to deconstruct filename")
+            if (file_obj.format is not None) and\
+                len(file_obj.format) != 1 and \
+                type(file_obj.format) != type(["list"]):
+                # one of OXD/ ADSC - should have got in previous
+                raise Exception("openimage failed on magic bytes & name guess")
+            filetype = file_obj.format
+            #UNUSED filenumber = file_obj.num
+        except Exception, error:
+            logger.error(error)
+            import traceback
+            traceback.print_exc()
+            raise Exception("Fabio could not identify " + filename)
+    klass_name = "".join(filetype) + 'image'
+    module = sys.modules.get("fabio." + klass_name, None)
+    if module is not None:
+        if hasattr(module, klass_name):
+            klass = getattr(module, klass_name)
+        else:
+            raise Exception("Module %s has no image class" % module)
+    else:
+        raise Exception("Filetype not known %s %s" % (filename, klass_name))
+    obj = klass()
+    # skip the read for read header
+    return obj
+
+
+
+
+

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+#coding: utf8
+"""
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:henning.sorensen@risoe.dk
+
+         + (mods for fabio) Jon Wright, ESRF
+marccdimage can read MarCCD and MarMosaic images including header info.
+
+JPW : Use a parser in case of typos (sorry?)
+
+"""
+
+
+# Base this on the tifimage (as Pilatus is tiff with a 
+# tiff header 
+
+from fabio.tifimage import tifimage
+
+
+class pilatusimage(tifimage):
+    """ Read in Pilatus format, also 
+        pilatus images, including header info """
+
+
+    def _readheader(self, infile):
+        """
+        Parser based approach
+        Gets all entries
+        """
+
+        self.header = {}
+
+#        infile = open(infile)
+        hstr = infile.read(4096)
+        # well not very pretty - but seems to find start of 
+        # header information
+        if (hstr.find('# ') == -1):
+            return self.header
+
+        hstr = hstr[hstr.index('# '):]
+        hstr = hstr[:hstr.index('\x00')]
+        hstr = hstr.split('#')
+        go_on = True
+        while go_on:
+            try:
+                hstr.remove('')
+            except Exception:
+                go_on = False
+
+        for line in hstr:
+            line = line[1:line.index('\r\n')]
+            if line.find(':') > -1:
+                dump = line.split(':')
+                self.header[dump[0]] = dump[1]
+            elif line.find('=') > -1:
+                dump = line.split('=')
+                self.header[dump[0]] = dump[1]
+            elif line.find(' ') > -1:
+                i = line.find(' ')
+                self.header[line[:i]] = line[i:]
+            elif line.find(',') > -1:
+                dump = line.split(',')
+                self.header[dump[0]] = dump[1]
+
+        return self.header
+
+
+
+    def _read(self, fname):
+        """
+        inherited from tifimage
+        ... a Pilatus image *is a* tif image
+        just with a header
+        """
+        return tifimage.read(self, fname)

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+#coding: utf8
+"""
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:henning.sorensen@risoe.dk
+
+"""
+
+import numpy, logging
+logger = logging.getLogger("pnmimage")
+from fabioimage import fabioimage
+
+SUBFORMATS = ['P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7']
+
+HEADERITEMS = ['SUBFORMAT', 'DIMENSIONS', 'MAXVAL']
+P7HEADERITEMS = ['WIDTH', 'HEIGHT', 'DEPTH', 'MAXVAL', 'TUPLTYPE', 'ENDHDR']
+
+class pnmimage(fabioimage):
+    def __init__(self, *arg, **kwargs):
+        fabioimage.__init__(self, *arg, **kwargs)
+        fun = getattr(fabioimage, '__init__', lambda x: None)
+        fun(self)
+        self.data = None
+        self.header = {'Subformat':'P5'}
+        self.dim1 = self.dim2 = 0
+        self.m = self.maxval = self.stddev = self.minval = None
+        self.header_keys = self.header.keys()
+        self.bytecode = None
+
+    def _readheader(self, f):
+        #pnm images have a 3-line header but ignore lines starting with '#'
+        #1st line contains the pnm image sub format
+        #2nd line contains the image pixel dimension
+        #3rd line contains the maximum pixel value (at least for grayscale - check this)
+        self.header_keys = ['SUBFORMAT', 'DIMENSIONS', 'MAXVAL']
+
+        l = f.readline().strip()
+        if l not in SUBFORMATS:
+            raise IOError, ('unknown subformat of pnm: %s' % l)
+        else:
+            self.header['SUBFORMAT'] = l
+
+        if self.header['SUBFORMAT'] == 'P7':
+            self.header_keys = P7HEADERITEMS
+            #this one has a special header
+            while 'ENDHDR' not in l:
+                l = f.readline()
+                while(l[0] == '#'): l = f.readline()
+                s = l.lsplit(' ', 1)
+                if s[0] not in P7HEADERITEMS:
+                    raise IOError, ('Illegal pam (netpnm p7) headeritem %s' % s[0])
+                self.header[s[0]] = s[1]
+        else:
+            self.header_keys = HEADERITEMS
+            for k in self.header_keys[1:]:
+                l = f.readline()
+                while(l[0] == '#'): l = f.readline()
+                self.header[k] = l.strip()
+
+        #set the dimensions
+        dims = (self.header['DIMENSIONS'].split())
+        self.dim1, self.dim2 = int(dims[0]), int(dims[1])
+        #figure out how many bytes are used to store the data
+        #case construct here!
+        m = int(self.header['MAXVAL'])
+        if m < 256:
+            self.bytecode = numpy.uint8
+        elif m < 65536:
+            self.bytecode = numpy.uint16
+        elif m < 2147483648L:
+            self.bytecode = numpy.uint32
+            logger.warning('32-bit pixels are not really supported by the netpgm standard')
+        else:
+            raise IOError, 'could not figure out what kind of pixels you have'
+
+    def read(self, fname, frame=None):
+        """
+        try to read PNM images
+        @param fname: name of the file
+        @param frame: not relevant here! PNM is always single framed
+        """
+        self.header = {}
+        self.resetvals()
+        infile = self._open(fname)
+        self._readheader(infile)
+
+        #read the image data
+        decoder_name = "%sdec" % self.header['SUBFORMAT']
+        if decoder_name in dir(pnmimage):
+            decoder = getattr(pnmimage, decoder_name)
+            self.data = decoder(infile, self.bytecode)
+        else:
+            raise IOError("No decoder named %s for file %s" % (decoder_name, fname))
+        self.resetvals()
+        return self
+
+    @staticmethod
+    def P1dec(buf, bytecode):
+        data = numpy.zeros((self.dim2, self.dim1))
+        i = 0
+        for l in buf.readlines():
+            try:
+                data[i, :] = numpy.array(l.split()).astype(bytecode)
+            except ValueError:
+                raise IOError, 'Size spec in pnm-header does not match size of image data field'
+        return data
+
+    @staticmethod
+    def P4dec(buf, bytecode):
+        err = 'single bit (pbm) images are not supported - yet'
+        logger.error(err)
+        raise NotImplementedError(err)
+
+    @staticmethod
+    def P2dec(buf, bytecode):
+        data = numpy.zeros((self.dim2, self.dim1))
+        i = 0
+        for l in buf.readlines():
+            try:
+                data[i, :] = numpy.array(l.split()).astype(bytecode)
+            except ValueError:
+                raise IOError, 'Size spec in pnm-header does not match size of image data field'
+        return data
+
+    @staticmethod
+    def P5dec(buf, bytecode):
+        l = buf.read()
+        try:
+            data = numpy.reshape(numpy.fromstring(l, bytecode), [self.dim2, self.dim1]).byteswap()
+        except ValueError:
+            raise IOError, 'Size spec in pnm-header does not match size of image data field'
+        return data
+
+    @staticmethod
+    def P3dec(buf, bytecode):
+        err = '(plain-ppm) RGB images are not supported - yet'
+        logger.error(err)
+        raise NotImplementedError(err)
+
+    @staticmethod
+    def P6dec(buf, bytecode):
+        err = '(ppm) RGB images are not supported - yet'
+        logger.error(err)
+        raise NotImplementedError(err)
+
+    @staticmethod
+    def P7dec(buf, bytecode):
+        err = '(pam) images are not supported - yet'
+        logger.error(err)
+        raise NotImplementedError(err)
+
+    def write(self, filename):
+        raise NotImplementedError('write pnm images is 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/readbytestream.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+#coding: utf8
+
+"""
+Reads a bytestream
+
+Authors: Jon Wright    Henning O. Sorensen & Erik Knudsen
+         ESRF          Risoe National Laboratory
+"""
+
+import numpy, logging
+logger = logging.getLogger("readbytestream")
+DATATYPES = {
+    # type  sign bytes
+    ("int", 'n', 1) : numpy.uint8,
+    ("int", 'n', 2) : numpy.uint16,
+    ("int", 'n', 4) : numpy.uint32,
+    ("int", 'y', 1) : numpy.int8,
+    ("int", 'y', 2) : numpy.int16,
+    ("int", 'y', 4) : numpy.int32,
+    ('float', 'y', 4) : numpy.float32, # does this occur in bruker?
+    ('double', 'y', 4): numpy.float64
+    }
+
+
+def readbytestream(fil,
+                   offset,
+                   x,
+                   y,
+                   nbytespp,
+                   datatype='int',
+                   signed='n',
+                   swap='n',
+                   typeout=numpy.uint16):
+    """
+    Reads in a bytestream from a file (which may be a string indicating
+    a filename, or an already opened file (should be "rb"))
+    offset is the position (in bytes) where the pixel data start
+    nbytespp = number of bytes per pixel
+    type can be int or float (4 bytes pp) or double (8 bytes pp)
+    signed: normally signed data 'y', but 'n' to try to get back the 
+    right numbers when unsigned data are converted to signed 
+    (python once had no unsigned numeric types.)
+    swap, normally do not bother, but 'y' to swap bytes
+    typeout is the numpy type to output, normally uint16, 
+    but more if overflows occurred
+    x and y are the pixel dimensions
+    
+    TODO : Read in regions of interest
+    
+    PLEASE LEAVE THE STRANGE INTERFACE ALONE - 
+    IT IS USEFUL FOR THE BRUKER FORMAT
+    """
+    tin = "dunno"
+    length = nbytespp * x * y # bytes per pixel times number of pixels
+    if datatype in ['float', 'double']:
+        signed = 'y'
+
+    key = (datatype, signed, nbytespp)
+    try:
+        tin = DATATYPES[key]
+    except:
+        logging.warning("datatype,signed,nbytespp " + str(key))
+        raise Exception("Unknown combination of types to readbytestream")
+
+    # Did we get a string (filename) or a readable stream object?
+    if hasattr(fil, "read") and hasattr(fil, "seek"):
+        infile = fil
+        opened = False
+    else:
+        infile = open(fil, 'rb')
+        opened = True
+
+    infile.seek(offset)
+
+    arr = numpy.array(numpy.reshape(
+            numpy.fromstring(
+                infile.read(length), tin) , (x, y)), typeout)
+
+    if swap == 'y':
+        arr = arr.byteswap()
+
+    if opened:
+        infile.close()
+
+    return arr