fabio 0.1.1__zip

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

@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+#-*- coding: utf8 -*-
+"""
+FabIO class for dealing with TIFF images. 
+In facts wraps TiffIO from Armando (available in PyMca) or falls back to PIL
+
+Authors: Jérôme Kieffer (jerome.kieffer@esrf.fr)
+         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    
+License: GPLv3+        
+"""
+__authors__ = ["Jérôme Kieffer", "Henning O. Sorensen", "Erik Knudsen"]
+__date__ = "11/07/2011"
+__license__ = "GPLv3+"
+__copyright__ = "ESRF, Grenoble & Risoe National Laboratory"
+
+import time, logging, struct
+logger = logging.getLogger("tifimage")
+try:
+    import Image
+except ImportError:
+    logger.warning("PIL is not installed ... trying to do without")
+    Image = None
+import numpy
+from fabioimage import fabioimage
+from TiffIO     import TiffIO
+
+PIL_TO_NUMPY = { "I;16": numpy.uint16,
+                   "F": numpy.float32,
+                   "1": numpy.bool,
+                   "I": numpy.int32,
+                   "L": numpy.uint8,
+                    }
+
+LITTLE_ENDIAN = 1234
+BIG_ENDIAN = 3412
+
+TYPES = {0:'invalid', 1:'byte', 2:'ascii', 3:'short', 4:'long', 5:'rational', 6:'sbyte', 7:'undefined', 8:'sshort', 9:'slong', 10:'srational', 11:'float', 12:'double'}
+
+TYPESIZES = {0:0, 1:1, 2:1, 3:2, 4:4, 5:8, 6:1, 7:1, 8:2, 9:4, 10:8, 11:4, 12:8}
+
+baseline_tiff_tags = {
+  256:'ImageWidth',
+  257:'ImageLength',
+  306:'DateTime',
+  315:'Artist',
+  258:'BitsPerSample',
+  265:'CellLength',
+  264:'CellWidth',
+  259:'Compression',
+
+  262:'PhotometricInterpretation',
+  296:'ResolutionUnit',
+  282:'XResolution',
+  283:'YResolution',
+
+  278:'RowsPerStrip',
+  273:'StripOffset',
+  279:'StripByteCounts',
+
+  270:'ImageDescription',
+  271:'Make',
+  272:'Model',
+  320:'ColorMap',
+  305:'Software',
+  339:'SampleFormat',
+  33432:'Copyright'
+  }
+
+class tifimage(fabioimage):
+    """
+    Images in TIF format
+    Wraps TiffIO
+    """
+    _need_a_seek_to_read = True
+
+    def __init__(self, *args, **kwds):
+        """ Tifimage constructor adds an nbits member attribute """
+        self.nbits = None
+        fabioimage.__init__(self, *args, **kwds)
+        self.lib = None
+
+    def _readheader(self, infile):
+        """
+        Try to read Tiff images header...
+        """
+#        try:
+#            self.header = { "filename" : infile.name }
+#        except AttributeError:
+#            self.header = {}
+#
+#        t = Tiff_header(infile.read())
+#        self.header = t.header
+#        try:
+#            self.dim1 = int(self.header['ImageWidth'])
+#            self.dim2 = int(self.header['ImageLength'])
+#        except (KeyError):
+#            logger.warning("image dimensions could not be determined from header tags, trying to go on anyway")
+#         read the first 32 bytes to determine size
+        header = numpy.fromstring(infile.read(64), numpy.uint16)
+        self.dim1 = int(header[9])
+        self.dim2 = int(header[15])
+#         nbits is not a fabioimage attribute...
+        self.nbits = int(header[21]) # number of bits
+
+    def read(self, fname, frame=None):
+        """
+        Wrapper for TiffIO.
+        """
+        infile = self._open(fname, "rb")
+        self._readheader(infile)
+        infile.seek(0)
+        self.lib = None
+        try:
+            tiffIO = TiffIO(infile)
+            if tiffIO.getNumberOfImages() > 0:
+                #No support for now of multi-frame tiff images
+                self.data = tiffIO.getImage(0)
+                self.header = tiffIO.getInfo(0)
+        except Exception, error:
+            logger.warning("Unable to read %s with TiffIO due to %s, trying PIL" % (fname, error))
+        else:
+            if self.data.ndim == 2:
+                self.dim2, self.dim1 = self.data.shape
+            elif self.data.ndim == 3:
+                self.dim2, self.dim1, ncol = self.data.shape
+                logger.warning("Third dimension is the color")
+            else:
+                logger.warning("dataset has %s dimensions (%s), check for errors !!!!", self.data.ndim, self.data.shape)
+            self.lib = "TiffIO"
+
+        if (self.lib is None):
+            if Image:
+                try:
+                    infile.seek(0)
+                    self.pilimage = Image.open(infile)
+                except Exception:
+                    logger.error("Error in opening %s  with PIL" % fname)
+                    self.lib = None
+                    infile.seek(0)
+                else:
+                    self.lib = "PIL"
+                    self.dim1, self.dim2 = self.pilimage.size
+                    if self.pilimage.mode in PIL_TO_NUMPY:
+                        self.data = numpy.fromstring(self.pilimage.tostring(), PIL_TO_NUMPY[self.pilimage.mode])
+                    else: #probably RGB or RGBA images: rely on PIL to convert it to greyscale float.
+                        self.data = numpy.fromstring(self.pilimage.convert("F").tostring(), numpy.float32)
+                    self.data.shape = (self.dim2, self.dim1)
+            else:
+                logger.error("Error in opening %s: no tiff reader managed to read the file.", fname)
+                self.lib = None
+                infile.seek(0)
+
+        self.bpp = len(numpy.zeros(1, dtype=self.data.dtype).tostring())
+        self.bytecode = self.data.dtype.name
+        self.resetvals()
+        return self
+
+    def write(self, fname):
+        """
+        Overrides the fabioimage.write method and provides a simple TIFF image writer.
+        @param fname: name of the file to save the image to
+        @tag_type fname: string or unicode (file?)...
+        """
+        tiffIO = TiffIO(fname, mode="w")
+        tiffIO.writeImage(self.data, info=self.header, software="fabio.tifimage", date=time.ctime())
+
+
+
+#define a couple of helper classes here:         
+class Tiff_header(object):
+    def __init__(self, string):
+        if string[:4] == "II\x2a\x00":
+            self.byteorder = LITTLE_ENDIAN
+        elif string[:4] == 'MM\x00\x2a':
+            self.byteorder = BIG_ENDIAN
+        else:
+            logger.warning("Warning: This does not appear to be a tiff file")
+        #the next two bytes contains the offset of the oth IFD
+        offset_first_ifd = struct.unpack_from("h", string[4:])[0]
+        self.ifd = [Image_File_Directory()]
+        offset_next = self.ifd[0].unpack(string, offset_first_ifd)
+        while (offset_next != 0):
+            self.ifd.append(Image_File_Directory())
+            offset_next = self.ifd[-1].unpack(string, offset_next)
+
+        self.header = {}
+        #read the values of the header items into a dictionary
+        for entry in self.ifd[0].entries:
+            if entry.tag in baseline_tiff_tags.keys():
+                self.header[baseline_tiff_tags[entry.tag]] = entry.val
+            else:
+                self.header[entry.tag] = entry.val
+
+class Image_File_Directory(object):
+    def __init__(self, instring=None, offset= -1):
+        self.entries = []
+        self.offset = offset
+        self.count = None
+
+    def unpack(self, instring, offset= -1):
+        if (offset == -1): offset = self.offset
+
+        strInput = instring[offset:]
+        self.count = struct.unpack_from("H", strInput[:2])[0]
+        #0th IFD contains count-1 entries (count includes the adress of the next IFD)
+        for i in range(self.count - 1):
+            e = Image_File_Directory_entry().unpack(strInput[2 + 12 * (i + 1):])
+            if (e != None):
+                self.entries.append(e)
+            #extract data associated with tags
+            for e in self.entries:
+                if (e.val == None):
+                    e.extract_data(instring)
+        #do we have some more ifds in this file 
+        offset_next = struct.unpack_from("L", instring[offset + 2 + self.count * 12:])[0]
+        return offset_next
+
+class Image_File_Directory_entry(object):
+    def __init__(self, tag=0, tag_type=0, count=0, offset=0):
+        self.tag = tag
+        self.tag_type = tag_type
+        self.count = count
+        self.val_offset = offset
+        self.val = None
+
+    def unpack(self, strInput):
+        idfentry = strInput[:12]
+################################################################################
+# #        TOFIX: How is it possible that HHL (2+2+4 bytes has a size of )
+################################################################################
+        (tag, tag_type, count) = struct.unpack_from("HHL", idfentry)
+        self.tag = tag
+        self.count = count
+        self.tag_type = tag_type
+        self.val = None
+        if (count <= 0):
+            logger.warning("Tag # %s has an invalid count: %s. Tag is ignored" % (tag, count))
+            return
+        if(count * TYPESIZES[tag_type] <= 4):
+            self.val_offset = 8
+            self.extract_data(idfentry)
+            self.val_offset = None
+        else:
+            self.val_offset = struct.unpack_from("L", idfentry[8:])[0]
+        return self
+
+    def extract_data(self, full_string):
+        tag_type = self.tag_type
+        if (TYPES[tag_type] == 'byte'):
+            self.val = struct.unpack_from("B", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'short'):
+            self.val = struct.unpack_from("H", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'long'):
+            self.val = struct.unpack_from("L", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'sbyte'):
+            self.val = struct.unpack_from("b", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'sshort'):
+            self.val = struct.unpack_from("h", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'slong'):
+            self.val = struct.unpack_from("l", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'ascii'):
+            self.val = full_string[self.val_offset:self.val_offset + max(self.count, 4)]
+        elif (TYPES[tag_type] == 'rational'):
+            if self.val_offset != None:
+                (num, den) = struct.unpack_from("LL", full_string[self.val_offset:])
+                print self.val_offset
+                self.val = float(num) / den
+        elif (TYPES[tag_type] == 'srational'):
+            if self.val_offset != None:
+                (num, den) = struct.unpack_from("ll", full_string[self.val_offset:])
+                self.val = float(num) / den,
+        elif (TYPES[tag_type] == 'float'):
+            self.val = struct.unpack_from("f", full_string[self.val_offset:])[0]
+        elif (TYPES[tag_type] == 'double'):
+            if  self.val_offset != None:
+                self.val = struct.unpack_from("d", full_string[self.val_offset:])[0]
+        else:
+            logger.warning("unrecognized type of strInputentry self: %s tag: %s type: %s TYPE: %s" % (self, baseline_tiff_tags[self.tag], self.tag_type, TYPES[tag_type]))

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

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# coding: utf8
+"""
+Authors: Jérôme Kieffer, ESRF 
+         email:jerome.kieffer@esrf.fr
+
+XSDimge are XML files containing numpy arrays 
+"""
+__author__ = "Jérôme Kieffer"
+__contact__ = "jerome.kieffer@esrf.eu"
+__license__ = "GPLv3+"
+__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
+
+import logging, numpy
+logger = logging.getLogger("xsdimage")
+from fabioimage import fabioimage
+import base64, hashlib
+try:
+    from lxml import etree
+except ImportError:
+    logger.warning("lxml library is probably not part of your python installation: disabling xsdimage format")
+    etree = None
+
+class xsdimage(fabioimage):
+    """ 
+    Read the XSDataImage XML File data format 
+    """
+    def __init__(self, data=None, header=None, fname=None):
+        """
+        Constructor of the class XSDataImage.
+
+        @param _strFilename: the name of the file to open
+        @type  _strFilename: string
+        """
+        fabioimage.__init__(self, data=data, header=header)
+        self.dims = []
+        self.size = None
+        self.coding = None
+        self.dtype = None
+        self.rawData = None
+        self.md5 = None
+        if fname is not None:
+            self.filename = fname
+            self.read(fname)
+
+    def read(self, fname, frame=None):
+        """
+        """
+        self.header = {}
+        self.resetvals()
+        self.filename = fname
+        infile = self._open(fname, "rb")
+        self._readheader(infile)
+
+        try:
+            self.dim1, self.dim2 = self.dims[:2]
+        except:
+            raise IOError("XSD file %s is corrupt, no dimensions in it" % fname)
+        try:
+            self.bytecode = numpy.dtype(self.dtype).type
+            self.bpp = len(numpy.array(0, self.bytecode).tostring())
+        except TypeError:
+            self.bytecode = numpy.int32
+            self.bpp = 32
+            logger.warning("Defaulting type to int32")
+
+        exp_size = 1
+        for i in self.dims:
+            exp_size *= i
+        assert exp_size == self.size
+
+        decData = None
+        if self.coding == "base64":
+            decData = base64.b64decode(self.rawData)
+        elif self.coding == "base32":
+            decData = base64.b32decode(self.rawData)
+        elif self.coding == "base16":
+            decData = base64.b16decode(self.rawData)
+        else:
+            logger.warning("Unable to recognize the encoding of the data !!! got %s, expected base64, base32 or base16, I assume it is base64 " % self.coding)
+            decData = base64.b64decode(self.rawData)
+        if self.md5:
+            assert  hashlib.md5(decData).hexdigest() == self.md5
+
+
+        self.data = numpy.fromstring(decData, dtype=self.bytecode).reshape(tuple(self.dims))
+        if not numpy.little_endian: #by default little endian
+            self.data.byteswap(inplace=True)
+        self.resetvals()
+#        # ensure the PIL image is reset
+        self.pilimage = None
+        return self
+
+    def _readheader(self, infile):
+        """
+        Read all headers in a file and populate self.header
+        data is not yet populated
+        @type infile: file object open in read mode
+        """
+        xml = etree.parse(infile)
+        self.dims = []
+        for i in xml.xpath("//shape"):
+            try:
+                self.dims.append(int(i.text))
+            except ValueError, error:
+                logger.warning("%s Shape: Unable to convert %s to integer in %s" % (error, i.text, i))
+        for i in xml.xpath("//size"):
+            try:
+                self.size = int(i.text)
+            except Exception, error:#IGNORE:W0703
+                logger.warning("%s Size: Unable to convert %s to integer in %s" % (error, i.text, i))
+        self.dtype = None
+        for i in xml.xpath("//dtype"):
+            self.dtype = i.text
+        self.coding = None
+        for i in xml.xpath("//coding"):
+            j = i.find("value")
+            if j is not None:
+                self.coding = j.text
+        self.rawData = None
+        for i in xml.xpath("//data"):
+            self.rawData = i.text
+        self.md5 = None
+        for i in xml.xpath("//md5sum"):
+            j = i.find("value")
+            if j is not None:
+                self.md5 = j.text
+
+if etree is None:
+    xsdimage = None
+
+
+
+

Library/Python/2.7/site-packages/fabio-0.1.1-py2.7.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: fabio
+Version: 0.1.1
+Summary: Image IO for fable
+Home-page: http://fable.wiki.sourceforge.net/fabio
+Author: Henning Sorensen, Erik Knudsen, Jon Wright, Regis Perdreau, Jérôme Kieffer and Gael Goret
+Author-email: fable-talk@lists.sourceforge.net
+License: UNKNOWN
+Download-URL: http://sourceforge.net/projects/fable/files/fabio/0.0.9
+Description: UNKNOWN
+Platform: UNKNOWN

Library/Python/2.7/site-packages/fabio-0.1.1-py2.7.egg-info/SOURCES.txt

@@ -0,0 +1,114 @@
+.gitignore
+MANIFEST.in
+README.TXT
+build-deb.sh
+setup.py
+stdeb.cfg
+debian-orig/changelog
+debian-orig/compat
+debian-orig/control
+debian-orig/copyright
+debian-orig/rules
+debian-orig/watch
+debian-orig/source/format
+fabio-src/GEimage.py
+fabio-src/GEimage_old.py
+fabio-src/HiPiCimage.py
+fabio-src/OXDimage.py
+fabio-src/TiffIO.py
+fabio-src/__init__.py
+fabio-src/adscimage.py
+fabio-src/binaryimage.py
+fabio-src/bruker100image.py
+fabio-src/brukerimage.py
+fabio-src/cbfimage.py
+fabio-src/compression.py
+fabio-src/converters.py
+fabio-src/datIO.py
+fabio-src/dm3image.py
+fabio-src/edfimage.py
+fabio-src/fabioimage.py
+fabio-src/fabioutils.py
+fabio-src/file_series.py
+fabio-src/fit2dmaskimage.py
+fabio-src/fit2dspreadsheetimage.py
+fabio-src/kcdimage.py
+fabio-src/mar345image.py
+fabio-src/marccdimage.py
+fabio-src/openimage.py
+fabio-src/pilatusimage.py
+fabio-src/pnmimage.py
+fabio-src/readbytestream.py
+fabio-src/tifimage.py
+fabio-src/xsdimage.py
+src/byte_offset.c
+src/byte_offset.html
+src/byte_offset.pyx
+src/ccp4_pack.c
+src/ccp4_pack.h
+src/cf_iomodule.c
+src/columnfile.c
+src/columnfile.h
+src/mar345_IO.c
+src/mar345_IO.html
+src/mar345_IO.pyx
+src/pack_c.c
+src/pack_c.h
+src/setup.py
+src/stdint.h
+test/__init__.py
+test/benchheader.py
+test/coral31_benchheaders
+test/coral31_benchmark
+test/eeepc-jonathanw_benchheaders
+test/eeepc-jonathanw_benchmark
+test/esrflinux1-1a_benchheaders
+test/esrflinux1-1a_benchmark
+test/get_test_images.sh
+test/lapwright_benchheaders
+test/lapwright_benchmark
+test/lintaillefer_benchHeaders
+test/profile_compressed.py
+test/testGEimage.py
+test/testOXDimage.py
+test/testXSDimage.py
+test/test_all.bat
+test/test_all.py
+test/test_all.sh
+test/test_all_images.py
+test/test_file_series.py
+test/test_filename_steps.py
+test/test_flat_binary.py
+test/testadscimage.py
+test/testbrukerimage.py
+test/testcbfimage.py
+test/testcompression.py
+test/testedfimage.py
+test/testfabioimage.py
+test/testfilenames.py
+test/testfit2dmaskimage.py
+test/testheadernotsingleton.py
+test/testkcdimage.py
+test/testmar345image.py
+test/testmccdimage.py
+test/testopenheader.py
+test/testopenimage.py
+test/testtifgz.py
+test/testtifimage.py
+test/utilstest.py
+test/win32_benchheaders
+test/win32_benchmark
+test/profile/benchheader.py
+test/profile/coral31_benchheaders
+test/profile/coral31_benchmark
+test/profile/eeepc-jonathanw_benchheaders
+test/profile/eeepc-jonathanw_benchmark
+test/profile/esrflinux1-1a_benchheaders
+test/profile/esrflinux1-1a_benchmark
+test/profile/get_test_images.sh
+test/profile/lapwright_benchheaders
+test/profile/lapwright_benchmark
+test/profile/lintaillefer_benchHeaders
+test/profile/profile_compressed.py
+test/profile/win32_benchheaders
+test/profile/win32_benchmark

Library/Python/2.7/site-packages/fabio-0.1.1-py2.7.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Library/Python/2.7/site-packages/fabio-0.1.1-py2.7.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+mar345_IO
+fabio
+byte_offset
+cf_io