fabio 0.1.1__zip

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

@@ -0,0 +1,1197 @@
+#/*##########################################################################
+# Copyright (C) 2012 European Synchrotron Radiation Facility
+#
+# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
+# the ESRF by the Software group.
+#
+# This file is free software; you can redistribute it and/or modify it 
+# under the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option) 
+# any later version.
+#
+# PyMca 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 Lesser General Public License for more
+# details.
+#
+#############################################################################*/
+__author__ = "V.A. Sole - ESRF Data Analysis"
+__revision__ = 1501
+
+import sys
+import os
+import struct
+import numpy
+
+DEBUG = 0
+ALLOW_MULTIPLE_STRIPS = False
+
+TAG_ID = { 256:"NumberOfColumns", # S or L ImageWidth
+            257:"NumberOfRows", # S or L ImageHeight
+            258:"BitsPerSample", # S Number of bits per component
+            259:"Compression", # SHORT (1 - NoCompression, ... 
+            262:"PhotometricInterpretation", # SHORT (0 - WhiteIsZero, 1 -BlackIsZero, 2 - RGB, 3 - Palette color
+            270:"ImageDescription", # ASCII
+            273:"StripOffsets", # S or L, for each strip, the byte offset of the strip
+            278:"RowsPerStrip", # S or L, number of rows in each back may be not for the last
+            279:"StripByteCounts", # S or L, The number of bytes in the strip AFTER any compression
+            305:"Software", # ASCII
+            306:"Date", # ASCII
+            320:"Colormap", # Colormap of Palette-color Images 
+            339:"SampleFormat", # SHORT Interpretation of data in each pixel
+            }
+
+#TILES ARE TO BE SUPPORTED TOO ...
+TAG_NUMBER_OF_COLUMNS = 256
+TAG_NUMBER_OF_ROWS = 257
+TAG_BITS_PER_SAMPLE = 258
+TAG_PHOTOMETRIC_INTERPRETATION = 262
+TAG_COMPRESSION = 259
+TAG_IMAGE_DESCRIPTION = 270
+TAG_STRIP_OFFSETS = 273
+TAG_ROWS_PER_STRIP = 278
+TAG_STRIP_BYTE_COUNTS = 279
+TAG_SOFTWARE = 305
+TAG_DATE = 306
+TAG_COLORMAP = 320
+TAG_SAMPLE_FORMAT = 339
+
+FIELD_TYPE = {1:('BYTE', "B"),
+               2:('ASCII', "s"), #string ending with binary zero
+               3:('SHORT', "H"),
+               4:('LONG', "I"),
+               5:('RATIONAL', "II"),
+               6:('SBYTE', "b"),
+               7:('UNDEFINED', "B"),
+               8:('SSHORT', "h"),
+               9:('SLONG', "i"),
+               10:('SRATIONAL', "ii"),
+               11:('FLOAT', "f"),
+               12:('DOUBLE', "d")}
+
+FIELD_TYPE_OUT = { 'B':   1,
+                   's':   2,
+                   'H':   3,
+                   'I':   4,
+                   'II':  5,
+                   'b':   6,
+                   'h':   8,
+                   'i':   9,
+                   'ii': 10,
+                   'f':  11,
+                   'd':  12}
+
+#sample formats (http://www.awaresystems.be/imaging/tiff/tiffflags/sampleformat.html)
+SAMPLE_FORMAT_UINT = 1
+SAMPLE_FORMAT_INT = 2
+SAMPLE_FORMAT_FLOAT = 3   #floating point
+SAMPLE_FORMAT_VOID = 4   #undefined data, usually assumed UINT
+SAMPLE_FORMAT_COMPLEXINT = 5
+SAMPLE_FORMAT_COMPLEXIEEEFP = 6
+
+
+
+class TiffIO(object):
+    def __init__(self, filename, mode=None, cache_length=20, mono_output=False):
+        if mode is None:
+            mode = 'rb'
+        if 'b' not in mode:
+            mode = mode + 'b'
+        if 'a' in mode.lower():
+            raise IOError("Mode %s makes no sense on TIFF files. Consider 'rb+'" % mode)
+        if ('w' in mode):
+            if '+' not in mode:
+                mode += '+'
+        #if isinstance(filename, file): #does not work in python 3
+        if hasattr(filename, "seek"):
+            fd = filename
+            self._access = None
+        else:
+            #the b is needed for windows and python 3
+            fd = open(filename, mode)
+            self._access = mode
+
+        self._initInternalVariables(fd)
+        self._maxImageCacheLength = cache_length
+        self._forceMonoOutput = mono_output
+
+    def _initInternalVariables(self, fd=None):
+        if fd is None:
+            fd = self.fd
+        else:
+            self.fd = fd
+        # read the order
+        fd.seek(0)
+        order = fd.read(2).decode()
+        if len(order):
+            if order == "II":
+                #intel, little endian
+                fileOrder = "little"
+                self._structChar = '<'
+            elif order == "MM":
+                #motorola, high endian
+                fileOrder = "big"
+                self._structChar = '>'
+            else:
+                raise IOError("File is not a Mar CCD file, nor a TIFF file")
+            a = fd.read(2)
+            fortyTwo = struct.unpack(self._structChar + "H", a)[0]
+            if fortyTwo != 42:
+                raise IOError("Invalid TIFF version %d" % fortyTwo)
+            else:
+                if DEBUG:
+                    print("VALID TIFF VERSION")
+            if sys.byteorder != fileOrder:
+                swap = True
+            else:
+                swap = False
+        else:
+            if sys.byteorder == "little":
+                self._structChar = '<'
+            else:
+                self._structChar = '>'
+            swap = False
+        self._swap = swap
+        self._IFD = []
+        self._imageDataCacheIndex = []
+        self._imageDataCache = []
+        self._imageInfoCacheIndex = []
+        self._imageInfoCache = []
+        self.getImageFileDirectories(fd)
+
+    def __makeSureFileIsOpen(self):
+        if not self.fd.closed:
+            return
+        if DEBUG:
+            print("Reopening closed file")
+        fileName = self.fd.name
+        if self._access is None:
+            #we do not own the file
+            #open in read mode
+            newFile = open(fileName, 'rb')
+        else:
+            newFile = open(fileName, self._access)
+        self.fd = newFile
+
+    def __makeSureFileIsClosed(self):
+        if self._access is None:
+            #we do not own the file
+            if DEBUG:
+                print("Not closing not owned file")
+            return
+
+        if not self.fd.closed:
+            self.fd.close()
+
+    def getNumberOfImages(self):
+        #update for the case someone has done anything?
+        self._updateIFD()
+        return len(self._IFD)
+
+    def _updateIFD(self):
+        self.__makeSureFileIsOpen()
+        self.getImageFileDirectories()
+        self.__makeSureFileIsClosed()
+
+    def getImageFileDirectories(self, fd=None):
+        if fd is None:
+            fd = self.fd
+        else:
+            self.fd = fd
+        st = self._structChar
+        fd.seek(4)
+        self._IFD = []
+        nImages = 0
+        fmt = st + 'I'
+        inStr = fd.read(struct.calcsize(fmt))
+        if not len(inStr):
+            offsetToIFD = 0
+        else:
+            offsetToIFD = struct.unpack(fmt, inStr)[0]
+        if DEBUG:
+            print("Offset to first IFD = %d" % offsetToIFD)
+        while offsetToIFD != 0:
+            self._IFD.append(offsetToIFD)
+            nImages += 1
+            fd.seek(offsetToIFD)
+            fmt = st + 'H'
+            numberOfDirectoryEntries = struct.unpack(fmt, fd.read(struct.calcsize(fmt)))[0]
+            if DEBUG:
+                print("Number of directory entries = %d" % numberOfDirectoryEntries)
+
+            fmt = st + 'I'
+            fd.seek(offsetToIFD + 2 + 12 * numberOfDirectoryEntries)
+            offsetToIFD = struct.unpack(fmt, fd.read(struct.calcsize(fmt)))[0]
+            if DEBUG:
+                print("Next Offset to IFD = %d" % offsetToIFD)
+            #offsetToIFD = 0 
+        if DEBUG:
+            print("Number of images found = %d" % nImages)
+        return nImages
+
+    def _parseImageFileDirectory(self, nImage):
+        offsetToIFD = self._IFD[nImage]
+        st = self._structChar
+        fd = self.fd
+        fd.seek(offsetToIFD)
+        fmt = st + 'H'
+        numberOfDirectoryEntries = struct.unpack(fmt, fd.read(struct.calcsize(fmt)))[0]
+        if DEBUG:
+            print("Number of directory entries = %d" % numberOfDirectoryEntries)
+
+        fmt = st + 'HHI4s'
+        tagIDList = []
+        fieldTypeList = []
+        nValuesList = []
+        valueOffsetList = []
+        for i in range(numberOfDirectoryEntries):
+            tagID, fieldType, nValues, valueOffset = struct.unpack(fmt, fd.read(12))
+            tagIDList.append(tagID)
+            fieldTypeList.append(fieldType)
+            nValuesList.append(nValues)
+            if nValues == 1:
+                ftype, vfmt = FIELD_TYPE[fieldType]
+                if ftype not in ['ASCII', 'RATIONAL', 'SRATIONAL']:
+                    vfmt = st + vfmt
+                    actualValue = struct.unpack(vfmt, valueOffset[0: struct.calcsize(vfmt)])[0]
+                    valueOffsetList.append(actualValue)
+                else:
+                    valueOffsetList.append(valueOffset)
+            elif (nValues < 5) and (fieldType == 2):
+                ftype, vfmt = FIELD_TYPE[fieldType]
+                vfmt = st + "%d%s" % (nValues, vfmt)
+                actualValue = struct.unpack(vfmt, valueOffset[0: struct.calcsize(vfmt)])[0]
+                valueOffsetList.append(actualValue)
+            else:
+                valueOffsetList.append(valueOffset)
+            if DEBUG:
+                if tagID in TAG_ID:
+                    print("tagID = %s" % TAG_ID[tagID])
+                else:
+                    print("tagID        = %d" % tagID)
+                print("fieldType    = %s" % FIELD_TYPE[fieldType][0])
+                print("nValues      = %d" % nValues)
+                #if nValues == 1:
+                #    print("valueOffset =  %s" % valueOffset)
+        return tagIDList, fieldTypeList, nValuesList, valueOffsetList
+
+
+
+    def _readIFDEntry(self, tag, tagIDList, fieldTypeList, nValuesList, valueOffsetList):
+        fd = self.fd
+        st = self._structChar
+        idx = tagIDList.index(tag)
+        nValues = nValuesList[idx]
+        output = []
+        ftype, vfmt = FIELD_TYPE[fieldTypeList[idx]]
+        vfmt = st + "%d%s" % (nValues, vfmt)
+        requestedBytes = struct.calcsize(vfmt)
+        if nValues == 1:
+            output.append(valueOffsetList[idx])
+        elif requestedBytes < 5:
+            output.append(valueOffsetList[idx])
+        else:
+            offset = fd.seek(struct.unpack(st + "I", valueOffsetList[idx])[0])
+            output = struct.unpack(vfmt, fd.read(requestedBytes))
+        return output
+
+    def getData(self, nImage, **kw):
+        if nImage >= len(self._IFD):
+            #update prior to raise an index error error
+            self._updateIFD()
+        return self._readImage(nImage, **kw)
+
+    def getImage(self, nImage):
+        return self.getData(nImage)
+
+    def getInfo(self, nImage, **kw):
+        if nImage >= len(self._IFD):
+            #update prior to raise an index error error
+            self._updateIFD()
+        current = self._IFD[nImage]
+        return self._readInfo(nImage)
+
+    def _readInfo(self, nImage, close=True):
+        if nImage in self._imageInfoCacheIndex:
+            if DEBUG:
+                print("Reading info from cache")
+            return self._imageInfoCache[self._imageInfoCacheIndex.index(nImage)]
+
+        #read the header
+        self.__makeSureFileIsOpen()
+        tagIDList, fieldTypeList, nValuesList, valueOffsetList = self._parseImageFileDirectory(nImage)
+
+        #rows and columns
+        nColumns = valueOffsetList[tagIDList.index(TAG_NUMBER_OF_COLUMNS)]
+        nRows = valueOffsetList[tagIDList.index(TAG_NUMBER_OF_ROWS)]
+
+        #bits per sample
+        idx = tagIDList.index(TAG_BITS_PER_SAMPLE)
+        nBits = valueOffsetList[idx]
+        if nValuesList[idx] != 1:
+            #this happens with RGB and friends, nBits is not a single value
+            nBits = self._readIFDEntry(TAG_BITS_PER_SAMPLE,
+                                          tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+
+
+        if TAG_COLORMAP in tagIDList:
+            idx = tagIDList.index(TAG_COLORMAP)
+            tmpColormap = self._readIFDEntry(TAG_COLORMAP,
+                                          tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+            if max(tmpColormap) > 255:
+                tmpColormap = numpy.array(tmpColormap, dtype=numpy.uint16)
+                tmpColormap = (tmpColormap / 256.).astype(numpy.uint8)
+            else:
+                tmpColormap = numpy.array(tmpColormap, dtype=numpy.uint8)
+            tmpColormap.shape = 3, -1
+            colormap = numpy.zeros((tmpColormap.shape[-1], 3), tmpColormap.dtype)
+            colormap[:, :] = tmpColormap.T
+            tmpColormap = None
+        else:
+            colormap = None
+
+        #sample format
+        if TAG_SAMPLE_FORMAT in tagIDList:
+            sampleFormat = valueOffsetList[tagIDList.index(TAG_SAMPLE_FORMAT)]
+        else:
+            #set to unknown
+            sampleFormat = SAMPLE_FORMAT_VOID
+
+        # compression
+        compression = False
+        compression_type = 1
+        if TAG_COMPRESSION in tagIDList:
+            compression_type = valueOffsetList[tagIDList.index(TAG_COMPRESSION)]
+            if compression_type == 1:
+                compression = False
+            else:
+                compression = True
+
+        #photometric interpretation
+        interpretation = 1
+        if TAG_PHOTOMETRIC_INTERPRETATION in tagIDList:
+            interpretation = valueOffsetList[tagIDList.index(TAG_PHOTOMETRIC_INTERPRETATION)]
+        else:
+            print("WARNING: Non standard TIFF. Photometric interpretation TAG missing")
+        helpString = ""
+        if sys.version > '2.6':
+            helpString = eval('b""')
+
+        if TAG_IMAGE_DESCRIPTION in tagIDList:
+            imageDescription = self._readIFDEntry(TAG_IMAGE_DESCRIPTION,
+                    tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+            if type(imageDescription) in [type([1]), type((1,))]:
+                imageDescription = helpString.join(imageDescription)
+        else:
+            imageDescription = "%d/%d" % (nImage + 1, len(self._IFD))
+
+        if sys.version < '3.0':
+            defaultSoftware = "Unknown Software"
+        else:
+            defaultSoftware = bytes("Unknown Software",
+                                    encoding='utf-8')
+        if TAG_SOFTWARE in tagIDList:
+            software = self._readIFDEntry(TAG_SOFTWARE,
+                    tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+            if type(software) in [type([1]), type((1,))]:
+                software = helpString.join(software)
+        else:
+            software = defaultSoftware
+
+        if software == defaultSoftware:
+            try:
+                if sys.version < '3.0':
+                    if imageDescription.upper().startswith("IMAGEJ"):
+                        software = imageDescription.split("=")[0]
+                else:
+                    tmpString = imageDescription.decode()
+                    if tmpString.upper().startswith("IMAGEJ"):
+                        software = bytes(tmpString.split("=")[0],
+                                         encoding='utf-8')
+            except:
+                pass
+
+        if TAG_DATE in tagIDList:
+            date = self._readIFDEntry(TAG_DATE,
+                    tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+            if type(date) in [type([1]), type((1,))]:
+                date = helpString.join(date)
+        else:
+            date = "Unknown Date"
+
+        stripOffsets = self._readIFDEntry(TAG_STRIP_OFFSETS,
+                        tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+        if TAG_ROWS_PER_STRIP in tagIDList:
+            rowsPerStrip = self._readIFDEntry(TAG_ROWS_PER_STRIP,
+                        tagIDList, fieldTypeList, nValuesList, valueOffsetList)[0]
+        else:
+            rowsPerStrip = nRows
+            print("WARNING: Non standard TIFF. Rows per strip TAG missing")
+
+        if TAG_STRIP_BYTE_COUNTS in tagIDList:
+            stripByteCounts = self._readIFDEntry(TAG_STRIP_BYTE_COUNTS,
+                        tagIDList, fieldTypeList, nValuesList, valueOffsetList)
+        else:
+            print("WARNING: Non standard TIFF. Strip byte counts TAG missing")
+            if hasattr(nBits, 'index'):
+                expectedSum = 0
+                for n in nBits:
+                    expectedSum += int(nRows * nColumns * n / 8)
+            else:
+                expectedSum = int(nRows * nColumns * nBits / 8)
+            stripByteCounts = [expectedSum]
+
+        if close:
+            self.__makeSureFileIsClosed()
+
+        if self._forceMonoOutput and (interpretation > 1):
+            #color image but asked monochrome output
+            nBits = 32
+            colormap = None
+            sampleFormat = SAMPLE_FORMAT_FLOAT
+            interpretation = 1
+            #we cannot rely on any cache in this case
+            useInfoCache = False
+            if DEBUG:
+                print("FORCED MONO")
+        else:
+            useInfoCache = True
+
+        info = {}
+        info["nRows"] = nRows
+        info["nColumns"] = nColumns
+        info["nBits"] = nBits
+        info["compression"] = compression
+        info["compression_type"] = compression_type
+        info["imageDescription"] = imageDescription
+        info["stripOffsets"] = stripOffsets #This contains the file offsets to the data positions
+        info["rowsPerStrip"] = rowsPerStrip
+        info["stripByteCounts"] = stripByteCounts #bytes in strip since I do not support compression
+        info["software"] = software
+        info["date"] = date
+        info["colormap"] = colormap
+        info["sampleFormat"] = sampleFormat
+        info["photometricInterpretation"] = interpretation
+        infoDict = {}
+        if sys.version < '3.0':
+            testString = 'PyMca'
+        else:
+            testString = eval('b"PyMca"')
+        if software.startswith(testString):
+            #str to make sure python 2.x sees it as string and not unicode
+            if sys.version < '3.0':
+                descriptionString = imageDescription
+            else:
+                descriptionString = str(imageDescription.decode())
+            #interpret the image description in terms of supplied
+            #information at writing time
+            items = descriptionString.split('=')
+            for i in range(int(len(items) / 2)):
+                key = "%s" % items[i * 2]
+                #get rid of the \n at the end of the value 
+                value = "%s" % items[i * 2 + 1][:-1]
+                infoDict[key] = value
+        info['info'] = infoDict
+
+        if (self._maxImageCacheLength > 0) and useInfoCache:
+            self._imageInfoCacheIndex.insert(0, nImage)
+            self._imageInfoCache.insert(0, info)
+            if len(self._imageInfoCacheIndex) > self._maxImageCacheLength:
+                self._imageInfoCacheIndex = self._imageInfoCacheIndex[:self._maxImageCacheLength]
+                self._imageInfoCache = self._imageInfoCache[:self._maxImageCacheLength]
+        return info
+
+    def _readImage(self, nImage, **kw):
+        if DEBUG:
+            print("Reading image %d" % nImage)
+        if 'close' in kw:
+            close = kw['close']
+        else:
+            close = True
+        rowMin = kw.get('rowMin', None)
+        rowMax = kw.get('rowMax', None)
+        if nImage in self._imageDataCacheIndex:
+            if DEBUG:
+                print("Reading image data from cache")
+            return self._imageDataCache[self._imageDataCacheIndex.index(nImage)]
+
+        self.__makeSureFileIsOpen()
+        if self._forceMonoOutput:
+            oldMono = True
+        else:
+            oldMono = False
+        try:
+            self._forceMonoOutput = False
+            info = self._readInfo(nImage, close=False)
+            self._forceMonoOutput = oldMono
+        except:
+            self._forceMonoOutput = oldMono
+            raise
+        compression = info['compression']
+        compression_type = info['compression_type']
+        if compression:
+            if compression_type != 32773:
+                raise IOError("Compressed TIFF images not supported except packbits")
+            else:
+                #PackBits compression
+                if DEBUG:
+                    print("Using PackBits compression")
+
+        interpretation = info["photometricInterpretation"]
+        if interpretation == 2:
+            #RGB
+            pass
+            #raise IOError("RGB Image. Only grayscale images supported")
+        elif interpretation == 3:
+            #Palette Color Image
+            pass
+            #raise IOError("Palette-color Image. Only grayscale images supported")
+        elif interpretation > 2:
+            #Palette Color Image
+            raise IOError("Only grayscale images supported")
+
+        nRows = info["nRows"]
+        nColumns = info["nColumns"]
+        nBits = info["nBits"]
+        colormap = info["colormap"]
+        sampleFormat = info["sampleFormat"]
+
+        if rowMin is None:
+            rowMin = 0
+
+        if rowMax is None:
+            rowMax = nRows - 1
+
+        if rowMin < 0:
+            rowMin = nRows - rowMin
+
+        if rowMax < 0:
+            rowMax = nRows - rowMax
+
+        if rowMax < rowMin:
+            txt = "Max Row smaller than Min Row. Reverse selection not supported"
+            raise NotImplemented(txt)
+
+        if rowMin >= nRows:
+            raise IndexError("Image only has %d rows" % nRows)
+
+        if rowMax >= nRows:
+            raise IndexError("Image only has %d rows" % nRows)
+
+        if sampleFormat == SAMPLE_FORMAT_FLOAT:
+            if nBits == 32:
+                dtype = numpy.float32
+            elif nBits == 64:
+                dtype = numpy.float64
+            else:
+                raise ValueError("Unsupported number of bits for a float: %d" % nBits)
+        elif sampleFormat in [SAMPLE_FORMAT_UINT, SAMPLE_FORMAT_VOID]:
+            if nBits in [8, (8, 8, 8), [8, 8, 8]]:
+                dtype = numpy.uint8
+            elif nBits in [16, (16, 16, 16), [16, 16, 16]]:
+                dtype = numpy.uint16
+            elif nBits in [32, (32, 32, 32), [32, 32, 32]]:
+                dtype = numpy.uint32
+            elif nBits in [64, (64, 64, 64), [64, 64, 64]]:
+                dtype = numpy.uint64
+            else:
+                raise ValueError("Unsupported number of bits for unsigned int: %s" % (nBits,))
+        elif sampleFormat == SAMPLE_FORMAT_INT:
+            if nBits in [8, (8, 8, 8), [8, 8, 8]]:
+                dtype = numpy.int8
+            elif nBits in [16, (16, 16, 16), [16, 16, 16]]:
+                dtype = numpy.int16
+            elif nBits in [32, (32, 32, 32), [32, 32, 32]]:
+                dtype = numpy.int32
+            elif nBits in [64, (64, 64, 64), [64, 64, 64]]:
+                dtype = numpy.int64
+            else:
+                raise ValueError("Unsupported number of bits for signed int: %s" % (nBits,))
+        else:
+            raise ValueError("Unsupported combination. Bits = %s  Format = %d" % (nBits, sampleFormat))
+        if hasattr(nBits, 'index'):
+            image = numpy.zeros((nRows, nColumns, len(nBits)), dtype=dtype)
+        elif colormap is not None:
+            #should I use colormap dtype?
+            image = numpy.zeros((nRows, nColumns, 3), dtype=dtype)
+        else:
+            image = numpy.zeros((nRows, nColumns), dtype=dtype)
+
+        fd = self.fd
+        st = self._structChar
+        stripOffsets = info["stripOffsets"] #This contains the file offsets to the data positions
+        rowsPerStrip = info["rowsPerStrip"]
+        stripByteCounts = info["stripByteCounts"] #bytes in strip since I do not support compression
+
+        rowStart = 0
+        if len(stripOffsets) == 1:
+            bytesPerRow = int(stripByteCounts[0] / rowsPerStrip)
+            fd.seek(stripOffsets[0] + rowMin * bytesPerRow)
+            nBytes = (rowMax - rowMin + 1) * bytesPerRow
+            if self._swap:
+                readout = numpy.fromstring(fd.read(nBytes), dtype).byteswap()
+            else:
+                readout = numpy.fromstring(fd.read(nBytes), dtype)
+            if hasattr(nBits, 'index'):
+                readout.shape = -1, nColumns, len(nBits)
+            elif info['colormap'] is not None:
+                readout = colormap[readout]
+            else:
+                readout.shape = -1, nColumns
+            image[rowMin:rowMax + 1, :] = readout
+        else:
+            for i in range(len(stripOffsets)):
+                #the amount of rows
+                nRowsToRead = rowsPerStrip
+                rowEnd = int(min(rowStart + nRowsToRead, nRows))
+                if rowEnd < rowMin:
+                    rowStart += nRowsToRead
+                    continue
+                if (rowStart > rowMax):
+                    break
+                #we are in position
+                fd.seek(stripOffsets[i])
+                #the amount of bytes to read
+                nBytes = stripByteCounts[i]
+                if compression_type == 32773:
+                    try:
+                        bufferBytes = bytes()
+                    except:
+                        #python 2.5 ...
+                        bufferBytes = ""
+                    #packBits
+                    readBytes = 0
+                    #intermediate buffer
+                    tmpBuffer = fd.read(nBytes)
+                    while readBytes < nBytes:
+                        n = struct.unpack('b', tmpBuffer[readBytes:(readBytes + 1)])[0]
+                        readBytes += 1
+                        if n >= 0:
+                            #should I prevent reading more than the
+                            #length of the chain? Let's python raise
+                            #the exception...
+                            bufferBytes += tmpBuffer[readBytes:\
+                                                      readBytes + (n + 1)]
+                            readBytes += (n + 1)
+                        elif n > -128:
+                            bufferBytes += (-n + 1) * tmpBuffer[readBytes:(readBytes + 1)]
+                            readBytes += 1
+                        else:
+                            #if read -128 ignore the byte
+                            continue
+                    if self._swap:
+                        readout = numpy.fromstring(bufferBytes, dtype).byteswap()
+                    else:
+                        readout = numpy.fromstring(bufferBytes, dtype)
+                    if hasattr(nBits, 'index'):
+                        readout.shape = -1, nColumns, len(nBits)
+                    elif info['colormap'] is not None:
+                        readout = colormap[readout]
+                        readout.shape = -1, nColumns, 3
+                    else:
+                        readout.shape = -1, nColumns
+                    image[rowStart:rowEnd, :] = readout
+                else:
+                    if 1:
+                        #use numpy
+                        if self._swap:
+                            readout = numpy.fromstring(fd.read(nBytes), dtype).byteswap()
+                        else:
+                            readout = numpy.fromstring(fd.read(nBytes), dtype)
+                        if hasattr(nBits, 'index'):
+                            readout.shape = -1, nColumns, len(nBits)
+                        elif colormap is not None:
+                            readout = colormap[readout]
+                            readout.shape = -1, nColumns, 3
+                        else:
+                            readout.shape = -1, nColumns
+                        image[rowStart:rowEnd, :] = readout
+                    else:
+                        #using struct
+                        readout = numpy.array(struct.unpack(st + "%df" % int(nBytes / 4), fd.read(nBytes)),
+                                              dtype=dtype)
+                        if hasattr(nBits, 'index'):
+                            readout.shape = -1, nColumns, len(nBits)
+                        elif colormap is not None:
+                            readout = colormap[readout]
+                            readout.shape = -1, nColumns, 3
+                        else:
+                            readout.shape = -1, nColumns
+                        image[rowStart:rowEnd, :] = readout
+                rowStart += nRowsToRead
+        if close:
+            self.__makeSureFileIsClosed()
+
+        if len(image.shape) == 3:
+            #color image
+            if self._forceMonoOutput:
+                #color image, convert to monochrome
+                image = (image[:, :, 0] * 0.114 + \
+                         image[:, :, 1] * 0.587 + \
+                         image[:, :, 2] * 0.299).astype(numpy.float32)
+
+        if (rowMin == 0) and (rowMax == (nRows - 1)):
+            self._imageDataCacheIndex.insert(0, nImage)
+            self._imageDataCache.insert(0, image)
+            if len(self._imageDataCacheIndex) > self._maxImageCacheLength:
+                self._imageDataCacheIndex = self._imageDataCacheIndex[:self._maxImageCacheLength]
+                self._imageDataCache = self._imageDataCache[:self._maxImageCacheLength]
+
+        return image
+
+    def writeImage(self, image0, info=None, software=None, date=None):
+        if software is None:
+            software = 'PyMca.TiffIO'
+        #if date is None:
+        #    date = time.ctime()
+
+        self.__makeSureFileIsOpen()
+        fd = self.fd
+        #prior to do anything, perform some tests
+        if not len(image0.shape):
+            raise ValueError("Empty image")
+        if len(image0.shape) == 1:
+            #get a different view
+            image = image0[:]
+            image.shape = 1, -1
+        else:
+            image = image0
+
+        if image.dtype == numpy.float64:
+            image = image.astype(numpy.float32)
+        fd.seek(0)
+        mode = fd.mode
+        name = fd.name
+        if 'w' in mode:
+            #we have to overwrite the file
+            self.__makeSureFileIsClosed()
+            fd = None
+            if os.path.exists(name):
+                os.remove(name)
+            fd = open(name, mode='wb+')
+            self._initEmptyFile(fd)
+        self.fd = fd
+
+        #read the file size
+        self.__makeSureFileIsOpen()
+        fd = self.fd
+        fd.seek(0, os.SEEK_END)
+        endOfFile = fd.tell()
+        if fd.tell() == 0:
+            self._initEmptyFile(fd)
+            fd.seek(0, os.SEEK_END)
+            endOfFile = fd.tell()
+
+        #init internal variables
+        self._initInternalVariables(fd)
+        st = self._structChar
+
+        #get the image file directories
+        nImages = self.getImageFileDirectories()
+        if DEBUG:
+            print("File contains %d images" % nImages)
+        if nImages == 0:
+            fd.seek(4)
+            fmt = st + 'I'
+            fd.write(struct.pack(fmt, endOfFile))
+        else:
+            fd.seek(self._IFD[-1])
+            fmt = st + 'H'
+            numberOfDirectoryEntries = struct.unpack(fmt, fd.read(struct.calcsize(fmt)))[0]
+            fmt = st + 'I'
+            pos = self._IFD[-1] + 2 + 12 * numberOfDirectoryEntries
+            fd.seek(pos)
+            fmt = st + 'I'
+            fd.write(struct.pack(fmt, endOfFile))
+        fd.flush()
+
+        #and we can write at the end of the file, find out the file length
+        fd.seek(0, os.SEEK_END)
+
+        #get the description information from the input information
+        if info is None:
+            description = info
+        else:
+            description = "%s" % ""
+            for key in info.keys():
+                description += "%s=%s\n" % (key, info[key])
+
+        #get the image file directory
+        outputIFD = self._getOutputIFD(image, description=description,
+                                              software=software,
+                                              date=date)
+
+        #write the new IFD
+        fd.write(outputIFD)
+
+        #write the image
+        if self._swap:
+            fd.write(image.byteswap().tostring())
+        else:
+            fd.write(image.tostring())
+
+        fd.flush()
+        self.fd = fd
+        self.__makeSureFileIsClosed()
+
+    def _initEmptyFile(self, fd=None):
+        if fd is None:
+            fd = self.fd
+        if sys.byteorder == "little":
+            order = "II"
+            #intel, little endian
+            fileOrder = "little"
+            self._structChar = '<'
+        else:
+            order = "MM"
+            #motorola, high endian
+            fileOrder = "big"
+            self._structChar = '>'
+        st = self._structChar
+        if fileOrder == sys.byteorder:
+            self._swap = False
+        else:
+            self._swap = True
+        fd.seek(0)
+        if sys.version < '3.0':
+            fd.write(struct.pack(st + '2s', order))
+            fd.write(struct.pack(st + 'H', 42))
+            fd.write(struct.pack(st + 'I', 0))
+        else:
+            fd.write(struct.pack(st + '2s', bytes(order, 'utf-8')))
+            fd.write(struct.pack(st + 'H', 42))
+            fd.write(struct.pack(st + 'I', 0))
+        fd.flush()
+
+    def _getOutputIFD(self, image, description=None, software=None, date=None):
+        #the tags have to be in order
+        #the very minimum is
+        #256:"NumberOfColumns",           # S or L ImageWidth
+        #257:"NumberOfRows",              # S or L ImageHeight
+        #258:"BitsPerSample",             # S Number of bits per component
+        #259:"Compression",               # SHORT (1 - NoCompression, ... 
+        #262:"PhotometricInterpretation", # SHORT (0 - WhiteIsZero, 1 -BlackIsZero, 2 - RGB, 3 - Palette color
+        #270:"ImageDescription",          # ASCII
+        #273:"StripOffsets",              # S or L, for each strip, the byte offset of the strip
+        #278:"RowsPerStrip",              # S or L, number of rows in each back may be not for the last
+        #279:"StripByteCounts",           # S or L, The number of bytes in the strip AFTER any compression
+        #305:"Software",                  # ASCII
+        #306:"Date",                      # ASCII
+        #339:"SampleFormat",              # SHORT Interpretation of data in each pixel
+
+        nDirectoryEntries = 9
+        imageDescription = None
+        if description is not None:
+            descriptionLength = len(description)
+            while descriptionLength < 4:
+                description = description + " "
+                descriptionLength = len(description)
+            if sys.version >= '3.0':
+                description = bytes(description, 'utf-8')
+            elif type(description) != type(""):
+                try:
+                    description = description.decode('utf-8')
+                except UnicodeDecodeError:
+                    try:
+                        description = description.decode('latin-1')
+                    except UnicodeDecodeError:
+                        description = "%s" % description
+                if sys.version > '2.6':
+                    description = description.encode('utf-8', errors="ignore")
+                description = "%s" % description
+            descriptionLength = len(description)
+            imageDescription = struct.pack("%ds" % descriptionLength, description)
+            nDirectoryEntries += 1
+
+        #software
+        if software is not None:
+            softwareLength = len(software)
+            while softwareLength < 4:
+                software = software + " "
+                softwareLength = len(software)
+            if sys.version >= '3.0':
+                software = bytes(software, 'utf-8')
+            softwarePackedString = struct.pack("%ds" % softwareLength, software)
+            nDirectoryEntries += 1
+        else:
+            softwareLength = 0
+
+        if date is not None:
+            dateLength = len(date)
+            if sys.version >= '3.0':
+                date = bytes(date, 'utf-8')
+            datePackedString = struct.pack("%ds" % dateLength, date)
+            dateLength = len(datePackedString)
+            nDirectoryEntries += 1
+        else:
+            dateLength = 0
+
+        nRows, nColumns = image.shape
+        dtype = image.dtype
+        bitsPerSample = int(dtype.str[-1]) * 8
+
+        #only uncompressed data
+        compression = 1
+
+        #interpretation, black is zero
+        interpretation = 1
+
+        #image description
+        if imageDescription is not None:
+            descriptionLength = len(imageDescription)
+        else:
+            descriptionLength = 0
+
+        #strip offsets
+        #we are putting them after the directory and the directory is
+        #at the end of the file
+        self.fd.seek(0, os.SEEK_END)
+        endOfFile = self.fd.tell()
+        if endOfFile == 0:
+            #empty file
+            endOfFile = 8
+
+        #rows per strip
+        if ALLOW_MULTIPLE_STRIPS:
+            #try to segment the image in several pieces
+            if not (nRows % 4):
+                rowsPerStrip = int(nRows / 4)
+            elif not (nRows % 10):
+                rowsPerStrip = int(nRows / 10)
+            elif not (nRows % 8):
+                rowsPerStrip = int(nRows / 8)
+            elif not (nRows % 4):
+                rowsPerStrip = int(nRows / 4)
+            elif not (nRows % 2):
+                rowsPerStrip = int(nRows / 2)
+            else:
+                rowsPerStrip = nRows
+        else:
+            rowsPerStrip = nRows
+
+        #stripByteCounts
+        stripByteCounts = int(nColumns * rowsPerStrip * bitsPerSample / 8)
+
+        if descriptionLength > 4:
+            stripOffsets0 = endOfFile + dateLength + descriptionLength + \
+                        2 + 12 * nDirectoryEntries + 4
+        else:
+            stripOffsets0 = endOfFile + dateLength + \
+                        2 + 12 * nDirectoryEntries + 4
+
+        if softwareLength > 4:
+            stripOffsets0 += softwareLength
+
+        stripOffsets = [stripOffsets0]
+        stripOffsetsLength = 0
+        stripOffsetsString = None
+
+        st = self._structChar
+
+        if rowsPerStrip != nRows:
+            nStripOffsets = int(nRows / rowsPerStrip)
+            fmt = st + 'I'
+            stripOffsetsLength = struct.calcsize(fmt) * nStripOffsets
+            stripOffsets0 += stripOffsetsLength
+            #the length for the stripByteCounts will be the same
+            stripOffsets0 += stripOffsetsLength
+            stripOffsets = []
+            for i in range(nStripOffsets):
+                value = stripOffsets0 + i * stripByteCounts
+                stripOffsets.append(value)
+                if i == 0:
+                    stripOffsetsString = struct.pack(fmt, value)
+                    stripByteCountsString = struct.pack(fmt, stripByteCounts)
+                else:
+                    stripOffsetsString += struct.pack(fmt, value)
+                    stripByteCountsString += struct.pack(fmt, stripByteCounts)
+
+        if DEBUG:
+            print("IMAGE WILL START AT %d" % stripOffsets[0])
+
+        #sample format
+        if dtype in [numpy.float32, numpy.float64] or\
+           dtype.str[-2] == 'f':
+            sampleFormat = SAMPLE_FORMAT_FLOAT
+        elif dtype in [numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]:
+            sampleFormat = SAMPLE_FORMAT_UINT
+        elif dtype in [numpy.int8, numpy.int16, numpy.int32, numpy.int64]:
+            sampleFormat = SAMPLE_FORMAT_INT
+        else:
+            raise ValueError("Unsupported data type %s" % dtype)
+
+        info = {}
+        info["nColumns"] = nColumns
+        info["nRows"] = nRows
+        info["nBits"] = bitsPerSample
+        info["compression"] = compression
+        info["photometricInterpretation"] = interpretation
+        info["stripOffsets"] = stripOffsets
+        info["rowsPerStrip"] = rowsPerStrip
+        info["stripByteCounts"] = stripByteCounts
+        info["date"] = date
+        info["sampleFormat"] = sampleFormat
+
+        outputIFD = ""
+        if sys.version > '2.6':
+            outputIFD = eval('b""')
+
+        fmt = st + "H"
+        outputIFD += struct.pack(fmt, nDirectoryEntries)
+
+        fmt = st + "HHII"
+        outputIFD += struct.pack(fmt, TAG_NUMBER_OF_COLUMNS,
+                                         FIELD_TYPE_OUT['I'],
+                                         1,
+                                         info["nColumns"])
+        outputIFD += struct.pack(fmt, TAG_NUMBER_OF_ROWS,
+                                         FIELD_TYPE_OUT['I'],
+                                         1,
+                                         info["nRows"])
+
+        fmt = st + 'HHIHH'
+        outputIFD += struct.pack(fmt, TAG_BITS_PER_SAMPLE,
+                                         FIELD_TYPE_OUT['H'],
+                                         1,
+                                         info["nBits"], 0)
+        fmt = st + 'HHIHH'
+        outputIFD += struct.pack(fmt, TAG_COMPRESSION,
+                                         FIELD_TYPE_OUT['H'],
+                                         1,
+                                         info["compression"], 0)
+        fmt = st + 'HHIHH'
+        outputIFD += struct.pack(fmt, TAG_PHOTOMETRIC_INTERPRETATION,
+                                         FIELD_TYPE_OUT['H'],
+                                         1,
+                                         info["photometricInterpretation"], 0)
+
+        if imageDescription is not None:
+            descriptionLength = len(imageDescription)
+            if descriptionLength > 4:
+                fmt = st + 'HHII'
+                outputIFD += struct.pack(fmt, TAG_IMAGE_DESCRIPTION,
+                                         FIELD_TYPE_OUT['s'],
+                                         descriptionLength,
+                                         info["stripOffsets"][0] - \
+                                         2 * stripOffsetsLength - \
+                                         descriptionLength)
+            else:
+                #it has to have length 4
+                fmt = st + 'HHI%ds' % descriptionLength
+                outputIFD += struct.pack(fmt, TAG_IMAGE_DESCRIPTION,
+                                         FIELD_TYPE_OUT['s'],
+                                         descriptionLength,
+                                         description)
+
+        if len(stripOffsets) == 1:
+            fmt = st + 'HHII'
+            outputIFD += struct.pack(fmt, TAG_STRIP_OFFSETS,
+                                             FIELD_TYPE_OUT['I'],
+                                             1,
+                                             info["stripOffsets"][0])
+        else:
+            fmt = st + 'HHII'
+            outputIFD += struct.pack(fmt, TAG_STRIP_OFFSETS,
+                                             FIELD_TYPE_OUT['I'],
+                                             len(stripOffsets),
+                    info["stripOffsets"][0] - 2 * stripOffsetsLength)
+
+        fmt = st + 'HHII'
+        outputIFD += struct.pack(fmt, TAG_ROWS_PER_STRIP,
+                                         FIELD_TYPE_OUT['I'],
+                                         1,
+                                         info["rowsPerStrip"])
+
+        if len(stripOffsets) == 1:
+            fmt = st + 'HHII'
+            outputIFD += struct.pack(fmt, TAG_STRIP_BYTE_COUNTS,
+                                             FIELD_TYPE_OUT['I'],
+                                             1,
+                                             info["stripByteCounts"])
+        else:
+            fmt = st + 'HHII'
+            outputIFD += struct.pack(fmt, TAG_STRIP_BYTE_COUNTS,
+                                             FIELD_TYPE_OUT['I'],
+                                             len(stripOffsets),
+                    info["stripOffsets"][0] - stripOffsetsLength)
+
+        if software is not None:
+            if softwareLength > 4:
+                fmt = st + 'HHII'
+                outputIFD += struct.pack(fmt, TAG_SOFTWARE,
+                                         FIELD_TYPE_OUT['s'],
+                                         softwareLength,
+                                         info["stripOffsets"][0] - \
+                                         2 * stripOffsetsLength - \
+                            descriptionLength - softwareLength - dateLength)
+            else:
+                #it has to have length 4
+                fmt = st + 'HHI%ds' % softwareLength
+                outputIFD += struct.pack(fmt, TAG_SOFTWARE,
+                                         FIELD_TYPE_OUT['s'],
+                                         softwareLength,
+                                         softwarePackedString)
+
+        if date is not None:
+            fmt = st + 'HHII'
+            outputIFD += struct.pack(fmt, TAG_DATE,
+                                      FIELD_TYPE_OUT['s'],
+                                      dateLength,
+                                      info["stripOffsets"][0] - \
+                                         2 * stripOffsetsLength - \
+                                      descriptionLength - dateLength)
+
+        fmt = st + 'HHIHH'
+        outputIFD += struct.pack(fmt, TAG_SAMPLE_FORMAT,
+                                         FIELD_TYPE_OUT['H'],
+                                         1,
+                                         info["sampleFormat"], 0)
+        fmt = st + 'I'
+        outputIFD += struct.pack(fmt, 0)
+
+        if softwareLength > 4:
+            outputIFD += softwarePackedString
+
+        if date is not None:
+            outputIFD += datePackedString
+
+        if imageDescription is not None:
+            if descriptionLength > 4:
+                outputIFD += imageDescription
+
+        if stripOffsetsString is not None:
+            outputIFD += stripOffsetsString
+            outputIFD += stripByteCountsString
+
+        return outputIFD
+
+
+if __name__ == "__main__":
+    filename = sys.argv[1]
+    dtype = numpy.uint16
+    if not os.path.exists(filename):
+        print("Testing file creation")
+        tif = TiffIO(filename, mode='wb+')
+        data = numpy.arange(10000).astype(dtype)
+        data.shape = 100, 100
+        tif.writeImage(data, info={'Title':'1st'})
+        tif = None
+        if os.path.exists(filename):
+            print("Testing image appending")
+            tif = TiffIO(filename, mode='rb+')
+            tif.writeImage((data * 2).astype(dtype), info={'Title':'2nd'})
+            tif = None
+    tif = TiffIO(filename)
+    print("Number of images = %d" % tif.getNumberOfImages())
+    for i in range(tif.getNumberOfImages()):
+        info = tif.getInfo(i)
+        for key in info:
+            if key not in ["colormap"]:
+                print("%s = %s" % (key, info[key]))
+            elif info['colormap'] is not None:
+                print("RED   %s = %s" % (key, info[key][0:10, 0]))
+                print("GREEN %s = %s" % (key, info[key][0:10, 1]))
+                print("BLUE  %s = %s" % (key, info[key][0:10, 2]))
+        data = tif.getImage(i)[0, 0:10]
+        print("data [0, 0:10] = ", data)
+