fabio 0.1.1__zip

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

@@ -0,0 +1,10 @@
+version = "0.1.1"
+import logging
+logging.basicConfig()
+import fabioimage
+import openimage
+from fabioutils import filename_object, COMPRESSORS, jump_filename, \
+        previous_filename, next_filename, deconstruct_filename, \
+        extract_filenumber, getnum, construct_filename
+from openimage import openimage as open
+from openimage import openheader as openheader

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

@@ -0,0 +1,137 @@
+#!/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:erik.knudsen@risoe.dk
+
++ mods for fabio by JPW
+
+"""
+
+import numpy, logging
+from fabioimage import fabioimage
+logger = logging.getLogger("adscimage")
+
+class adscimage(fabioimage):
+    """ Read an image in ADSC format (quite similar to edf?) """
+    def __init__(self, *args, **kwargs):
+        fabioimage.__init__(self, *args, **kwargs)
+
+    def read(self, fname, frame=None):
+        """ read in the file """
+        infile = self._open(fname, "rb")
+        try:
+            self._readheader(infile)
+        except:
+            raise Exception("Error processing adsc header")
+        # banned by bzip/gzip???
+        try:
+            infile.seek(int(self.header['HEADER_BYTES']), 0)
+        except TypeError:
+            # Gzipped does not allow a seek and read header is not
+            # promising to stop in the right place
+            infile.close()
+            infile = self._open(fname, "rb")
+            infile.read(int(self.header['HEADER_BYTES']))
+        binary = infile.read()
+        infile.close()
+
+        #now read the data into the array
+        self.dim1 = int(self.header['SIZE1'])
+        self.dim2 = int(self.header['SIZE2'])
+        if 'little' in self.header['BYTE_ORDER']:
+            try:
+                self.data = numpy.reshape(
+                    numpy.fromstring(binary, numpy.uint16),
+                    (self.dim2, self.dim1))
+            except ValueError:
+                raise IOError, 'Size spec in ADSC-header does not match ' + \
+                    'size of image data field'
+            self.bytecode = numpy.uint16
+            logger.info("adscimage read in using low byte first (x386-order)")
+        else:
+            try:
+                self.data = numpy.reshape(
+                    numpy.fromstring(binary, numpy.uint16),
+                    (self.dim2, self.dim1)).byteswap()
+            except ValueError:
+                raise IOError, 'Size spec in ADSC-header does not match ' + \
+                    'size of image data field'
+            self.bytecode = numpy.uint16
+            logger.info('adscimage using high byte first (network order)')
+        self.resetvals()
+        return self
+
+
+    def _readheader(self, infile):
+        """ read an adsc header """
+        line = infile.readline()
+        bytesread = len(line)
+        while '}' not in line:
+            if '=' in line:
+                (key, val) = line.split('=')
+                self.header_keys.append(key.strip())
+                self.header[key.strip()] = val.strip(' ;\n')
+            line = infile.readline()
+            bytesread = bytesread + len(line)
+
+
+    def write(self, fname):
+        """
+        Write adsc format
+        """
+        out = '{\n'
+        for key in self.header_keys:
+            out += "%s = %s;\n" % (key, self.header[key])
+        # FIXME ??? - made padding match header bytes keyword            
+        #        the cbflib example image has exactly 512...
+        if self.header.has_key("HEADER_BYTES"):
+            pad = int(self.header["HEADER_BYTES"]) - len(out) - 2
+        else:
+            # integer division
+            # 1234567890123456789012
+            # HEADER_BYTES = 1234;\n
+            hsize = ((len(out) + 23) / 512 + 1) * 512
+            out += "HEADER_BYTES=%d;\n" % (hsize)
+            pad = hsize - len(out) - 2
+        out += pad * ' ' + "}\n"
+        assert len(out) % 512 == 0 , "Header is not multiple of 512"
+        outf = open(fname, "wb")
+        outf.write(out)
+        # it says "unsigned_short" ? ... jpw example has:
+        # BYTE_ORDER=big_endian;
+        # TYPE=unsigned_short;
+        if "little" in self.header["BYTE_ORDER"]:
+            outf.write(self.data.astype(numpy.uint16).tostring())
+        else:
+            outf.write(self.data.byteswap().astype(
+                    numpy.uint16).tostring())
+        outf.close()
+
+
+def test():
+    """ testcase """
+    import sys, time
+    img = adscimage()
+    begin = time.clock()
+    while (sys.argv[1:]):
+        img.read(sys.argv[1])
+#        rim = img.toPIL16()
+        img.rebin(2, 2)
+        img.write('jegErEnFil0000.img')
+        print sys.argv[1] + ": max=%d, min=%d, mean=%.2e, stddev=%.2e" % (\
+              img.getmax(), img.getmin(), img.getmean(), img.getstddev())
+        print 'integrated intensity (%d %d %d %d) =%.3f' % (\
+              10, 20, 20, 40, img.integrate_area((10, 20, 20, 40)))
+        sys.argv[1:] = sys.argv[2:]
+    end = time.clock()
+    print end - begin
+
+
+if __name__ == '__main__':
+    test()

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

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+#coding: utf8 
+from __future__ import with_statement
+__doc__ = """
+Authors: Gael Goret, Jerome Kieffer, ESRF, France
+Emails: gael.goret@esrf.fr, jerome.kieffer@esrf.fr
+
+Binary files images are simple none-compressed 2D images only defined by their : 
+data-type, dimensions, byte order and offset
+
+This simple library has been made for manipulating exotic/unknown files format.  
+"""
+
+__authors__ = ["Gaël Goret", "Jérôme Kieffer"]
+__contact__ = "gael.goret@esrf.fr"#, jerome.kieffer@esrf.eu"
+__license__ = "GPLv3+"
+__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
+__version__ = "17 Apr 2012"
+
+from fabioimage import fabioimage
+import numpy, logging
+logger = logging.getLogger("binaryimage")
+
+class binaryimage(fabioimage):
+    """
+    This simple library has been made for manipulating exotic/unknown files format.
+    
+    Binary files images are simple none-compressed 2D images only defined by their : 
+    data-type, dimensions, byte order and offset
+    """
+
+    def __init__(self, *args, **kwargs):
+        fabioimage.__init__(self, *args, **kwargs)
+
+    @staticmethod
+    def swap_needed(endian):
+        """
+        Decide if we need to byteswap
+        """
+        if (endian == '<' and numpy.little_endian) or (endian == '>' and not numpy.little_endian):
+            return False
+        if (endian == '>' and numpy.little_endian) or (endian == '<' and not numpy.little_endian):
+            return True
+
+    def read(self, fname, dim1, dim2, offset=0, bytecode="int32", endian="<"):
+        """ 
+        Read a binary image
+        Parameters : fname, dim1, dim2, offset, bytecode, endian
+        fname : file name : str
+        dim1,dim2 : image dimensions : int
+        offset : size of the : int 
+        bytecode among : "int8","int16","int32","int64","uint8","uint16","uint32","uint64","float32","float64",...
+        endian among short or long endian ("<" or ">")
+        """
+        self.filename = fname
+        self.dim1 = dim1
+        self.dim2 = dim2
+        self.bytecode = bytecode
+        f = open(self.filename, "rb")
+        dims = [dim2, dim1]
+        bpp = len(numpy.array(0, bytecode).tostring())
+        size = dims[0] * dims[1] * bpp
+
+        f.seek(offset)
+        rawData = f.read(size)
+        if  self.swap_needed(endian):
+            data = numpy.fromstring(rawData, bytecode).byteswap().reshape(tuple(dims))
+        else:
+            data = numpy.fromstring(rawData, bytecode).reshape(tuple(dims))
+        self.data = data
+        return self
+
+    def estimate_offset_value(self, fname, dim1, dim2, bytecode="int32"):
+        "Estimates the size of a file"
+        with open(fname, "rb") as f:
+            bpp = len(numpy.array(0, bytecode).tostring())
+            size = dim1 * dim2 * bpp
+            totsize = len(f.read())
+        logger.info('total size (bytes): %s', totsize)
+        logger.info('expected data size given parameters (bytes): %s', size)
+        logger.info('estimation of the offset value (bytes): %s', totsize - size)
+
+    def write(self, fname):
+        with open(fname, mode="wb") as outfile:
+            outfile.write(self.data.tostring())
+
+

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

@@ -0,0 +1,96 @@
+import numpy
+import math
+import logging
+logger = logging.getLogger("bruker100image")
+try:
+    import Image
+except ImportError:
+    logger.warning("PIL is not installed ... trying to do without")
+    Image = None
+
+from brukerimage import brukerimage
+from readbytestream import readbytestream 
+
+class bruker100image(brukerimage):
+
+
+    def toPIL16(self, filename=None):
+        if not Image:
+            raise RuntimeError("PIL is not installed !!! ")
+
+        if filename:
+            self.read(filename)
+        PILimage = Image.frombuffer("F",
+                                        (self.dim1, self.dim2),
+                                        self.data,
+                                        "raw",
+                                        "F;16", 0, -1)
+        return PILimage
+
+    def read(self, fname, frame=None):
+        f = open(fname, "rb")
+        try:
+            self._readheader(f)
+        except:
+            raise
+
+        rows = int(self.header['NROWS'])
+        cols = int(self.header['NCOLS'])
+        npixelb = int(self.header['NPIXELB'][0])
+        # you had to read the Bruker docs to know this!
+
+        # We are now at the start of the image - assuming 
+        #   readbrukerheader worked
+        # size = rows * cols * npixelb
+        self.data = readbytestream(f, f.tell(), rows, cols, npixelb,
+                                    datatype="int", signed='n', swap='n')
+
+        noverfl = self.header['NOVERFL'].split() # now process the overflows
+        #read the set of "underflow pixels" - these will be completely 
+        # disregarded for now
+        data = self.data
+        k = 0
+
+        while k < 2:#for the time being things - are done in 16 bits
+            datatype = {'1' : numpy.uint8,
+                        '2' : numpy.uint16,
+                        '4' : numpy.uint32 }[("%d" % 2 ** k)]
+            ar = numpy.array(numpy.fromstring(f.read(int(noverfl[k]) * (2 ** k)),
+                                        datatype), numpy.uint16)
+            #insert the the overflow pixels in the image array:
+            #this is probably a memory intensive way of doing this - 
+            # might be done in a more clever way
+            lim = 2 ** (8 * k) - 1
+            #generate an array comprising of the indices into data.ravel() 
+            # where its value equals lim.
+            M = numpy.compress(numpy.equal(data.ravel(), lim), numpy.arange(rows * cols))
+            #now put values from ar into those indices
+            numpy.put(data.ravel(), M, ar)
+            padding = 16 * int(math.ceil(int(noverfl[k]) * (2 ** k) / 16.)) - \
+                         int(noverfl[k]) * (2 ** k)
+            f.seek(padding, 1)
+            print noverfl[k] + " bytes read + %d bytes padding" % padding
+            k = k + 1
+
+        f.close()
+
+        (self.dim1, self.dim2) = (rows, cols)
+        print self.dim1, self.dim2
+        self.resetvals()
+        return self
+
+if __name__ == '__main__':
+    import sys, time
+    I = bruker100image()
+    b = time.clock()
+    while (sys.argv[1:]):
+        I.read(sys.argv[1])
+        r = I.toPIL16()
+        I.rebin(2, 2)
+        print sys.argv[1] + (": max=%d, min=%d, mean=%.2e, stddev=%.2e") % (
+            I.getmax(), I.getmin(), I.getmean(), I.getstddev())
+        print 'integrated intensity (%d %d %d %d) =%.3f' % (
+            10, 20, 20, 40, I.integrate_area((10, 20, 20, 40)))
+        sys.argv[1:] = sys.argv[2:]
+    e = time.clock()
+    print (e - b)

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

@@ -0,0 +1,195 @@
+#!/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
+
+Based on: openbruker,readbruker, readbrukerheader functions in the opendata
+         module of ImageD11 written by Jon Wright, ESRF, Grenoble, France
+
+"""
+
+import numpy, logging
+logger = logging.getLogger("brukerimage")
+from fabioimage import fabioimage
+from readbytestream import readbytestream
+
+
+class brukerimage(fabioimage):
+    """
+    Read and eventually write ID11 bruker (eg smart6500) images
+    """
+
+    # needed if you feel like writing - see ImageD11/scripts/edf2bruker.py
+
+    __headerstring__ = ""
+
+
+    def _readheader(self, infile):
+        """
+        the bruker format uses 80 char lines in key : value format
+        In the fisrt 512*5 bytes of the header there should be a 
+        HDRBLKS key, whose value denotes how many 512 byte blocks 
+        are in the total header. The header is always n*5*512 bytes,
+        otherwise it wont contain whole key: value pairs
+        """
+        lump = infile.read(512 * 5)
+        self.__headerstring__ += lump
+        i = 80
+        self.header = {}
+        while i < 512 * 5:
+            if lump[i - 80: i].find(":") > 0:
+                key, val = lump[i - 80: i].split(":", 1)
+                key = key.strip()         # remove the whitespace (why?)
+                val = val.strip()
+                if self.header.has_key(key):
+                    # append lines if key already there
+                    self.header[key] = self.header[key] + '\n' + val
+                else:
+                    self.header[key] = val
+                    self.header_keys.append(key)
+            i = i + 80                  # next 80 characters
+        # we must have read this in the first 512 bytes.
+        nhdrblks = int(self.header['HDRBLKS'])
+        # Now read in the rest of the header blocks, appending 
+        rest = infile.read(512 * (nhdrblks - 5))
+        self.__headerstring__ += rest
+        lump = lump[i - 80: 512] + rest
+        i = 80
+        j = 512 * nhdrblks
+        while i < j :
+            if lump[i - 80: i].find(":") > 0: # as for first 512 bytes of header
+                key, val = lump[i - 80: i].split(":", 1)
+                key = key.strip()
+                val = val.strip()
+                if self.header.has_key(key):
+                    self.header[key] = self.header[key] + '\n' + val
+                else:
+                    self.header[key] = val
+                    self.header_keys.append(key)
+            i = i + 80
+        # make a (new) header item called "datastart"
+        self.header['datastart'] = infile.tell()
+        #set the image dimensions
+        self.dim1 = int(self.header['NROWS'])
+        self.dim2 = int(self.header['NCOLS'])
+
+    def read(self, fname, frame=None):
+        """
+        Read in and unpack the pixels (including overflow table
+        """
+        infile = self._open(fname, "rb")
+        try:
+            self._readheader(infile)
+        except:
+            raise
+
+        rows = self.dim1
+        cols = self.dim2
+
+        try:
+            # you had to read the Bruker docs to know this!
+            npixelb = int(self.header['NPIXELB'])
+        except:
+            errmsg = "length " + str(len(self.header['NPIXELB'])) + "\n"
+            for byt in self.header['NPIXELB']:
+                errmsg += "char: " + str(byt) + " " + str(ord(byt)) + "\n"
+            logger.warning(errmsg)
+            raise
+
+        self.data = readbytestream(infile, infile.tell(),
+                                   rows, cols, npixelb,
+                                   datatype="int",
+                                   signed='n',
+                                   swap='n')
+
+        #handle overflows
+        nov = int(self.header['NOVERFL'])
+        if nov > 0:   # Read in the overflows
+            # need at least int32 sized data I guess - can reach 2^21
+            self.data = self.data.astype(numpy.uint32)
+            # 16 character overflows:
+            #      9 characters of intensity
+            #      7 character position
+            for i in range(nov):
+                ovfl = infile.read(16)
+                intensity = int(ovfl[0: 9])
+                position = int(ovfl[9: 16])
+                # relies on python style modulo being always +
+                row = position % rows
+                # relies on truncation down
+                col = position / rows
+                #print "Overflow ", r, c, intensity, position,\
+                #    self.data[r,c],self.data[c,r]
+                self.data[col, row] = intensity
+        infile.close()
+
+        self.resetvals()
+        self.pilimage = None
+        return self
+
+
+    def write(self, fname):
+        """
+        Writes the image as EDF
+        FIXME - this should call edfimage.write if that is wanted?
+        eg:     obj = edfimage(data = self.data, header = self.header)
+                obj.write(fname)
+                or maybe something like: edfimage.write(self, fname)
+        """
+        logger.warning("***warning***: call to unifinished " + \
+                "brukerimage.write. This will write the file" + \
+                            fname + "as an edf-file")
+
+
+        outfile = self._open(fname, "wb")
+        outfile.write('{\n')
+        i = 4
+        for k in self.header_keys:
+            out = (("%s = %s;\n") % (k, self.header[k]))
+            i = i + len(out)
+            outfile.write(out)
+        out = (4096 - i) * ' '
+        outfile.write(out)
+        outfile.write('}\n')
+        # Assumes a short-circuiting if / or ...
+        if not self.header.has_key("ByteOrder") or \
+               self.header["ByteOrder"] == "LowByteFirst":
+            outfile.write(self.data.astype(numpy.uint16).tostring())
+        else:
+            outfile.write(self.data.byteswap().astype(
+                    numpy.uint16).tostring())
+        outfile.close()
+
+    def write2(self, fname):
+        """ FIXME: what is this? """
+        pass
+
+
+
+def test():
+    """ a testcase """
+    import sys, time
+    img = brukerimage()
+    start = time.clock()
+    for filename in sys.argv[1:]:
+        img.read(filename)
+        res = img.toPIL16()
+        img.rebin(2, 2)
+        print filename + (": max=%d, min=%d, mean=%.2e, stddev=%.2e") % (
+            img.getmax(), img.getmin(), img.getmean(), img.getstddev())
+        print 'integrated intensity (%d %d %d %d) =%.3f' % (
+            10, 20, 20, 40, img.integrate_area((10, 20, 20, 40)))
+    end = time.clock()
+    print (end - start)
+
+
+
+if __name__ == '__main__':
+    test()
+
+