#! /usr/bin/env python3
# -*- coding: utf-8 -*-
# tifffile.py
# Copyright (c) 2008-2018, Christoph Gohlke
# Copyright (c) 2008-2018, The Regents of the University of California
# Produced at the Laboratory for Fluorescence Dynamics
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the copyright holders nor the names of any
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""Read image and meta data from (bio) TIFF(R) files. Save numpy arrays as TIFF.
Image and metadata can be read from TIFF, BigTIFF, OME-TIFF, STK, LSM, NIH,
SGI, ImageJ, MicroManager, FluoView, ScanImage, SEQ, GEL, and GeoTIFF files.
Tifffile is not a general-purpose TIFF library.
Only a subset of the TIFF specification is supported, mainly uncompressed and
losslessly compressed 1, 8, 16, 32 and 64 bit integer, 16, 32 and 64-bit float,
grayscale and RGB(A) images, which are commonly used in scientific imaging.
Specifically, reading slices of image data, image trees defined via SubIFDs,
CCITT and OJPEG compression, chroma subsampling without JPEG compression,
or IPTC and XMP metadata are not implemented.
TIFF(R), the tagged Image File Format, is a trademark and under control of
Adobe Systems Incorporated. BigTIFF allows for files greater than 4 GB.
STK, LSM, FluoView, SGI, SEQ, GEL, and OME-TIFF, are custom extensions
defined by Molecular Devices (Universal Imaging Corporation), Carl Zeiss
MicroImaging, Olympus, Silicon Graphics International, Media Cybernetics,
Molecular Dynamics, and the Open Microscopy Environment consortium
respectively.
For command line usage run C{python -m tifffile --help}
:Author:
`Christoph Gohlke `_
:Organization:
Laboratory for Fluorescence Dynamics, University of California, Irvine
:Version: 2018.06.15
Requirements
------------
* `CPython 3.6 64-bit `_
* `Numpy 1.14 `_
* `Matplotlib 2.2 `_ (optional for plotting)
* `Tifffile.c 2018.02.10 `_
(recommended for faster decoding of PackBits and LZW encoded strings)
* `Tifffile_geodb.py 2018.02.10 `_
(optional enums for GeoTIFF metadata)
* Python 2 requires 'futures', 'enum34', 'pathlib'.
Revisions
---------
2018.06.15
Pass 2680 tests.
Towards reading JPEG and other compressions via imagecodecs package (WIP).
Add function to validate TIFF using 'jhove -m TIFF-hul'.
Save bool arrays as bilevel TIFF.
Accept pathlib.Path as filenames.
Move 'software' argument from TiffWriter __init__ to save.
Raise DOS limit to 16 TB.
Lazy load lzma and zstd compressors and decompressors.
Add option to save IJMetadata tags.
Return correct number of pages for truncated series (bug fix).
Move EXIF tags to TIFF.TAG as per TIFF/EP standard.
2018.02.18
Pass 2293 tests.
Always save RowsPerStrip and Resolution tags as required by TIFF standard.
Do not use badly typed ImageDescription.
Coherce bad ASCII string tags to bytes.
Tuning of __str__ functions.
Fix reading 'undefined' tag values (bug fix).
Read and write ZSTD compressed data.
Use hexdump to print byte strings.
Determine TIFF byte order from data dtype in imsave.
Add option to specify RowsPerStrip for compressed strips.
Allow memory map of arrays with non-native byte order.
Attempt to handle ScanImage <= 5.1 files.
Restore TiffPageSeries.pages sequence interface.
Use numpy.frombuffer instead of fromstring to read from binary data.
Parse GeoTIFF metadata.
Add option to apply horizontal differencing before compression.
Towards reading PerkinElmer QPTIFF (no test files).
Do not index out of bounds data in tifffile.c unpackbits and decodelzw.
2017.09.29 (tentative)
Many backwards incompatible changes improving speed and resource usage:
Pass 2268 tests.
Add detail argument to __str__ function. Remove info functions.
Fix potential issue correcting offsets of large LSM files with positions.
Remove TiffFile sequence interface; use TiffFile.pages instead.
Do not make tag values available as TiffPage attributes.
Use str (not bytes) type for tag and metadata strings (WIP).
Use documented standard tag and value names (WIP).
Use enums for some documented TIFF tag values.
Remove 'memmap' and 'tmpfile' options; use out='memmap' instead.
Add option to specify output in asarray functions.
Add option to concurrently decode image strips or tiles using threads.
Add TiffPage.asrgb function (WIP).
Do not apply colormap in asarray.
Remove 'colormapped', 'rgbonly', and 'scale_mdgel' options from asarray.
Consolidate metadata in TiffFile _metadata functions.
Remove non-tag metadata properties from TiffPage.
Add function to convert LSM to tiled BIN files.
Align image data in file.
Make TiffPage.dtype a numpy.dtype.
Add 'ndim' and 'size' properties to TiffPage and TiffPageSeries.
Allow imsave to write non-BigTIFF files up to ~4 GB.
Only read one page for shaped series if possible.
Add memmap function to create memory-mapped array stored in TIFF file.
Add option to save empty arrays to TIFF files.
Add option to save truncated TIFF files.
Allow single tile images to be saved contiguously.
Add optional movie mode for files with uniform pages.
Lazy load pages.
Use lightweight TiffFrame for IFDs sharing properties with key TiffPage.
Move module constants to 'TIFF' namespace (speed up module import).
Remove 'fastij' option from TiffFile.
Remove 'pages' parameter from TiffFile.
Remove TIFFfile alias.
Deprecate Python 2.
Require enum34 and futures packages on Python 2.7.
Remove Record class and return all metadata as dict instead.
Add functions to parse STK, MetaSeries, ScanImage, SVS, Pilatus metadata.
Read tags from EXIF and GPS IFDs.
Use pformat for tag and metadata values.
Fix reading some UIC tags (bug fix).
Do not modify input array in imshow (bug fix).
Fix Python implementation of unpack_ints.
2017.05.23
Pass 1961 tests.
Write correct number of SampleFormat values (bug fix).
Use Adobe deflate code to write ZIP compressed files.
Add option to pass tag values as packed binary data for writing.
Defer tag validation to attribute access.
Use property instead of lazyattr decorator for simple expressions.
2017.03.17
Write IFDs and tag values on word boundaries.
Read ScanImage metadata.
Remove is_rgb and is_indexed attributes from TiffFile.
Create files used by doctests.
2017.01.12
Read Zeiss SEM metadata.
Read OME-TIFF with invalid references to external files.
Rewrite C LZW decoder (5x faster).
Read corrupted LSM files missing EOI code in LZW stream.
2017.01.01
Add option to append images to existing TIFF files.
Read files without pages.
Read S-FEG and Helios NanoLab tags created by FEI software.
Allow saving Color Filter Array (CFA) images.
Add info functions returning more information about TiffFile and TiffPage.
Add option to read specific pages only.
Remove maxpages argument (backwards incompatible).
Remove test_tifffile function.
2016.10.28
Pass 1944 tests.
Improve detection of ImageJ hyperstacks.
Read TVIPS metadata created by EM-MENU (by Marco Oster).
Add option to disable using OME-XML metadata.
Allow non-integer range attributes in modulo tags (by Stuart Berg).
2016.06.21
Do not always memmap contiguous data in page series.
2016.05.13
Add option to specify resolution unit.
Write grayscale images with extra samples when planarconfig is specified.
Do not write RGB color images with 2 samples.
Reorder TiffWriter.save keyword arguments (backwards incompatible).
2016.04.18
Pass 1932 tests.
TiffWriter, imread, and imsave accept open binary file streams.
2016.04.13
Correctly handle reversed fill order in 2 and 4 bps images (bug fix).
Implement reverse_bitorder in C.
2016.03.18
Fix saving additional ImageJ metadata.
2016.02.22
Pass 1920 tests.
Write 8 bytes double tag values using offset if necessary (bug fix).
Add option to disable writing second image description tag.
Detect tags with incorrect counts.
Disable color mapping for LSM.
2015.11.13
Read LSM 6 mosaics.
Add option to specify directory of memory-mapped files.
Add command line options to specify vmin and vmax values for colormapping.
2015.10.06
New helper function to apply colormaps.
Renamed is_palette attributes to is_indexed (backwards incompatible).
Color-mapped samples are now contiguous (backwards incompatible).
Do not color-map ImageJ hyperstacks (backwards incompatible).
Towards reading Leica SCN.
2015.09.25
Read images with reversed bit order (FillOrder is LSB2MSB).
2015.09.21
Read RGB OME-TIFF.
Warn about malformed OME-XML.
2015.09.16
Detect some corrupted ImageJ metadata.
Better axes labels for 'shaped' files.
Do not create TiffTag for default values.
Chroma subsampling is not supported.
Memory-map data in TiffPageSeries if possible (optional).
2015.08.17
Pass 1906 tests.
Write ImageJ hyperstacks (optional).
Read and write LZMA compressed data.
Specify datetime when saving (optional).
Save tiled and color-mapped images (optional).
Ignore void bytecounts and offsets if possible.
Ignore bogus image_depth tag created by ISS Vista software.
Decode floating point horizontal differencing (not tiled).
Save image data contiguously if possible.
Only read first IFD from ImageJ files if possible.
Read ImageJ 'raw' format (files larger than 4 GB).
TiffPageSeries class for pages with compatible shape and data type.
Try to read incomplete tiles.
Open file dialog if no filename is passed on command line.
Ignore errors when decoding OME-XML.
Rename decoder functions (backwards incompatible).
2014.08.24
TiffWriter class for incremental writing images.
Simplify examples.
2014.08.19
Add memmap function to FileHandle.
Add function to determine if image data in TiffPage is memory-mappable.
Do not close files if multifile_close parameter is False.
2014.08.10
Pass 1730 tests.
Return all extrasamples by default (backwards incompatible).
Read data from series of pages into memory-mapped array (optional).
Squeeze OME dimensions (backwards incompatible).
Workaround missing EOI code in strips.
Support image and tile depth tags (SGI extension).
Better handling of STK/UIC tags (backwards incompatible).
Disable color mapping for STK.
Julian to datetime converter.
TIFF ASCII type may be NULL separated.
Unwrap strip offsets for LSM files greater than 4 GB.
Correct strip byte counts in compressed LSM files.
Skip missing files in OME series.
Read embedded TIFF files.
2014.02.05
Save rational numbers as type 5 (bug fix).
2013.12.20
Keep other files in OME multi-file series closed.
FileHandle class to abstract binary file handle.
Disable color mapping for bad OME-TIFF produced by bio-formats.
Read bad OME-XML produced by ImageJ when cropping.
2013.11.03
Allow zlib compress data in imsave function (optional).
Memory-map contiguous image data (optional).
2013.10.28
Read MicroManager metadata and little-endian ImageJ tag.
Save extra tags in imsave function.
Save tags in ascending order by code (bug fix).
2012.10.18
Accept file like objects (read from OIB files).
2012.08.21
Rename TIFFfile to TiffFile and TIFFpage to TiffPage.
TiffSequence class for reading sequence of TIFF files.
Read UltraQuant tags.
Allow float numbers as resolution in imsave function.
2012.08.03
Read MD GEL tags and NIH Image header.
2012.07.25
Read ImageJ tags.
...
Notes
-----
The API is not stable yet and might change between revisions.
Tested on little-endian platforms only.
Other Python packages and modules for reading (bio) scientific TIFF files:
* `python-bioformats `_
* `Imread `_
* `PyLibTiff `_
* `ITK `_
* `PyLSM `_
* `PyMca.TiffIO.py `_ (same as fabio.TiffIO)
* `BioImageXD.Readers `_
* `Cellcognition.io `_
* `pymimage `_
* `pytiff `_
Acknowledgements
----------------
* Egor Zindy, University of Manchester, for lsm_scan_info specifics.
* Wim Lewis for a bug fix and some LSM functions.
* Hadrien Mary for help on reading MicroManager files.
* Christian Kliche for help writing tiled and color-mapped files.
References
----------
1) TIFF 6.0 Specification and Supplements. Adobe Systems Incorporated.
http://partners.adobe.com/public/developer/tiff/
2) TIFF File Format FAQ. http://www.awaresystems.be/imaging/tiff/faq.html
3) MetaMorph Stack (STK) Image File Format.
http://support.meta.moleculardevices.com/docs/t10243.pdf
4) Image File Format Description LSM 5/7 Release 6.0 (ZEN 2010).
Carl Zeiss MicroImaging GmbH. BioSciences. May 10, 2011
5) The OME-TIFF format.
http://www.openmicroscopy.org/site/support/file-formats/ome-tiff
6) UltraQuant(r) Version 6.0 for Windows Start-Up Guide.
http://www.ultralum.com/images%20ultralum/pdf/UQStart%20Up%20Guide.pdf
7) Micro-Manager File Formats.
http://www.micro-manager.org/wiki/Micro-Manager_File_Formats
8) Tags for TIFF and Related Specifications. Digital Preservation.
http://www.digitalpreservation.gov/formats/content/tiff_tags.shtml
9) ScanImage BigTiff Specification - ScanImage 2016.
http://scanimage.vidriotechnologies.com/display/SI2016/
ScanImage+BigTiff+Specification
10) CIPA DC-008-2016: Exchangeable image file format for digital still cameras:
Exif Version 2.31.
http://www.cipa.jp/std/documents/e/DC-008-Translation-2016-E.pdf
Examples
--------
>>> # write numpy array to TIFF file
>>> data = numpy.random.rand(4, 301, 219)
>>> imsave('temp.tif', data, photometric='minisblack')
>>> # read numpy array from TIFF file
>>> image = imread('temp.tif')
>>> numpy.testing.assert_array_equal(image, data)
>>> # iterate over pages and tags in TIFF file
>>> with TiffFile('temp.tif') as tif:
... images = tif.asarray()
... for page in tif.pages:
... for tag in page.tags.values():
... _ = tag.name, tag.value
... image = page.asarray()
"""
from __future__ import division, print_function
import sys
import os
import io
import re
import glob
import math
import zlib
import time
import json
import enum
import struct
import pathlib
import warnings
import binascii
import tempfile
import datetime
import threading
import collections
import multiprocessing
import concurrent.futures
import numpy
# delay imports: mmap, pprint, fractions, xml, tkinter, matplotlib, lzma, zstd,
# subprocess
__version__ = "2018.06.15"
__docformat__ = "restructuredtext en"
__all__ = (
"imsave",
"imread",
"imshow",
"memmap",
"TiffFile",
"TiffWriter",
"TiffSequence",
# utility functions used by oiffile or czifile
"FileHandle",
"lazyattr",
"natural_sorted",
"decode_lzw",
"stripnull",
"create_output",
"repeat_nd",
"format_size",
"product",
"xml2dict",
)
def imread(files, **kwargs):
"""Return image data from TIFF file(s) as numpy array.
Refer to the TiffFile class and member functions for documentation.
Parameters
----------
files : str, binary stream, or sequence
File name, seekable binary stream, glob pattern, or sequence of
file names.
kwargs : dict
Parameters 'multifile' and 'is_ome' are passed to the TiffFile class.
The 'pattern' parameter is passed to the TiffSequence class.
Other parameters are passed to the asarray functions.
The first image series is returned if no arguments are provided.
Examples
--------
>>> # get image from first page
>>> imsave('temp.tif', numpy.random.rand(3, 4, 301, 219))
>>> im = imread('temp.tif', key=0)
>>> im.shape
(4, 301, 219)
>>> # get images from sequence of files
>>> ims = imread(['temp.tif', 'temp.tif'])
>>> ims.shape
(2, 3, 4, 301, 219)
"""
kwargs_file = parse_kwargs(kwargs, "multifile", "is_ome")
kwargs_seq = parse_kwargs(kwargs, "pattern")
if isinstance(files, basestring) and any(i in files for i in "?*"):
files = glob.glob(files)
if not files:
raise ValueError("no files found")
if not hasattr(files, "seek") and len(files) == 1:
files = files[0]
if isinstance(files, basestring) or hasattr(files, "seek"):
with TiffFile(files, **kwargs_file) as tif:
return tif.asarray(**kwargs)
else:
with TiffSequence(files, **kwargs_seq) as imseq:
return imseq.asarray(**kwargs)
def imsave(file, data=None, shape=None, dtype=None, bigsize=2**32 - 2**25, **kwargs):
"""Write numpy array to TIFF file.
Refer to the TiffWriter class and member functions for documentation.
Parameters
----------
file : str or binary stream
File name or writable binary stream, such as an open file or BytesIO.
data : array_like
Input image. The last dimensions are assumed to be image depth,
height, width, and samples.
If None, an empty array of the specified shape and dtype is
saved to file.
Unless 'byteorder' is specified in 'kwargs', the TIFF file byte order
is determined from the data's dtype or the dtype argument.
shape : tuple
If 'data' is None, shape of an empty array to save to the file.
dtype : numpy.dtype
If 'data' is None, data-type of an empty array to save to the file.
bigsize : int
Create a BigTIFF file if the size of data in bytes is larger than
this threshold and 'imagej' or 'truncate' are not enabled.
By default, the threshold is 4 GB minus 32 MB reserved for metadata.
Use the 'bigtiff' parameter to explicitly specify the type of
file created.
kwargs : dict
Parameters 'append', 'byteorder', 'bigtiff', and 'imagej', are passed
to TiffWriter(). Other parameters are passed to TiffWriter.save().
Returns
-------
If the image data are written contiguously, return offset and bytecount
of image data in the file.
Examples
--------
>>> # save a RGB image
>>> data = numpy.random.randint(0, 255, (256, 256, 3), 'uint8')
>>> imsave('temp.tif', data, photometric='rgb')
>>> # save a random array and metadata, using compression
>>> data = numpy.random.rand(2, 5, 3, 301, 219)
>>> imsave('temp.tif', data, compress=6, metadata={'axes': 'TZCYX'})
"""
tifargs = parse_kwargs(kwargs, "append", "bigtiff", "byteorder", "imagej")
if data is None:
size = product(shape) * numpy.dtype(dtype).itemsize
byteorder = numpy.dtype(dtype).byteorder
else:
try:
size = data.nbytes
byteorder = data.dtype.byteorder
except Exception:
size = 0
byteorder = None
if (
size > bigsize
and "bigtiff" not in tifargs
and not (tifargs.get("imagej", False) or tifargs.get("truncate", False))
):
tifargs["bigtiff"] = True
if "byteorder" not in tifargs:
tifargs["byteorder"] = byteorder
with TiffWriter(file, **tifargs) as tif:
return tif.save(data, shape, dtype, **kwargs)
def memmap(filename, shape=None, dtype=None, page=None, series=0, mode="r+", **kwargs):
"""Return memory-mapped numpy array stored in TIFF file.
Memory-mapping requires data stored in native byte order, without tiling,
compression, predictors, etc.
If 'shape' and 'dtype' are provided, existing files will be overwritten or
appended to depending on the 'append' parameter.
Otherwise the image data of a specified page or series in an existing
file will be memory-mapped. By default, the image data of the first page
series is memory-mapped.
Call flush() to write any changes in the array to the file.
Raise ValueError if the image data in the file is not memory-mappable.
Parameters
----------
filename : str
Name of the TIFF file which stores the array.
shape : tuple
Shape of the empty array.
dtype : numpy.dtype
Data-type of the empty array.
page : int
Index of the page which image data to memory-map.
series : int
Index of the page series which image data to memory-map.
mode : {'r+', 'r', 'c'}, optional
The file open mode. Default is to open existing file for reading and
writing ('r+').
kwargs : dict
Additional parameters passed to imsave() or TiffFile().
Examples
--------
>>> # create an empty TIFF file and write to memory-mapped image
>>> im = memmap('temp.tif', shape=(256, 256), dtype='float32')
>>> im[255, 255] = 1.0
>>> im.flush()
>>> im.shape, im.dtype
((256, 256), dtype('float32'))
>>> del im
>>> # memory-map image data in a TIFF file
>>> im = memmap('temp.tif', page=0)
>>> im[255, 255]
1.0
"""
if shape is not None and dtype is not None:
# create a new, empty array
kwargs.update(
data=None,
shape=shape,
dtype=dtype,
returnoffset=True,
align=TIFF.ALLOCATIONGRANULARITY,
)
result = imsave(filename, **kwargs)
if result is None:
# TODO: fail before creating file or writing data
raise ValueError("image data are not memory-mappable")
offset = result[0]
else:
# use existing file
with TiffFile(filename, **kwargs) as tif:
if page is not None:
page = tif.pages[page]
if not page.is_memmappable:
raise ValueError("image data are not memory-mappable")
offset, _ = page.is_contiguous
shape = page.shape
dtype = page.dtype
else:
series = tif.series[series]
if series.offset is None:
raise ValueError("image data are not memory-mappable")
shape = series.shape
dtype = series.dtype
offset = series.offset
dtype = tif.byteorder + dtype.char
return numpy.memmap(filename, dtype, mode, offset, shape, "C")
class lazyattr(object):
"""Attribute whose value is computed on first access."""
# TODO: help() doesn't work
__slots__ = ("func",)
def __init__(self, func):
self.func = func
# self.__name__ = func.__name__
# self.__doc__ = func.__doc__
# self.lock = threading.RLock()
def __get__(self, instance, owner):
# with self.lock:
if instance is None:
return self
try:
value = self.func(instance)
except AttributeError as e:
raise RuntimeError(e)
if value is NotImplemented:
return getattr(super(owner, instance), self.func.__name__)
setattr(instance, self.func.__name__, value)
return value
class TiffWriter(object):
"""Write numpy arrays to TIFF file.
TiffWriter instances must be closed using the 'close' method, which is
automatically called when using the 'with' context manager.
TiffWriter's main purpose is saving nD numpy array's as TIFF,
not to create any possible TIFF format. Specifically, JPEG compression,
SubIFDs, ExifIFD, or GPSIFD tags are not supported.
Examples
--------
>>> # successively append images to BigTIFF file
>>> data = numpy.random.rand(2, 5, 3, 301, 219)
>>> with TiffWriter('temp.tif', bigtiff=True) as tif:
... for i in range(data.shape[0]):
... tif.save(data[i], compress=6, photometric='minisblack')
"""
def __init__(self, file, bigtiff=False, byteorder=None, append=False, imagej=False):
"""Open a TIFF file for writing.
An empty TIFF file is created if the file does not exist, else the
file is overwritten with an empty TIFF file unless 'append'
is true. Use bigtiff=True when creating files larger than 4 GB.
Parameters
----------
file : str, binary stream, or FileHandle
File name or writable binary stream, such as an open file
or BytesIO.
bigtiff : bool
If True, the BigTIFF format is used.
byteorder : {'<', '>', '=', '|'}
The endianness of the data in the file.
By default, this is the system's native byte order.
append : bool
If True and 'file' is an existing standard TIFF file, image data
and tags are appended to the file.
Appending data may corrupt specifically formatted TIFF files
such as LSM, STK, ImageJ, NIH, or FluoView.
imagej : bool
If True, write an ImageJ hyperstack compatible file.
This format can handle data types uint8, uint16, or float32 and
data shapes up to 6 dimensions in TZCYXS order.
RGB images (S=3 or S=4) must be uint8.
ImageJ's default byte order is big-endian but this implementation
uses the system's native byte order by default.
ImageJ does not support BigTIFF format or LZMA compression.
The ImageJ file format is undocumented.
"""
if append:
# determine if file is an existing TIFF file that can be extended
try:
with FileHandle(file, mode="rb", size=0) as fh:
pos = fh.tell()
try:
with TiffFile(fh) as tif:
if append != "force" and any(
getattr(tif, "is_" + a)
for a in (
"lsm",
"stk",
"imagej",
"nih",
"fluoview",
"micromanager",
)
):
raise ValueError("file contains metadata")
byteorder = tif.byteorder
bigtiff = tif.is_bigtiff
self._ifdoffset = tif.pages.next_page_offset
except Exception as e:
raise ValueError("cannot append to file: %s" % str(e))
finally:
fh.seek(pos)
except (IOError, FileNotFoundError):
append = False
if byteorder in (None, "=", "|"):
byteorder = "<" if sys.byteorder == "little" else ">"
elif byteorder not in ("<", ">"):
raise ValueError("invalid byteorder %s" % byteorder)
if imagej and bigtiff:
warnings.warn("writing incompatible BigTIFF ImageJ")
self._byteorder = byteorder
self._imagej = bool(imagej)
self._truncate = False
self._metadata = None
self._colormap = None
self._descriptionoffset = 0
self._descriptionlen = 0
self._descriptionlenoffset = 0
self._tags = None
self._shape = None # normalized shape of data in consecutive pages
self._datashape = None # shape of data in consecutive pages
self._datadtype = None # data type
self._dataoffset = None # offset to data
self._databytecounts = None # byte counts per plane
self._tagoffsets = None # strip or tile offset tag code
if bigtiff:
self._bigtiff = True
self._offsetsize = 8
self._tagsize = 20
self._tagnoformat = "Q"
self._offsetformat = "Q"
self._valueformat = "8s"
else:
self._bigtiff = False
self._offsetsize = 4
self._tagsize = 12
self._tagnoformat = "H"
self._offsetformat = "I"
self._valueformat = "4s"
if append:
self._fh = FileHandle(file, mode="r+b", size=0)
self._fh.seek(0, 2)
else:
self._fh = FileHandle(file, mode="wb", size=0)
self._fh.write({"<": b"II", ">": b"MM"}[byteorder])
if bigtiff:
self._fh.write(struct.pack(byteorder + "HHH", 43, 8, 0))
else:
self._fh.write(struct.pack(byteorder + "H", 42))
# first IFD
self._ifdoffset = self._fh.tell()
self._fh.write(struct.pack(byteorder + self._offsetformat, 0))
def save(
self,
data=None,
shape=None,
dtype=None,
returnoffset=False,
photometric=None,
planarconfig=None,
tile=None,
contiguous=True,
align=16,
truncate=False,
compress=0,
rowsperstrip=None,
predictor=False,
colormap=None,
description=None,
datetime=None,
resolution=None,
software="tifffile.py",
metadata={},
ijmetadata=None,
extratags=(),
):
"""Write numpy array and tags to TIFF file.
The data shape's last dimensions are assumed to be image depth,
height (length), width, and samples.
If a colormap is provided, the data's dtype must be uint8 or uint16
and the data values are indices into the last dimension of the
colormap.
If 'shape' and 'dtype' are specified, an empty array is saved.
This option cannot be used with compression or multiple tiles.
Image data are written uncompressed in one strip per plane by default.
Dimensions larger than 2 to 4 (depending on photometric mode, planar
configuration, and SGI mode) are flattened and saved as separate pages.
The SampleFormat and BitsPerSample tags are derived from the data type.
Parameters
----------
data : numpy.ndarray or None
Input image array.
shape : tuple or None
Shape of the empty array to save. Used only if 'data' is None.
dtype : numpy.dtype or None
Data-type of the empty array to save. Used only if 'data' is None.
returnoffset : bool
If True and the image data in the file is memory-mappable, return
the offset and number of bytes of the image data in the file.
photometric : {'MINISBLACK', 'MINISWHITE', 'RGB', 'PALETTE', 'CFA'}
The color space of the image data.
By default, this setting is inferred from the data shape and the
value of colormap.
For CFA images, DNG tags must be specified in 'extratags'.
planarconfig : {'CONTIG', 'SEPARATE'}
Specifies if samples are stored contiguous or in separate planes.
By default, this setting is inferred from the data shape.
If this parameter is set, extra samples are used to store grayscale
images.
'CONTIG': last dimension contains samples.
'SEPARATE': third last dimension contains samples.
tile : tuple of int
The shape (depth, length, width) of image tiles to write.
If None (default), image data are written in strips.
The tile length and width must be a multiple of 16.
If the tile depth is provided, the SGI ImageDepth and TileDepth
tags are used to save volume data.
Unless a single tile is used, tiles cannot be used to write
contiguous files.
Few software can read the SGI format, e.g. MeVisLab.
contiguous : bool
If True (default) and the data and parameters are compatible with
previous ones, if any, the image data are stored contiguously after
the previous one. Parameters 'photometric' and 'planarconfig'
are ignored. Parameters 'description', datetime', and 'extratags'
are written to the first page of a contiguous series only.
align : int
Byte boundary on which to align the image data in the file.
Default 16. Use mmap.ALLOCATIONGRANULARITY for memory-mapped data.
Following contiguous writes are not aligned.
truncate : bool
If True, only write the first page including shape metadata if
possible (uncompressed, contiguous, not tiled).
Other TIFF readers will only be able to read part of the data.
compress : int or 'LZMA', 'ZSTD'
Values from 0 to 9 controlling the level of zlib compression.
If 0 (default), data are written uncompressed.
Compression cannot be used to write contiguous files.
If 'LZMA' or 'ZSTD', LZMA or ZSTD compression is used, which is
not available on all platforms.
rowsperstrip : int
The number of rows per strip used for compression.
Uncompressed data are written in one strip per plane.
predictor : bool
If True, apply horizontal differencing to integer type images
before compression.
colormap : numpy.ndarray
RGB color values for the corresponding data value.
Must be of shape (3, 2**(data.itemsize*8)) and dtype uint16.
description : str
The subject of the image. Must be 7-bit ASCII. Cannot be used with
the ImageJ format. Saved with the first page only.
datetime : datetime
Date and time of image creation in '%Y:%m:%d %H:%M:%S' format.
If None (default), the current date and time is used.
Saved with the first page only.
resolution : (float, float[, str]) or ((int, int), (int, int)[, str])
X and Y resolutions in pixels per resolution unit as float or
rational numbers. A third, optional parameter specifies the
resolution unit, which must be None (default for ImageJ),
'INCH' (default), or 'CENTIMETER'.
software : str
Name of the software used to create the file. Must be 7-bit ASCII.
Saved with the first page only.
metadata : dict
Additional meta data to be saved along with shape information
in JSON or ImageJ formats in an ImageDescription tag.
If None, do not write a second ImageDescription tag.
Strings must be 7-bit ASCII. Saved with the first page only.
ijmetadata : dict
Additional meta data to be saved in application specific
IJMetadata and IJMetadataByteCounts tags. Refer to the
imagej_metadata_tags function for valid keys and values.
Saved with the first page only.
extratags : sequence of tuples
Additional tags as [(code, dtype, count, value, writeonce)].
code : int
The TIFF tag Id.
dtype : str
Data type of items in 'value' in Python struct format.
One of B, s, H, I, 2I, b, h, i, 2i, f, d, Q, or q.
count : int
Number of data values. Not used for string or byte string
values.
value : sequence
'Count' values compatible with 'dtype'.
Byte strings must contain count values of dtype packed as
binary data.
writeonce : bool
If True, the tag is written to the first page only.
"""
# TODO: refactor this function
fh = self._fh
byteorder = self._byteorder
if data is None:
if compress:
raise ValueError("cannot save compressed empty file")
datashape = shape
datadtype = numpy.dtype(dtype).newbyteorder(byteorder)
datadtypechar = datadtype.char
else:
data = numpy.asarray(data, byteorder + data.dtype.char, "C")
if data.size == 0:
raise ValueError("cannot save empty array")
datashape = data.shape
datadtype = data.dtype
datadtypechar = data.dtype.char
returnoffset = returnoffset and datadtype.isnative
bilevel = datadtypechar == "?"
if bilevel:
index = -1 if datashape[-1] > 1 else -2
datasize = product(datashape[:index])
if datashape[index] % 8:
datasize *= datashape[index] // 8 + 1
else:
datasize *= datashape[index] // 8
else:
datasize = product(datashape) * datadtype.itemsize
# just append contiguous data if possible
self._truncate = bool(truncate)
if self._datashape:
if (
not contiguous
or self._datashape[1:] != datashape
or self._datadtype != datadtype
or (compress and self._tags)
or tile
or not numpy.array_equal(colormap, self._colormap)
):
# incompatible shape, dtype, compression mode, or colormap
self._write_remaining_pages()
self._write_image_description()
self._truncate = False
self._descriptionoffset = 0
self._descriptionlenoffset = 0
self._datashape = None
self._colormap = None
if self._imagej:
raise ValueError("ImageJ does not support non-contiguous data")
else:
# consecutive mode
self._datashape = (self._datashape[0] + 1,) + datashape
if not compress:
# write contiguous data, write IFDs/tags later
offset = fh.tell()
if data is None:
fh.write_empty(datasize)
else:
fh.write_array(data)
if returnoffset:
return offset, datasize
return
input_shape = datashape
tagnoformat = self._tagnoformat
valueformat = self._valueformat
offsetformat = self._offsetformat
offsetsize = self._offsetsize
tagsize = self._tagsize
MINISBLACK = TIFF.PHOTOMETRIC.MINISBLACK
RGB = TIFF.PHOTOMETRIC.RGB
CFA = TIFF.PHOTOMETRIC.CFA
PALETTE = TIFF.PHOTOMETRIC.PALETTE
CONTIG = TIFF.PLANARCONFIG.CONTIG
SEPARATE = TIFF.PLANARCONFIG.SEPARATE
# parse input
if photometric is not None:
photometric = enumarg(TIFF.PHOTOMETRIC, photometric)
if planarconfig:
planarconfig = enumarg(TIFF.PLANARCONFIG, planarconfig)
if not compress:
compress = False
compresstag = 1
predictor = False
else:
if isinstance(compress, (tuple, list)):
compress, compresslevel = compress
elif isinstance(compress, int):
compress, compresslevel = "ADOBE_DEFLATE", int(compress)
if not 0 <= compresslevel <= 9:
raise ValueError("invalid compression level %s" % compress)
else:
compresslevel = None
compress = compress.upper()
compresstag = enumarg(TIFF.COMPRESSION, compress)
# prepare ImageJ format
if self._imagej:
if compress in ("LZMA", "ZSTD"):
raise ValueError("ImageJ cannot handle LZMA or ZSTD compression")
if description:
warnings.warn("not writing description to ImageJ file")
description = None
volume = False
if datadtypechar not in "BHhf":
raise ValueError("ImageJ does not support data type %s" % datadtypechar)
ijrgb = photometric == RGB if photometric else None
if datadtypechar not in "B":
ijrgb = False
ijshape = imagej_shape(datashape, ijrgb)
if ijshape[-1] in (3, 4):
photometric = RGB
if datadtypechar not in "B":
raise ValueError(
"ImageJ does not support data type %s "
"for RGB" % datadtypechar
)
elif photometric is None:
photometric = MINISBLACK
planarconfig = None
if planarconfig == SEPARATE:
raise ValueError("ImageJ does not support planar images")
else:
planarconfig = CONTIG if ijrgb else None
# define compress function
if compress:
if compresslevel is None:
compressor, compresslevel = TIFF.COMPESSORS[compresstag]
else:
compressor, _ = TIFF.COMPESSORS[compresstag]
compresslevel = int(compresslevel)
if predictor:
if datadtype.kind not in "iu":
raise ValueError("prediction not implemented for %s" % datadtype)
def compress(data, level=compresslevel):
# horizontal differencing
diff = numpy.diff(data, axis=-2)
data = numpy.insert(diff, 0, data[..., 0, :], axis=-2)
return compressor(data, level)
else:
def compress(data, level=compresslevel):
return compressor(data, level)
# verify colormap and indices
if colormap is not None:
if datadtypechar not in "BH":
raise ValueError("invalid data dtype for palette mode")
colormap = numpy.asarray(colormap, dtype=byteorder + "H")
if colormap.shape != (3, 2 ** (datadtype.itemsize * 8)):
raise ValueError("invalid color map shape")
self._colormap = colormap
# verify tile shape
if tile:
tile = tuple(int(i) for i in tile[:3])
volume = len(tile) == 3
if (
len(tile) < 2
or tile[-1] % 16
or tile[-2] % 16
or any(i < 1 for i in tile)
):
raise ValueError("invalid tile shape")
else:
tile = ()
volume = False
# normalize data shape to 5D or 6D, depending on volume:
# (pages, planar_samples, [depth,] height, width, contig_samples)
datashape = reshape_nd(datashape, 3 if photometric == RGB else 2)
shape = datashape
ndim = len(datashape)
samplesperpixel = 1
extrasamples = 0
if volume and ndim < 3:
volume = False
if colormap is not None:
photometric = PALETTE
planarconfig = None
if photometric is None:
photometric = MINISBLACK
if bilevel:
photometric = TIFF.PHOTOMETRIC.MINISWHITE
elif planarconfig == CONTIG:
if ndim > 2 and shape[-1] in (3, 4):
photometric = RGB
elif planarconfig == SEPARATE:
if volume and ndim > 3 and shape[-4] in (3, 4):
photometric = RGB
elif ndim > 2 and shape[-3] in (3, 4):
photometric = RGB
elif ndim > 2 and shape[-1] in (3, 4):
photometric = RGB
elif self._imagej:
photometric = MINISBLACK
elif volume and ndim > 3 and shape[-4] in (3, 4):
photometric = RGB
elif ndim > 2 and shape[-3] in (3, 4):
photometric = RGB
if planarconfig and len(shape) <= (3 if volume else 2):
planarconfig = None
photometric = MINISBLACK
if photometric == RGB:
if len(shape) < 3:
raise ValueError("not a RGB(A) image")
if len(shape) < 4:
volume = False
if planarconfig is None:
if shape[-1] in (3, 4):
planarconfig = CONTIG
elif shape[-4 if volume else -3] in (3, 4):
planarconfig = SEPARATE
elif shape[-1] > shape[-4 if volume else -3]:
planarconfig = SEPARATE
else:
planarconfig = CONTIG
if planarconfig == CONTIG:
datashape = (-1, 1) + shape[(-4 if volume else -3) :]
samplesperpixel = datashape[-1]
else:
datashape = (-1,) + shape[(-4 if volume else -3) :] + (1,)
samplesperpixel = datashape[1]
if samplesperpixel > 3:
extrasamples = samplesperpixel - 3
elif photometric == CFA:
if len(shape) != 2:
raise ValueError("invalid CFA image")
volume = False
planarconfig = None
datashape = (-1, 1) + shape[-2:] + (1,)
if 50706 not in (et[0] for et in extratags):
raise ValueError("must specify DNG tags for CFA image")
elif planarconfig and len(shape) > (3 if volume else 2):
if planarconfig == CONTIG:
datashape = (-1, 1) + shape[(-4 if volume else -3) :]
samplesperpixel = datashape[-1]
else:
datashape = (-1,) + shape[(-4 if volume else -3) :] + (1,)
samplesperpixel = datashape[1]
extrasamples = samplesperpixel - 1
else:
planarconfig = None
# remove trailing 1s
while len(shape) > 2 and shape[-1] == 1:
shape = shape[:-1]
if len(shape) < 3:
volume = False
datashape = (-1, 1) + shape[(-3 if volume else -2) :] + (1,)
# normalize shape to 6D
assert len(datashape) in (5, 6)
if len(datashape) == 5:
datashape = datashape[:2] + (1,) + datashape[2:]
if datashape[0] == -1:
s0 = product(input_shape) // product(datashape[1:])
datashape = (s0,) + datashape[1:]
shape = datashape
if data is not None:
data = data.reshape(shape)
if tile and not volume:
tile = (1, tile[-2], tile[-1])
if photometric == PALETTE:
if samplesperpixel != 1 or extrasamples or shape[1] != 1 or shape[-1] != 1:
raise ValueError("invalid data shape for palette mode")
if photometric == RGB and samplesperpixel == 2:
raise ValueError("not a RGB image (samplesperpixel=2)")
if bilevel:
if compress:
raise ValueError("cannot save compressed bilevel image")
if tile:
raise ValueError("cannot save tiled bilevel image")
if photometric not in (0, 1):
raise ValueError("cannot save bilevel image as %s" % str(photometric))
datashape = list(datashape)
if datashape[-2] % 8:
datashape[-2] = datashape[-2] // 8 + 1
else:
datashape[-2] = datashape[-2] // 8
datashape = tuple(datashape)
assert datasize == product(datashape)
if data is not None:
data = numpy.packbits(data, axis=-2)
assert datashape[-2] == data.shape[-2]
bytestr = (
bytes
if sys.version[0] == "2"
else (lambda x: bytes(x, "ascii") if isinstance(x, str) else x)
)
tags = [] # list of (code, ifdentry, ifdvalue, writeonce)
strip_or_tile = "Tile" if tile else "Strip"
tagbytecounts = TIFF.TAG_NAMES[strip_or_tile + "ByteCounts"]
tag_offsets = TIFF.TAG_NAMES[strip_or_tile + "Offsets"]
self._tagoffsets = tag_offsets
def pack(fmt, *val):
return struct.pack(byteorder + fmt, *val)
def addtag(code, dtype, count, value, writeonce=False):
# Compute ifdentry & ifdvalue bytes from code, dtype, count, value
# Append (code, ifdentry, ifdvalue, writeonce) to tags list
code = int(TIFF.TAG_NAMES.get(code, code))
try:
tifftype = TIFF.DATA_DTYPES[dtype]
except KeyError:
raise ValueError("unknown dtype %s" % dtype)
rawcount = count
if dtype == "s":
# strings
value = bytestr(value) + b"\0"
count = rawcount = len(value)
rawcount = value.find(b"\0\0")
if rawcount < 0:
rawcount = count
else:
rawcount += 1 # length of string without buffer
value = (value,)
elif isinstance(value, bytes):
# packed binary data
dtsize = struct.calcsize(dtype)
if len(value) % dtsize:
raise ValueError("invalid packed binary data")
count = len(value) // dtsize
if len(dtype) > 1:
count *= int(dtype[:-1])
dtype = dtype[-1]
ifdentry = [pack("HH", code, tifftype), pack(offsetformat, rawcount)]
ifdvalue = None
if struct.calcsize(dtype) * count <= offsetsize:
# value(s) can be written directly
if isinstance(value, bytes):
ifdentry.append(pack(valueformat, value))
elif count == 1:
if isinstance(value, (tuple, list, numpy.ndarray)):
value = value[0]
ifdentry.append(pack(valueformat, pack(dtype, value)))
else:
ifdentry.append(pack(valueformat, pack(str(count) + dtype, *value)))
else:
# use offset to value(s)
ifdentry.append(pack(offsetformat, 0))
if isinstance(value, bytes):
ifdvalue = value
elif isinstance(value, numpy.ndarray):
assert value.size == count
assert value.dtype.char == dtype
ifdvalue = value.tostring()
elif isinstance(value, (tuple, list)):
ifdvalue = pack(str(count) + dtype, *value)
else:
ifdvalue = pack(dtype, value)
tags.append((code, b"".join(ifdentry), ifdvalue, writeonce))
def rational(arg, max_denominator=1000000):
""" "Return nominator and denominator from float or two integers."""
from fractions import Fraction # delayed import
try:
f = Fraction.from_float(arg)
except TypeError:
f = Fraction(arg[0], arg[1])
f = f.limit_denominator(max_denominator)
return f.numerator, f.denominator
if description:
# user provided description
addtag("ImageDescription", "s", 0, description, writeonce=True)
# write shape and metadata to ImageDescription
self._metadata = {} if not metadata else metadata.copy()
if self._imagej:
description = imagej_description(
input_shape,
shape[-1] in (3, 4),
self._colormap is not None,
**self._metadata
)
elif metadata or metadata == {}:
if self._truncate:
self._metadata.update(truncated=True)
description = json_description(input_shape, **self._metadata)
else:
description = None
if description:
# add 64 bytes buffer
# the image description might be updated later with the final shape
description = str2bytes(description, "ascii")
description += b"\0" * 64
self._descriptionlen = len(description)
addtag("ImageDescription", "s", 0, description, writeonce=True)
if software:
addtag("Software", "s", 0, software, writeonce=True)
if datetime is None:
datetime = self._now()
addtag(
"DateTime", "s", 0, datetime.strftime("%Y:%m:%d %H:%M:%S"), writeonce=True
)
addtag("Compression", "H", 1, compresstag)
if predictor:
addtag("Predictor", "H", 1, 2)
addtag("ImageWidth", "I", 1, shape[-2])
addtag("ImageLength", "I", 1, shape[-3])
if tile:
addtag("TileWidth", "I", 1, tile[-1])
addtag("TileLength", "I", 1, tile[-2])
if tile[0] > 1:
addtag("ImageDepth", "I", 1, shape[-4])
addtag("TileDepth", "I", 1, tile[0])
addtag("NewSubfileType", "I", 1, 0)
if not bilevel:
sampleformat = {"u": 1, "i": 2, "f": 3, "c": 6}[datadtype.kind]
addtag(
"SampleFormat", "H", samplesperpixel, (sampleformat,) * samplesperpixel
)
addtag("PhotometricInterpretation", "H", 1, photometric.value)
if colormap is not None:
addtag("ColorMap", "H", colormap.size, colormap)
addtag("SamplesPerPixel", "H", 1, samplesperpixel)
if bilevel:
pass
elif planarconfig and samplesperpixel > 1:
addtag("PlanarConfiguration", "H", 1, planarconfig.value)
addtag(
"BitsPerSample",
"H",
samplesperpixel,
(datadtype.itemsize * 8,) * samplesperpixel,
)
else:
addtag("BitsPerSample", "H", 1, datadtype.itemsize * 8)
if extrasamples:
if photometric == RGB and extrasamples == 1:
addtag("ExtraSamples", "H", 1, 1) # associated alpha channel
else:
addtag("ExtraSamples", "H", extrasamples, (0,) * extrasamples)
if resolution is not None:
addtag("XResolution", "2I", 1, rational(resolution[0]))
addtag("YResolution", "2I", 1, rational(resolution[1]))
if len(resolution) > 2:
unit = resolution[2]
unit = 1 if unit is None else enumarg(TIFF.RESUNIT, unit)
elif self._imagej:
unit = 1
else:
unit = 2
addtag("ResolutionUnit", "H", 1, unit)
elif not self._imagej:
addtag("XResolution", "2I", 1, (1, 1))
addtag("YResolution", "2I", 1, (1, 1))
addtag("ResolutionUnit", "H", 1, 1)
if ijmetadata:
for t in imagej_metadata_tags(ijmetadata, byteorder):
addtag(*t)
contiguous = not compress
if tile:
# one chunk per tile per plane
tiles = (
(shape[2] + tile[0] - 1) // tile[0],
(shape[3] + tile[1] - 1) // tile[1],
(shape[4] + tile[2] - 1) // tile[2],
)
numtiles = product(tiles) * shape[1]
stripbytecounts = [
product(tile) * shape[-1] * datadtype.itemsize
] * numtiles
addtag(tagbytecounts, offsetformat, numtiles, stripbytecounts)
addtag(tag_offsets, offsetformat, numtiles, [0] * numtiles)
contiguous = contiguous and product(tiles) == 1
if not contiguous:
# allocate tile buffer
chunk = numpy.empty(tile + (shape[-1],), dtype=datadtype)
elif contiguous:
# one strip per plane
if bilevel:
stripbytecounts = [product(datashape[2:])] * shape[1]
else:
stripbytecounts = [product(datashape[2:]) * datadtype.itemsize] * shape[
1
]
addtag(tagbytecounts, offsetformat, shape[1], stripbytecounts)
addtag(tag_offsets, offsetformat, shape[1], [0] * shape[1])
addtag("RowsPerStrip", "I", 1, shape[-3])
else:
# compress rowsperstrip or ~64 KB chunks
rowsize = product(shape[-2:]) * datadtype.itemsize
if rowsperstrip is None:
rowsperstrip = 65536 // rowsize
if rowsperstrip < 1:
rowsperstrip = 1
elif rowsperstrip > shape[-3]:
rowsperstrip = shape[-3]
addtag("RowsPerStrip", "I", 1, rowsperstrip)
numstrips = (shape[-3] + rowsperstrip - 1) // rowsperstrip
numstrips *= shape[1]
stripbytecounts = [0] * numstrips
addtag(tagbytecounts, offsetformat, numstrips, [0] * numstrips)
addtag(tag_offsets, offsetformat, numstrips, [0] * numstrips)
if data is None and not contiguous:
raise ValueError("cannot write non-contiguous empty file")
# add extra tags from user
for t in extratags:
addtag(*t)
# TODO: check TIFFReadDirectoryCheckOrder warning in files containing
# multiple tags of same code
# the entries in an IFD must be sorted in ascending order by tag code
tags = sorted(tags, key=lambda x: x[0])
if not (self._bigtiff or self._imagej) and (fh.tell() + datasize > 2**31 - 1):
raise ValueError("data too large for standard TIFF file")
# if not compressed or multi-tiled, write the first IFD and then
# all data contiguously; else, write all IFDs and data interleaved
for pageindex in range(1 if contiguous else shape[0]):
# update pointer at ifd_offset
pos = fh.tell()
if pos % 2:
# location of IFD must begin on a word boundary
fh.write(b"\0")
pos += 1
fh.seek(self._ifdoffset)
fh.write(pack(offsetformat, pos))
fh.seek(pos)
# write ifdentries
fh.write(pack(tagnoformat, len(tags)))
tag_offset = fh.tell()
fh.write(b"".join(t[1] for t in tags))
self._ifdoffset = fh.tell()
fh.write(pack(offsetformat, 0)) # offset to next IFD
# write tag values and patch offsets in ifdentries, if necessary
for tagindex, tag in enumerate(tags):
if tag[2]:
pos = fh.tell()
if pos % 2:
# tag value is expected to begin on word boundary
fh.write(b"\0")
pos += 1
fh.seek(tag_offset + tagindex * tagsize + offsetsize + 4)
fh.write(pack(offsetformat, pos))
fh.seek(pos)
if tag[0] == tag_offsets:
stripoffsetsoffset = pos
elif tag[0] == tagbytecounts:
strip_bytecounts_offset = pos
elif tag[0] == 270 and tag[2].endswith(b"\0\0\0\0"):
# image description buffer
self._descriptionoffset = pos
self._descriptionlenoffset = tag_offset + tagindex * tagsize + 4
fh.write(tag[2])
# write image data
data_offset = fh.tell()
skip = align - data_offset % align
fh.seek(skip, 1)
data_offset += skip
if contiguous:
if data is None:
fh.write_empty(datasize)
else:
fh.write_array(data)
elif tile:
if data is None:
fh.write_empty(numtiles * stripbytecounts[0])
else:
stripindex = 0
for plane in data[pageindex]:
for tz in range(tiles[0]):
for ty in range(tiles[1]):
for tx in range(tiles[2]):
c0 = min(tile[0], shape[2] - tz * tile[0])
c1 = min(tile[1], shape[3] - ty * tile[1])
c2 = min(tile[2], shape[4] - tx * tile[2])
chunk[c0:, c1:, c2:] = 0
chunk[:c0, :c1, :c2] = plane[
tz * tile[0] : tz * tile[0] + c0,
ty * tile[1] : ty * tile[1] + c1,
tx * tile[2] : tx * tile[2] + c2,
]
if compress:
t = compress(chunk)
fh.write(t)
stripbytecounts[stripindex] = len(t)
stripindex += 1
else:
fh.write_array(chunk)
fh.flush()
elif compress:
# write one strip per rowsperstrip
assert data.shape[2] == 1 # not handling depth
numstrips = (shape[-3] + rowsperstrip - 1) // rowsperstrip
stripindex = 0
for plane in data[pageindex]:
for i in range(numstrips):
strip = plane[0, i * rowsperstrip : (i + 1) * rowsperstrip]
strip = compress(strip)
fh.write(strip)
stripbytecounts[stripindex] = len(strip)
stripindex += 1
# update strip/tile offsets and bytecounts if necessary
pos = fh.tell()
for tagindex, tag in enumerate(tags):
if tag[0] == tag_offsets: # strip/tile offsets
if tag[2]:
fh.seek(stripoffsetsoffset)
strip_offset = data_offset
for size in stripbytecounts:
fh.write(pack(offsetformat, strip_offset))
strip_offset += size
else:
fh.seek(tag_offset + tagindex * tagsize + offsetsize + 4)
fh.write(pack(offsetformat, data_offset))
elif tag[0] == tagbytecounts: # strip/tile bytecounts
if compress:
if tag[2]:
fh.seek(strip_bytecounts_offset)
for size in stripbytecounts:
fh.write(pack(offsetformat, size))
else:
fh.seek(tag_offset + tagindex * tagsize + offsetsize + 4)
fh.write(pack(offsetformat, stripbytecounts[0]))
break
fh.seek(pos)
fh.flush()
# remove tags that should be written only once
if pageindex == 0:
tags = [tag for tag in tags if not tag[-1]]
self._shape = shape
self._datashape = (1,) + input_shape
self._datadtype = datadtype
self._dataoffset = data_offset
self._databytecounts = stripbytecounts
if contiguous:
# write remaining IFDs/tags later
self._tags = tags
# return offset and size of image data
if returnoffset:
return data_offset, sum(stripbytecounts)
def _write_remaining_pages(self):
"""Write outstanding IFDs and tags to file."""
if not self._tags or self._truncate:
return
fh = self._fh
fhpos = fh.tell()
if fhpos % 2:
fh.write(b"\0")
fhpos += 1
byteorder = self._byteorder
offsetformat = self._offsetformat
offsetsize = self._offsetsize
tagnoformat = self._tagnoformat
tagsize = self._tagsize
dataoffset = self._dataoffset
pagedatasize = sum(self._databytecounts)
pageno = self._shape[0] * self._datashape[0] - 1
def pack(fmt, *val):
return struct.pack(byteorder + fmt, *val)
# construct template IFD in memory
# need to patch offsets to next IFD and data before writing to disk
ifd = io.BytesIO()
ifd.write(pack(tagnoformat, len(self._tags)))
tagoffset = ifd.tell()
ifd.write(b"".join(t[1] for t in self._tags))
ifdoffset = ifd.tell()
ifd.write(pack(offsetformat, 0)) # offset to next IFD
# tag values
for tagindex, tag in enumerate(self._tags):
offset2value = tagoffset + tagindex * tagsize + offsetsize + 4
if tag[2]:
pos = ifd.tell()
if pos % 2: # tag value is expected to begin on word boundary
ifd.write(b"\0")
pos += 1
ifd.seek(offset2value)
try:
ifd.write(pack(offsetformat, pos + fhpos))
except Exception: # struct.error
if self._imagej:
warnings.warn("truncating ImageJ file")
self._truncate = True
return
raise ValueError("data too large for non-BigTIFF file")
ifd.seek(pos)
ifd.write(tag[2])
if tag[0] == self._tagoffsets:
# save strip/tile offsets for later updates
stripoffset2offset = offset2value
stripoffset2value = pos
elif tag[0] == self._tagoffsets:
# save strip/tile offsets for later updates
stripoffset2offset = None
stripoffset2value = offset2value
# size to word boundary
if ifd.tell() % 2:
ifd.write(b"\0")
# check if all IFDs fit in file
pos = fh.tell()
if not self._bigtiff and pos + ifd.tell() * pageno > 2**32 - 256:
if self._imagej:
warnings.warn("truncating ImageJ file")
self._truncate = True
return
raise ValueError("data too large for non-BigTIFF file")
# TODO: assemble IFD chain in memory
for _ in range(pageno):
# update pointer at IFD offset
pos = fh.tell()
fh.seek(self._ifdoffset)
fh.write(pack(offsetformat, pos))
fh.seek(pos)
self._ifdoffset = pos + ifdoffset
# update strip/tile offsets in IFD
dataoffset += pagedatasize # offset to image data
if stripoffset2offset is None:
ifd.seek(stripoffset2value)
ifd.write(pack(offsetformat, dataoffset))
else:
ifd.seek(stripoffset2offset)
ifd.write(pack(offsetformat, pos + stripoffset2value))
ifd.seek(stripoffset2value)
stripoffset = dataoffset
for size in self._databytecounts:
ifd.write(pack(offsetformat, stripoffset))
stripoffset += size
# write IFD entry
fh.write(ifd.getvalue())
self._tags = None
self._datadtype = None
self._dataoffset = None
self._databytecounts = None
# do not reset _shape or _data_shape
def _write_image_description(self):
"""Write meta data to ImageDescription tag."""
if (
not self._datashape
or self._datashape[0] == 1
or self._descriptionoffset <= 0
):
return
colormapped = self._colormap is not None
if self._imagej:
isrgb = self._shape[-1] in (3, 4)
description = imagej_description(
self._datashape, isrgb, colormapped, **self._metadata
)
else:
description = json_description(self._datashape, **self._metadata)
# rewrite description and its length to file
description = description.encode("utf-8")
description = description[: self._descriptionlen - 1]
pos = self._fh.tell()
self._fh.seek(self._descriptionoffset)
self._fh.write(description)
self._fh.seek(self._descriptionlenoffset)
self._fh.write(
struct.pack(self._byteorder + self._offsetformat, len(description) + 1)
)
self._fh.seek(pos)
self._descriptionoffset = 0
self._descriptionlenoffset = 0
self._descriptionlen = 0
def _now(self):
"""Return current date and time."""
return datetime.datetime.now()
def close(self):
"""Write remaining pages and close file handle."""
if not self._truncate:
self._write_remaining_pages()
self._write_image_description()
self._fh.close()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
class TiffFile(object):
"""Read image and metadata from TIFF file.
TiffFile instances must be closed using the 'close' method, which is
automatically called when using the 'with' context manager.
Attributes
----------
pages : TiffPages
Sequence of TIFF pages in file.
series : list of TiffPageSeries
Sequences of closely related TIFF pages. These are computed
from OME, LSM, ImageJ, etc. metadata or based on similarity
of page properties such as shape, dtype, and compression.
byteorder : '>', '<'
The endianness of data in the file.
'>': big-endian (Motorola).
'>': little-endian (Intel).
is_flag : bool
If True, file is of a certain format.
Flags are: bigtiff, movie, shaped, ome, imagej, stk, lsm, fluoview,
nih, vista, 'micromanager, metaseries, mdgel, mediacy, tvips, fei,
sem, scn, svs, scanimage, andor, epics, pilatus, qptiff.
All attributes are read-only.
Examples
--------
>>> # read image array from TIFF file
>>> imsave('temp.tif', numpy.random.rand(5, 301, 219))
>>> with TiffFile('temp.tif') as tif:
... data = tif.asarray()
>>> data.shape
(5, 301, 219)
"""
def __init__(
self,
arg,
name=None,
offset=None,
size=None,
multifile=True,
movie=None,
**kwargs
):
"""Initialize instance from file.
Parameters
----------
arg : str or open file
Name of file or open file object.
The file objects are closed in TiffFile.close().
name : str
Optional name of file in case 'arg' is a file handle.
offset : int
Optional start position of embedded file. By default, this is
the current file position.
size : int
Optional size of embedded file. By default, this is the number
of bytes from the 'offset' to the end of the file.
multifile : bool
If True (default), series may include pages from multiple files.
Currently applies to OME-TIFF only.
movie : bool
If True, assume that later pages differ from first page only by
data offsets and byte counts. Significantly increases speed and
reduces memory usage when reading movies with thousands of pages.
Enabling this for non-movie files will result in data corruption
or crashes. Python 3 only.
kwargs : bool
'is_ome': If False, disable processing of OME-XML metadata.
"""
if "fastij" in kwargs:
del kwargs["fastij"]
raise DeprecationWarning("the fastij option will be removed")
for key, value in kwargs.items():
if key[:3] == "is_" and key[3:] in TIFF.FILE_FLAGS:
if value is not None and not value:
setattr(self, key, bool(value))
else:
raise TypeError("unexpected keyword argument: %s" % key)
fh = FileHandle(arg, mode="rb", name=name, offset=offset, size=size)
self._fh = fh
self._multifile = bool(multifile)
self._files = {fh.name: self} # cache of TiffFiles
try:
fh.seek(0)
try:
byteorder = {b"II": "<", b"MM": ">"}[fh.read(2)]
except KeyError:
raise ValueError("not a TIFF file")
sys_byteorder = {"big": ">", "little": "<"}[sys.byteorder]
self.isnative = byteorder == sys_byteorder
version = struct.unpack(byteorder + "H", fh.read(2))[0]
if version == 43:
# BigTiff
self.is_bigtiff = True
offsetsize, zero = struct.unpack(byteorder + "HH", fh.read(4))
if zero or offsetsize != 8:
raise ValueError("invalid BigTIFF file")
self.byteorder = byteorder
self.offsetsize = 8
self.offsetformat = byteorder + "Q"
self.tagnosize = 8
self.tagnoformat = byteorder + "Q"
self.tagsize = 20
self.tagformat1 = byteorder + "HH"
self.tagformat2 = byteorder + "Q8s"
elif version == 42:
self.is_bigtiff = False
self.byteorder = byteorder
self.offsetsize = 4
self.offsetformat = byteorder + "I"
self.tagnosize = 2
self.tagnoformat = byteorder + "H"
self.tagsize = 12
self.tagformat1 = byteorder + "HH"
self.tagformat2 = byteorder + "I4s"
else:
raise ValueError("invalid TIFF file")
# file handle is at offset to offset to first page
self.pages = TiffPages(self)
if self.is_lsm and (
self.filehandle.size >= 2**32
or self.pages[0].compression != 1
or self.pages[1].compression != 1
):
self._lsm_load_pages()
self._lsm_fix_strip_offsets()
self._lsm_fix_strip_bytecounts()
elif movie:
self.pages.useframes = True
except Exception:
fh.close()
raise
@property
def filehandle(self):
"""Return file handle."""
return self._fh
@property
def filename(self):
"""Return name of file handle."""
return self._fh.name
@lazyattr
def fstat(self):
"""Return status of file handle as stat_result object."""
try:
return os.fstat(self._fh.fileno())
except Exception: # io.UnsupportedOperation
return None
def close(self):
"""Close open file handle(s)."""
for tif in self._files.values():
tif.filehandle.close()
self._files = {}
def asarray(self, key=None, series=None, out=None, validate=True, maxworkers=1):
"""Return image data from multiple TIFF pages as numpy array.
By default, the data from the first series is returned.
Parameters
----------
key : int, slice, or sequence of page indices
Defines which pages to return as array.
series : int or TiffPageSeries
Defines which series of pages to return as array.
out : numpy.ndarray, str, or file-like object; optional
Buffer where image data will be saved.
If None (default), a new array will be created.
If numpy.ndarray, a writable array of compatible dtype and shape.
If 'memmap', directly memory-map the image data in the TIFF file
if possible; else create a memory-mapped array in a temporary file.
If str or open file, the file name or file object used to
create a memory-map to an array stored in a binary file on disk.
validate : bool
If True (default), validate various tags.
Passed to TiffPage.asarray().
maxworkers : int
Maximum number of threads to concurrently get data from pages.
Default is 1. If None, up to half the CPU cores are used.
Reading data from file is limited to a single thread.
Using multiple threads can significantly speed up this function
if the bottleneck is decoding compressed data, e.g. in case of
large LZW compressed LSM files.
If the bottleneck is I/O or pure Python code, using multiple
threads might be detrimental.
"""
if not self.pages:
return numpy.array([])
if key is None and series is None:
series = 0
if series is not None:
try:
series = self.series[series]
except (KeyError, TypeError):
pass
pages = series._pages
else:
pages = self.pages
if key is None:
pass
elif isinstance(key, inttypes):
pages = [pages[key]]
elif isinstance(key, slice):
pages = pages[key]
elif isinstance(key, collections.Iterable):
pages = [pages[k] for k in key]
else:
raise TypeError("key must be an int, slice, or sequence")
if not pages:
raise ValueError("no pages selected")
if self.is_nih:
result = stack_pages(pages, out=out, maxworkers=maxworkers, squeeze=False)
elif key is None and series and series.offset:
typecode = self.byteorder + series.dtype.char
if out == "memmap" and pages[0].is_memmappable:
result = self.filehandle.memmap_array(
typecode, series.shape, series.offset
)
else:
if out is not None:
out = create_output(out, series.shape, series.dtype)
self.filehandle.seek(series.offset)
result = self.filehandle.read_array(
typecode, product(series.shape), out=out, native=True
)
elif len(pages) == 1:
result = pages[0].asarray(out=out, validate=validate)
else:
result = stack_pages(pages, out=out, maxworkers=maxworkers)
if result is None:
return
if key is None:
try:
result.shape = series.shape
except ValueError:
try:
warnings.warn(
"failed to reshape %s to %s" % (result.shape, series.shape)
)
# try series of expected shapes
result.shape = (-1,) + series.shape
except ValueError:
# revert to generic shape
result.shape = (-1,) + pages[0].shape
elif len(pages) == 1:
result.shape = pages[0].shape
else:
result.shape = (-1,) + pages[0].shape
return result
@lazyattr
def series(self):
"""Return related pages as TiffPageSeries.
Side effect: after calling this function, TiffFile.pages might contain
TiffPage and TiffFrame instances.
"""
if not self.pages:
return []
useframes = self.pages.useframes
keyframe = self.pages.keyframe
series = []
for name in "ome imagej lsm fluoview nih mdgel shaped".split():
if getattr(self, "is_" + name, False):
series = getattr(self, "_%s_series" % name)()
break
self.pages.useframes = useframes
self.pages.keyframe = keyframe
if not series:
series = self._generic_series()
# remove empty series, e.g. in MD Gel files
series = [s for s in series if sum(s.shape) > 0]
for i, s in enumerate(series):
s.index = i
return series
def _generic_series(self):
"""Return image series in file."""
if self.pages.useframes:
# movie mode
page = self.pages[0]
shape = page.shape
axes = page.axes
if len(self.pages) > 1:
shape = (len(self.pages),) + shape
axes = "I" + axes
return [
TiffPageSeries(self.pages[:], shape, page.dtype, axes, stype="movie")
]
self.pages.clear(False)
self.pages.load()
result = []
keys = []
series = {}
compressions = TIFF.DECOMPESSORS
for page in self.pages:
if not page.shape:
continue
key = page.shape + (page.axes, page.compression in compressions)
if key in series:
series[key].append(page)
else:
keys.append(key)
series[key] = [page]
for key in keys:
pages = series[key]
page = pages[0]
shape = page.shape
axes = page.axes
if len(pages) > 1:
shape = (len(pages),) + shape
axes = "I" + axes
result.append(
TiffPageSeries(pages, shape, page.dtype, axes, stype="Generic")
)
return result
def _shaped_series(self):
"""Return image series in "shaped" file."""
pages = self.pages
pages.useframes = True
lenpages = len(pages)
def append_series(series, pages, axes, shape, reshape, name, truncated):
page = pages[0]
if not axes:
shape = page.shape
axes = page.axes
if len(pages) > 1:
shape = (len(pages),) + shape
axes = "Q" + axes
size = product(shape)
resize = product(reshape)
if page.is_contiguous and resize > size and resize % size == 0:
if truncated is None:
truncated = True
axes = "Q" + axes
shape = (resize // size,) + shape
try:
axes = reshape_axes(axes, shape, reshape)
shape = reshape
except ValueError as e:
warnings.warn(str(e))
series.append(
TiffPageSeries(
pages,
shape,
page.dtype,
axes,
name=name,
stype="Shaped",
truncated=truncated,
)
)
keyframe = axes = shape = reshape = name = None
series = []
index = 0
while True:
if index >= lenpages:
break
# new keyframe; start of new series
pages.keyframe = index
keyframe = pages[index]
if not keyframe.is_shaped:
warnings.warn("invalid shape metadata or corrupted file")
return
# read metadata
axes = None
shape = None
metadata = json_description_metadata(keyframe.is_shaped)
name = metadata.get("name", "")
reshape = metadata["shape"]
truncated = metadata.get("truncated", None)
if "axes" in metadata:
axes = metadata["axes"]
if len(axes) == len(reshape):
shape = reshape
else:
axes = ""
warnings.warn("axes do not match shape")
# skip pages if possible
spages = [keyframe]
size = product(reshape)
npages, mod = divmod(size, product(keyframe.shape))
if mod:
warnings.warn("series shape does not match page shape")
return
if 1 < npages <= lenpages - index:
size *= keyframe._dtype.itemsize
if truncated:
npages = 1
elif (
keyframe.is_final
and keyframe.offset + size < pages[index + 1].offset
):
truncated = False
else:
# need to read all pages for series
truncated = False
for j in range(index + 1, index + npages):
page = pages[j]
page.keyframe = keyframe
spages.append(page)
append_series(series, spages, axes, shape, reshape, name, truncated)
index += npages
return series
def _imagej_series(self):
"""Return image series in ImageJ file."""
# ImageJ's dimension order is always TZCYXS
# TODO: fix loading of color, composite, or palette images
self.pages.useframes = True
self.pages.keyframe = 0
ij = self.imagej_metadata
pages = self.pages
page = pages[0]
def is_hyperstack():
# ImageJ hyperstack store all image metadata in the first page and
# image data are stored contiguously before the second page, if any
if not page.is_final:
return False
images = ij.get("images", 0)
if images <= 1:
return False
offset, count = page.is_contiguous
if (
count != product(page.shape) * page.bitspersample // 8
or offset + count * images > self.filehandle.size
):
raise ValueError()
# check that next page is stored after data
if len(pages) > 1 and offset + count * images > pages[1].offset:
return False
return True
try:
hyperstack = is_hyperstack()
except ValueError:
warnings.warn("invalid ImageJ metadata or corrupted file")
return
if hyperstack:
# no need to read other pages
pages = [page]
else:
self.pages.load()
shape = []
axes = []
if "frames" in ij:
shape.append(ij["frames"])
axes.append("T")
if "slices" in ij:
shape.append(ij["slices"])
axes.append("Z")
if "channels" in ij and not (
page.photometric == 2 and not ij.get("hyperstack", False)
):
shape.append(ij["channels"])
axes.append("C")
remain = ij.get("images", len(pages)) // (product(shape) if shape else 1)
if remain > 1:
shape.append(remain)
axes.append("I")
if page.axes[0] == "I":
# contiguous multiple images
shape.extend(page.shape[1:])
axes.extend(page.axes[1:])
elif page.axes[:2] == "SI":
# color-mapped contiguous multiple images
shape = page.shape[0:1] + tuple(shape) + page.shape[2:]
axes = list(page.axes[0]) + axes + list(page.axes[2:])
else:
shape.extend(page.shape)
axes.extend(page.axes)
truncated = (
hyperstack
and len(self.pages) == 1
and page.is_contiguous[1] != product(shape) * page.bitspersample // 8
)
return [
TiffPageSeries(
pages, shape, page.dtype, axes, stype="ImageJ", truncated=truncated
)
]
def _fluoview_series(self):
"""Return image series in FluoView file."""
self.pages.useframes = True
self.pages.keyframe = 0
self.pages.load()
mm = self.fluoview_metadata
mmhd = list(reversed(mm["Dimensions"]))
axes = "".join(
TIFF.MM_DIMENSIONS.get(i[0].upper(), "Q") for i in mmhd if i[1] > 1
)
shape = tuple(int(i[1]) for i in mmhd if i[1] > 1)
return [
TiffPageSeries(
self.pages,
shape,
self.pages[0].dtype,
axes,
name=mm["ImageName"],
stype="FluoView",
)
]
def _mdgel_series(self):
"""Return image series in MD Gel file."""
# only a single page, scaled according to metadata in second page
self.pages.useframes = False
self.pages.keyframe = 0
self.pages.load()
md = self.mdgel_metadata
if md["FileTag"] in (2, 128):
dtype = numpy.dtype("float32")
scale = md["ScalePixel"]
scale = scale[0] / scale[1] # rational
if md["FileTag"] == 2:
# squary root data format
def transform(a):
return a.astype("float32") ** 2 * scale
else:
def transform(a):
return a.astype("float32") * scale
else:
transform = None
page = self.pages[0]
return [
TiffPageSeries(
[page], page.shape, dtype, page.axes, transform=transform, stype="MDGel"
)
]
def _nih_series(self):
"""Return image series in NIH file."""
self.pages.useframes = True
self.pages.keyframe = 0
self.pages.load()
page0 = self.pages[0]
if len(self.pages) == 1:
shape = page0.shape
axes = page0.axes
else:
shape = (len(self.pages),) + page0.shape
axes = "I" + page0.axes
return [TiffPageSeries(self.pages, shape, page0.dtype, axes, stype="NIH")]
def _ome_series(self):
"""Return image series in OME-TIFF file(s)."""
from xml.etree import cElementTree as etree # delayed import
omexml = self.pages[0].description
try:
root = etree.fromstring(omexml)
except etree.ParseError as e:
# TODO: test badly encoded OME-XML
warnings.warn("ome-xml: %s" % e)
try:
# might work on Python 2
omexml = omexml.decode("utf-8", "ignore").encode("utf-8")
root = etree.fromstring(omexml)
except Exception:
return
self.pages.useframes = True
self.pages.keyframe = 0
self.pages.load()
uuid = root.attrib.get("UUID", None)
self._files = {uuid: self}
dirname = self._fh.dirname
modulo = {}
series = []
for element in root:
if element.tag.endswith("BinaryOnly"):
# TODO: load OME-XML from master or companion file
warnings.warn("ome-xml: not an ome-tiff master file")
break
if element.tag.endswith("StructuredAnnotations"):
for annot in element:
if not annot.attrib.get("Namespace", "").endswith("modulo"):
continue
for value in annot:
for modul in value:
for along in modul:
if not along.tag[:-1].endswith("Along"):
continue
axis = along.tag[-1]
newaxis = along.attrib.get("Type", "other")
newaxis = TIFF.AXES_LABELS[newaxis]
if "Start" in along.attrib:
step = float(along.attrib.get("Step", 1))
start = float(along.attrib["Start"])
stop = float(along.attrib["End"]) + step
labels = numpy.arange(start, stop, step)
else:
labels = [
label.text
for label in along
if label.tag.endswith("Label")
]
modulo[axis] = (newaxis, labels)
if not element.tag.endswith("Image"):
continue
attr = element.attrib
name = attr.get("Name", None)
for pixels in element:
if not pixels.tag.endswith("Pixels"):
continue
attr = pixels.attrib
dtype = attr.get("PixelType", None)
axes = "".join(reversed(attr["DimensionOrder"]))
shape = list(int(attr["Size" + ax]) for ax in axes)
size = product(shape[:-2])
ifds = None
spp = 1 # samples per pixel
# FIXME: this implementation assumes the last two
# dimensions are stored in tiff pages (shape[:-2]).
# Apparently that is not always the case.
for data in pixels:
if data.tag.endswith("Channel"):
attr = data.attrib
if ifds is None:
spp = int(attr.get("SamplesPerPixel", spp))
ifds = [None] * (size // spp)
elif int(attr.get("SamplesPerPixel", 1)) != spp:
raise ValueError("cannot handle differing SamplesPerPixel")
continue
if ifds is None:
ifds = [None] * (size // spp)
if not data.tag.endswith("TiffData"):
continue
attr = data.attrib
ifd = int(attr.get("IFD", 0))
num = int(attr.get("NumPlanes", 1 if "IFD" in attr else 0))
num = int(attr.get("PlaneCount", num))
idx = [int(attr.get("First" + ax, 0)) for ax in axes[:-2]]
try:
idx = numpy.ravel_multi_index(idx, shape[:-2])
except ValueError:
# ImageJ produces invalid ome-xml when cropping
warnings.warn("ome-xml: invalid TiffData index")
continue
for uuid in data:
if not uuid.tag.endswith("UUID"):
continue
if uuid.text not in self._files:
if not self._multifile:
# abort reading multifile OME series
# and fall back to generic series
return []
fname = uuid.attrib["FileName"]
try:
tif = TiffFile(os.path.join(dirname, fname))
tif.pages.useframes = True
tif.pages.keyframe = 0
tif.pages.load()
except (IOError, FileNotFoundError, ValueError):
warnings.warn("ome-xml: failed to read '%s'" % fname)
break
self._files[uuid.text] = tif
tif.close()
pages = self._files[uuid.text].pages
try:
for i in range(num if num else len(pages)):
ifds[idx + i] = pages[ifd + i]
except IndexError:
warnings.warn("ome-xml: index out of range")
# only process first UUID
break
else:
pages = self.pages
try:
for i in range(num if num else len(pages)):
ifds[idx + i] = pages[ifd + i]
except IndexError:
warnings.warn("ome-xml: index out of range")
if all(i is None for i in ifds):
# skip images without data
continue
# set a keyframe on all IFDs
keyframe = None
for i in ifds:
# try find a TiffPage
if i and i == i.keyframe:
keyframe = i
break
if not keyframe:
# reload a TiffPage from file
for i, keyframe in enumerate(ifds):
if keyframe:
keyframe.parent.pages.keyframe = keyframe.index
keyframe = keyframe.parent.pages[keyframe.index]
ifds[i] = keyframe
break
for i in ifds:
if i is not None:
i.keyframe = keyframe
dtype = keyframe.dtype
series.append(
TiffPageSeries(
ifds, shape, dtype, axes, parent=self, name=name, stype="OME"
)
)
for serie in series:
shape = list(serie.shape)
for axis, (newaxis, labels) in modulo.items():
i = serie.axes.index(axis)
size = len(labels)
if shape[i] == size:
serie.axes = serie.axes.replace(axis, newaxis, 1)
else:
shape[i] //= size
shape.insert(i + 1, size)
serie.axes = serie.axes.replace(axis, axis + newaxis, 1)
serie.shape = tuple(shape)
# squeeze dimensions
for serie in series:
serie.shape, serie.axes = squeeze_axes(serie.shape, serie.axes)
return series
def _lsm_series(self):
"""Return main image series in LSM file. Skip thumbnails."""
lsmi = self.lsm_metadata
axes = TIFF.CZ_LSMINFO_SCANTYPE[lsmi["ScanType"]]
if self.pages[0].photometric == 2: # RGB; more than one channel
axes = axes.replace("C", "").replace("XY", "XYC")
if lsmi.get("DimensionP", 0) > 1:
axes += "P"
if lsmi.get("DimensionM", 0) > 1:
axes += "M"
axes = axes[::-1]
shape = tuple(int(lsmi[TIFF.CZ_LSMINFO_DIMENSIONS[i]]) for i in axes)
name = lsmi.get("Name", "")
self.pages.keyframe = 0
pages = self.pages[::2]
dtype = pages[0].dtype
series = [TiffPageSeries(pages, shape, dtype, axes, name=name, stype="LSM")]
if self.pages[1].is_reduced:
self.pages.keyframe = 1
pages = self.pages[1::2]
dtype = pages[0].dtype
cp, i = 1, 0
while cp < len(pages) and i < len(shape) - 2:
cp *= shape[i]
i += 1
shape = shape[:i] + pages[0].shape
axes = axes[:i] + "CYX"
series.append(
TiffPageSeries(pages, shape, dtype, axes, name=name, stype="LSMreduced")
)
return series
def _lsm_load_pages(self):
"""Load all pages from LSM file."""
self.pages.cache = True
self.pages.useframes = True
# second series: thumbnails
self.pages.keyframe = 1
keyframe = self.pages[1]
for page in self.pages[1::2]:
page.keyframe = keyframe
# first series: data
self.pages.keyframe = 0
keyframe = self.pages[0]
for page in self.pages[::2]:
page.keyframe = keyframe
def _lsm_fix_strip_offsets(self):
"""Unwrap strip offsets for LSM files greater than 4 GB.
Each series and position require separate unwrapping (undocumented).
"""
if self.filehandle.size < 2**32:
return
pages = self.pages
npages = len(pages)
series = self.series[0]
axes = series.axes
# find positions
positions = 1
for i in 0, 1:
if series.axes[i] in "PM":
positions *= series.shape[i]
# make time axis first
if positions > 1:
ntimes = 0
for i in 1, 2:
if axes[i] == "T":
ntimes = series.shape[i]
break
if ntimes:
div, mod = divmod(npages, 2 * positions * ntimes)
assert mod == 0
shape = (positions, ntimes, div, 2)
indices = numpy.arange(product(shape)).reshape(shape)
indices = numpy.moveaxis(indices, 1, 0)
else:
indices = numpy.arange(npages).reshape(-1, 2)
# images of reduced page might be stored first
if pages[0].dataoffsets[0] > pages[1].dataoffsets[0]:
indices = indices[..., ::-1]
# unwrap offsets
wrap = 0
previousoffset = 0
for i in indices.flat:
page = pages[i]
dataoffsets = []
for currentoffset in page.dataoffsets:
if currentoffset < previousoffset:
wrap += 2**32
dataoffsets.append(currentoffset + wrap)
previousoffset = currentoffset
page.dataoffsets = tuple(dataoffsets)
def _lsm_fix_strip_bytecounts(self):
"""Set databytecounts to size of compressed data.
The StripByteCounts tag in LSM files contains the number of bytes
for the uncompressed data.
"""
pages = self.pages
if pages[0].compression == 1:
return
# sort pages by first strip offset
pages = sorted(pages, key=lambda p: p.dataoffsets[0])
npages = len(pages) - 1
for i, page in enumerate(pages):
if page.index % 2:
continue
offsets = page.dataoffsets
bytecounts = page.databytecounts
if i < npages:
lastoffset = pages[i + 1].dataoffsets[0]
else:
# LZW compressed strips might be longer than uncompressed
lastoffset = min(offsets[-1] + 2 * bytecounts[-1], self._fh.size)
offsets = offsets + (lastoffset,)
page.databytecounts = tuple(
offsets[j + 1] - offsets[j] for j in range(len(bytecounts))
)
def __getattr__(self, name):
"""Return 'is_flag' attributes from first page."""
if name[3:] in TIFF.FILE_FLAGS:
if not self.pages:
return False
value = bool(getattr(self.pages[0], name))
setattr(self, name, value)
return value
raise AttributeError(
"'%s' object has no attribute '%s'" % (self.__class__.__name__, name)
)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def __str__(self, detail=0, width=79):
"""Return string containing information about file.
The detail parameter specifies the level of detail returned:
0: file only.
1: all series, first page of series and its tags.
2: large tag values and file metadata.
3: all pages.
"""
info = [
"TiffFile '%s'",
format_size(self._fh.size),
{"<": "LittleEndian", ">": "BigEndian"}[self.byteorder],
]
if self.is_bigtiff:
info.append("BigTiff")
info.append("|".join(f.upper() for f in self.flags))
if len(self.pages) > 1:
info.append("%i Pages" % len(self.pages))
if len(self.series) > 1:
info.append("%i Series" % len(self.series))
if len(self._files) > 1:
info.append("%i Files" % (len(self._files)))
info = " ".join(info)
info = info.replace(" ", " ").replace(" ", " ")
info = info % snipstr(self._fh.name, max(12, width + 2 - len(info)))
if detail <= 0:
return info
info = [info]
info.append("\n".join(str(s) for s in self.series))
if detail >= 3:
info.extend(
(
TiffPage.__str__(p, detail=detail, width=width)
for p in self.pages
if p is not None
)
)
else:
info.extend(
(
TiffPage.__str__(s.pages[0], detail=detail, width=width)
for s in self.series
if s.pages[0] is not None
)
)
if detail >= 2:
for name in sorted(self.flags):
if hasattr(self, name + "_metadata"):
m = getattr(self, name + "_metadata")
if m:
info.append(
"%s_METADATA\n%s"
% (
name.upper(),
pformat(m, width=width, height=detail * 12),
)
)
return "\n\n".join(info).replace("\n\n\n", "\n\n")
@lazyattr
def flags(self):
"""Return set of file flags."""
return set(
name.lower()
for name in sorted(TIFF.FILE_FLAGS)
if getattr(self, "is_" + name)
)
@lazyattr
def is_mdgel(self):
"""File has MD Gel format."""
try:
return self.pages[0].is_mdgel or self.pages[1].is_mdgel
except IndexError:
return False
@property
def is_movie(self):
"""Return if file is a movie."""
return self.pages.useframes
@lazyattr
def shaped_metadata(self):
"""Return Tifffile metadata from JSON descriptions as dicts."""
if not self.is_shaped:
return
return tuple(
json_description_metadata(s.pages[0].is_shaped)
for s in self.series
if s.stype.lower() == "shaped"
)
@lazyattr
def ome_metadata(self):
"""Return OME XML as dict."""
# TODO: remove this or return XML?
if not self.is_ome:
return
return xml2dict(self.pages[0].description)["OME"]
@lazyattr
def qptiff_metadata(self):
"""Return PerkinElmer-QPI-ImageDescription XML element as dict."""
if not self.is_qptiff:
return
root = "PerkinElmer-QPI-ImageDescription"
xml = self.pages[0].description.replace(" " + root + " ", root)
return xml2dict(xml)[root]
@lazyattr
def lsm_metadata(self):
"""Return LSM metadata from CZ_LSMINFO tag as dict."""
if not self.is_lsm:
return
return self.pages[0].tags["CZ_LSMINFO"].value
@lazyattr
def stk_metadata(self):
"""Return STK metadata from UIC tags as dict."""
if not self.is_stk:
return
page = self.pages[0]
tags = page.tags
result = {}
result["NumberPlanes"] = tags["UIC2tag"].count
if page.description:
result["PlaneDescriptions"] = page.description.split("\0")
# result['plane_descriptions'] = stk_description_metadata(
# page.image_description)
if "UIC1tag" in tags:
result.update(tags["UIC1tag"].value)
if "UIC3tag" in tags:
result.update(tags["UIC3tag"].value) # wavelengths
if "UIC4tag" in tags:
result.update(tags["UIC4tag"].value) # override uic1 tags
uic2tag = tags["UIC2tag"].value
result["ZDistance"] = uic2tag["ZDistance"]
result["TimeCreated"] = uic2tag["TimeCreated"]
result["TimeModified"] = uic2tag["TimeModified"]
try:
result["DatetimeCreated"] = numpy.array(
[
julian_datetime(*dt)
for dt in zip(uic2tag["DateCreated"], uic2tag["TimeCreated"])
],
dtype="datetime64[ns]",
)
result["DatetimeModified"] = numpy.array(
[
julian_datetime(*dt)
for dt in zip(uic2tag["DateModified"], uic2tag["TimeModified"])
],
dtype="datetime64[ns]",
)
except ValueError as e:
warnings.warn("stk_metadata: %s" % e)
return result
@lazyattr
def imagej_metadata(self):
"""Return consolidated ImageJ metadata as dict."""
if not self.is_imagej:
return
page = self.pages[0]
result = imagej_description_metadata(page.is_imagej)
if "IJMetadata" in page.tags:
try:
result.update(page.tags["IJMetadata"].value)
except Exception:
pass
return result
@lazyattr
def fluoview_metadata(self):
"""Return consolidated FluoView metadata as dict."""
if not self.is_fluoview:
return
result = {}
page = self.pages[0]
result.update(page.tags["MM_Header"].value)
# TODO: read stamps from all pages
result["Stamp"] = page.tags["MM_Stamp"].value
# skip parsing image description; not reliable
# try:
# t = fluoview_description_metadata(page.image_description)
# if t is not None:
# result['ImageDescription'] = t
# except Exception as e:
# warnings.warn(
# "failed to read FluoView image description: %s" % e)
return result
@lazyattr
def nih_metadata(self):
"""Return NIH Image metadata from NIHImageHeader tag as dict."""
if not self.is_nih:
return
return self.pages[0].tags["NIHImageHeader"].value
@lazyattr
def fei_metadata(self):
"""Return FEI metadata from SFEG or HELIOS tags as dict."""
if not self.is_fei:
return
tags = self.pages[0].tags
if "FEI_SFEG" in tags:
return tags["FEI_SFEG"].value
if "FEI_HELIOS" in tags:
return tags["FEI_HELIOS"].value
@lazyattr
def sem_metadata(self):
"""Return SEM metadata from CZ_SEM tag as dict."""
if not self.is_sem:
return
return self.pages[0].tags["CZ_SEM"].value
@lazyattr
def mdgel_metadata(self):
"""Return consolidated metadata from MD GEL tags as dict."""
for page in self.pages[:2]:
if "MDFileTag" in page.tags:
tags = page.tags
break
else:
return
result = {}
for code in range(33445, 33453):
name = TIFF.TAGS[code]
if name not in tags:
continue
result[name[2:]] = tags[name].value
return result
@lazyattr
def andor_metadata(self):
"""Return Andor tags as dict."""
return self.pages[0].andor_tags
@lazyattr
def epics_metadata(self):
"""Return EPICS areaDetector tags as dict."""
return self.pages[0].epics_tags
@lazyattr
def tvips_metadata(self):
"""Return TVIPS tag as dict."""
if not self.is_tvips:
return
return self.pages[0].tags["TVIPS"].value
@lazyattr
def metaseries_metadata(self):
"""Return MetaSeries metadata from image description as dict."""
if not self.is_metaseries:
return
return metaseries_description_metadata(self.pages[0].description)
@lazyattr
def pilatus_metadata(self):
"""Return Pilatus metadata from image description as dict."""
if not self.is_pilatus:
return
return pilatus_description_metadata(self.pages[0].description)
@lazyattr
def micromanager_metadata(self):
"""Return consolidated MicroManager metadata as dict."""
if not self.is_micromanager:
return
# from file header
result = read_micromanager_metadata(self._fh)
# from tag
result.update(self.pages[0].tags["MicroManagerMetadata"].value)
return result
@lazyattr
def scanimage_metadata(self):
"""Return ScanImage non-varying frame and ROI metadata as dict."""
if not self.is_scanimage:
return
result = {}
try:
framedata, roidata = read_scanimage_metadata(self._fh)
result["FrameData"] = framedata
result.update(roidata)
except ValueError:
pass
# TODO: scanimage_artist_metadata
try:
result["Description"] = scanimage_description_metadata(
self.pages[0].description
)
except Exception as e:
warnings.warn("scanimage_description_metadata failed: %s" % e)
return result
@property
def geotiff_metadata(self):
"""Return GeoTIFF metadata from first page as dict."""
if not self.is_geotiff:
return
return self.pages[0].geotiff_tags
class TiffPages(object):
"""Sequence of TIFF image file directories."""
def __init__(self, parent):
"""Initialize instance from file. Read first TiffPage from file.
The file position must be at an offset to an offset to a TiffPage.
"""
self.parent = parent
self.pages = [] # cache of TiffPages, TiffFrames, or their offsets
self.complete = False # True if offsets to all pages were read
self._tiffpage = TiffPage # class for reading tiff pages
self._keyframe = None
self._cache = True
# read offset to first page
fh = parent.filehandle
self._nextpageoffset = fh.tell()
offset = struct.unpack(parent.offsetformat, fh.read(parent.offsetsize))[0]
if offset == 0:
# warnings.warn('file contains no pages')
self.complete = True
return
if offset >= fh.size:
warnings.warn("invalid page offset (%i)" % offset)
self.complete = True
return
# always read and cache first page
fh.seek(offset)
page = TiffPage(parent, index=0)
self.pages.append(page)
self._keyframe = page
@property
def cache(self):
"""Return if pages/frames are currently being cached."""
return self._cache
@cache.setter
def cache(self, value):
"""Enable or disable caching of pages/frames. Clear cache if False."""
value = bool(value)
if self._cache and not value:
self.clear()
self._cache = value
@property
def useframes(self):
"""Return if currently using TiffFrame (True) or TiffPage (False)."""
return self._tiffpage == TiffFrame and TiffFrame is not TiffPage
@useframes.setter
def useframes(self, value):
"""Set to use TiffFrame (True) or TiffPage (False)."""
self._tiffpage = TiffFrame if value else TiffPage
@property
def keyframe(self):
"""Return index of current keyframe."""
return self._keyframe.index
@keyframe.setter
def keyframe(self, index):
"""Set current keyframe. Load TiffPage from file if necessary."""
if self._keyframe.index == index:
return
if self.complete or 0 <= index < len(self.pages):
page = self.pages[index]
if isinstance(page, TiffPage):
self._keyframe = page
return
elif isinstance(page, TiffFrame):
# remove existing frame
self.pages[index] = page.offset
# load TiffPage from file
useframes = self.useframes
self._tiffpage = TiffPage
self._keyframe = self[index]
self.useframes = useframes
@property
def next_page_offset(self):
"""Return offset where offset to a new page can be stored."""
if not self.complete:
self._seek(-1)
return self._nextpageoffset
def load(self):
"""Read all remaining pages from file."""
fh = self.parent.filehandle
keyframe = self._keyframe
pages = self.pages
if not self.complete:
self._seek(-1)
for i, page in enumerate(pages):
if isinstance(page, inttypes):
fh.seek(page)
page = self._tiffpage(self.parent, index=i, keyframe=keyframe)
pages[i] = page
def clear(self, fully=True):
"""Delete all but first page from cache. Set keyframe to first page."""
pages = self.pages
if not self._cache or len(pages) < 1:
return
self._keyframe = pages[0]
if fully:
# delete all but first TiffPage/TiffFrame
for i, page in enumerate(pages[1:]):
if not isinstance(page, inttypes):
pages[i + 1] = page.offset
elif TiffFrame is not TiffPage:
# delete only TiffFrames
for i, page in enumerate(pages):
if isinstance(page, TiffFrame):
pages[i] = page.offset
def _seek(self, index, maxpages=2**22):
"""Seek file to offset of specified page."""
pages = self.pages
if not pages:
return
fh = self.parent.filehandle
if fh.closed:
raise RuntimeError("FileHandle is closed")
if self.complete or 0 <= index < len(pages):
page = pages[index]
offset = page if isinstance(page, inttypes) else page.offset
fh.seek(offset)
return
offsetformat = self.parent.offsetformat
offsetsize = self.parent.offsetsize
tagnoformat = self.parent.tagnoformat
tagnosize = self.parent.tagnosize
tagsize = self.parent.tagsize
unpack = struct.unpack
page = pages[-1]
offset = page if isinstance(page, inttypes) else page.offset
while len(pages) < maxpages:
# read offsets to pages from file until index is reached
fh.seek(offset)
# skip tags
try:
tagno = unpack(tagnoformat, fh.read(tagnosize))[0]
if tagno > 4096:
raise ValueError("suspicious number of tags")
except Exception:
warnings.warn("corrupted tag list at offset %i" % offset)
del pages[-1]
self.complete = True
break
self._nextpageoffset = offset + tagnosize + tagno * tagsize
fh.seek(self._nextpageoffset)
# read offset to next page
offset = unpack(offsetformat, fh.read(offsetsize))[0]
if offset == 0:
self.complete = True
break
if offset >= fh.size:
warnings.warn("invalid page offset (%i)" % offset)
self.complete = True
break
pages.append(offset)
if 0 <= index < len(pages):
break
if index >= len(pages):
raise IndexError("list index out of range")
page = pages[index]
fh.seek(page if isinstance(page, inttypes) else page.offset)
def __bool__(self):
"""Return True if file contains any pages."""
return len(self.pages) > 0
def __len__(self):
"""Return number of pages in file."""
if not self.complete:
self._seek(-1)
return len(self.pages)
def __getitem__(self, key):
"""Return specified page(s) from cache or file."""
pages = self.pages
if not pages:
raise IndexError("list index out of range")
if key == 0:
return pages[key]
if isinstance(key, slice):
start, stop, _ = key.indices(2**31 - 1)
if not self.complete and max(stop, start) > len(pages):
self._seek(-1)
return [self[i] for i in range(*key.indices(len(pages)))]
if self.complete and key >= len(pages):
raise IndexError("list index out of range")
try:
page = pages[key]
except IndexError:
page = 0
if not isinstance(page, inttypes):
return page
self._seek(key)
page = self._tiffpage(self.parent, index=key, keyframe=self._keyframe)
if self._cache:
pages[key] = page
return page
def __iter__(self):
"""Return iterator over all pages."""
i = 0
while True:
try:
yield self[i]
i += 1
except IndexError:
break
class TiffPage(object):
"""TIFF image file directory (IFD).
Attributes
----------
index : int
Index of page in file.
dtype : numpy.dtype or None
Data type (native byte order) of the image in IFD.
shape : tuple
Dimensions of the image in IFD.
axes : str
Axes label codes:
'X' width, 'Y' height, 'S' sample, 'I' image series|page|plane,
'Z' depth, 'C' color|em-wavelength|channel, 'E' ex-wavelength|lambda,
'T' time, 'R' region|tile, 'A' angle, 'P' phase, 'H' lifetime,
'L' exposure, 'V' event, 'Q' unknown, '_' missing
tags : dict
Dictionary of tags in IFD. {tag.name: TiffTag}
colormap : numpy.ndarray
Color look up table, if exists.
All attributes are read-only.
Notes
-----
The internal, normalized '_shape' attribute is 6 dimensional:
0 : number planes/images (stk, ij).
1 : planar samplesperpixel.
2 : imagedepth Z (sgi).
3 : imagelength Y.
4 : imagewidth X.
5 : contig samplesperpixel.
"""
# default properties; will be updated from tags
imagewidth = 0
imagelength = 0
imagedepth = 1
tilewidth = 0
tilelength = 0
tiledepth = 1
bitspersample = 1
samplesperpixel = 1
sampleformat = 1
rowsperstrip = 2**32 - 1
compression = 1
planarconfig = 1
fillorder = 1
photometric = 0
predictor = 1
extrasamples = 1
colormap = None
software = ""
description = ""
description1 = ""
def __init__(self, parent, index, keyframe=None):
"""Initialize instance from file.
The file handle position must be at offset to a valid IFD.
"""
self.parent = parent
self.index = index
self.shape = ()
self._shape = ()
self.dtype = None
self._dtype = None
self.axes = ""
self.tags = {}
self.dataoffsets = ()
self.databytecounts = ()
# read TIFF IFD structure and its tags from file
fh = parent.filehandle
self.offset = fh.tell() # offset to this IFD
try:
tagno = struct.unpack(parent.tagnoformat, fh.read(parent.tagnosize))[0]
if tagno > 4096:
raise ValueError("suspicious number of tags")
except Exception:
raise ValueError("corrupted tag list at offset %i" % self.offset)
tagsize = parent.tagsize
data = fh.read(tagsize * tagno)
tags = self.tags
index = -tagsize
for _ in range(tagno):
index += tagsize
try:
tag = TiffTag(self.parent, data[index : index + tagsize])
except TiffTag.Error as e:
warnings.warn(str(e))
continue
tagname = tag.name
if tagname not in tags:
name = tagname
tags[name] = tag
else:
# some files contain multiple tags with same code
# e.g. MicroManager files contain two ImageDescription tags
i = 1
while True:
name = "%s%i" % (tagname, i)
if name not in tags:
tags[name] = tag
break
name = TIFF.TAG_ATTRIBUTES.get(name, "")
if name:
if name[:3] in "sof des" and not isinstance(tag.value, str):
pass # wrong string type for software, description
else:
setattr(self, name, tag.value)
if not tags:
return # found in FIBICS
# consolidate private tags; remove them from self.tags
if self.is_andor:
self.andor_tags
elif self.is_epics:
self.epics_tags
if self.is_lsm or (self.index and self.parent.is_lsm):
# correct non standard LSM bitspersample tags
self.tags["BitsPerSample"]._fix_lsm_bitspersample(self)
if self.is_vista or (self.index and self.parent.is_vista):
# ISS Vista writes wrong ImageDepth tag
self.imagedepth = 1
if self.is_stk and "UIC1tag" in tags and not tags["UIC1tag"].value:
# read UIC1tag now that plane count is known
uic1tag = tags["UIC1tag"]
fh.seek(uic1tag.valueoffset)
tags["UIC1tag"].value = read_uic1tag(
fh,
self.parent.byteorder,
uic1tag.dtype,
uic1tag.count,
None,
tags["UIC2tag"].count,
)
if "IJMetadata" in tags:
# decode IJMetadata tag
try:
tags["IJMetadata"].value = imagej_metadata(
tags["IJMetadata"].value,
tags["IJMetadataByteCounts"].value,
self.parent.byteorder,
)
except Exception as e:
warnings.warn(str(e))
if "BitsPerSample" in tags:
tag = tags["BitsPerSample"]
if tag.count == 1:
self.bitspersample = tag.value
else:
# LSM might list more items than samplesperpixel
value = tag.value[: self.samplesperpixel]
if any((v - value[0] for v in value)):
self.bitspersample = value
else:
self.bitspersample = value[0]
if "SampleFormat" in tags:
tag = tags["SampleFormat"]
if tag.count == 1:
self.sampleformat = tag.value
else:
value = tag.value[: self.samplesperpixel]
if any((v - value[0] for v in value)):
self.sampleformat = value
else:
self.sampleformat = value[0]
if "ImageLength" in tags:
if "RowsPerStrip" not in tags or tags["RowsPerStrip"].count > 1:
self.rowsperstrip = self.imagelength
# self.stripsperimage = int(math.floor(
# float(self.imagelength + self.rowsperstrip - 1) /
# self.rowsperstrip))
# determine dtype
dtype = self.sampleformat, self.bitspersample
dtype = TIFF.SAMPLE_DTYPES.get(dtype, None)
if dtype is not None:
dtype = numpy.dtype(dtype)
self.dtype = self._dtype = dtype
# determine shape of data
imagelength = self.imagelength
imagewidth = self.imagewidth
imagedepth = self.imagedepth
samplesperpixel = self.samplesperpixel
if self.is_stk:
assert self.imagedepth == 1
uictag = tags["UIC2tag"].value
planes = tags["UIC2tag"].count
if self.planarconfig == 1:
self._shape = (planes, 1, 1, imagelength, imagewidth, samplesperpixel)
if samplesperpixel == 1:
self.shape = (planes, imagelength, imagewidth)
self.axes = "YX"
else:
self.shape = (planes, imagelength, imagewidth, samplesperpixel)
self.axes = "YXS"
else:
self._shape = (planes, samplesperpixel, 1, imagelength, imagewidth, 1)
if samplesperpixel == 1:
self.shape = (planes, imagelength, imagewidth)
self.axes = "YX"
else:
self.shape = (planes, samplesperpixel, imagelength, imagewidth)
self.axes = "SYX"
# detect type of series
if planes == 1:
self.shape = self.shape[1:]
elif numpy.all(uictag["ZDistance"] != 0):
self.axes = "Z" + self.axes
elif numpy.all(numpy.diff(uictag["TimeCreated"]) != 0):
self.axes = "T" + self.axes
else:
self.axes = "I" + self.axes
elif self.photometric == 2 or samplesperpixel > 1: # PHOTOMETRIC.RGB
if self.planarconfig == 1:
self._shape = (
1,
1,
imagedepth,
imagelength,
imagewidth,
samplesperpixel,
)
if imagedepth == 1:
self.shape = (imagelength, imagewidth, samplesperpixel)
self.axes = "YXS"
else:
self.shape = (imagedepth, imagelength, imagewidth, samplesperpixel)
self.axes = "ZYXS"
else:
self._shape = (
1,
samplesperpixel,
imagedepth,
imagelength,
imagewidth,
1,
)
if imagedepth == 1:
self.shape = (samplesperpixel, imagelength, imagewidth)
self.axes = "SYX"
else:
self.shape = (samplesperpixel, imagedepth, imagelength, imagewidth)
self.axes = "SZYX"
else:
self._shape = (1, 1, imagedepth, imagelength, imagewidth, 1)
if imagedepth == 1:
self.shape = (imagelength, imagewidth)
self.axes = "YX"
else:
self.shape = (imagedepth, imagelength, imagewidth)
self.axes = "ZYX"
# dataoffsets and databytecounts
if "TileOffsets" in tags:
self.dataoffsets = tags["TileOffsets"].value
elif "StripOffsets" in tags:
self.dataoffsets = tags["StripOffsets"].value
else:
self.dataoffsets = (0,)
if "TileByteCounts" in tags:
self.databytecounts = tags["TileByteCounts"].value
elif "StripByteCounts" in tags:
self.databytecounts = tags["StripByteCounts"].value
else:
self.databytecounts = (product(self.shape) * (self.bitspersample // 8),)
if self.compression != 1:
warnings.warn("required ByteCounts tag is missing")
assert len(self.shape) == len(self.axes)
def asarray(
self,
out=None,
squeeze=True,
lock=None,
reopen=True,
maxsize=2**44,
validate=True,
):
"""Read image data from file and return as numpy array.
Raise ValueError if format is unsupported.
Parameters
----------
out : numpy.ndarray, str, or file-like object; optional
Buffer where image data will be saved.
If None (default), a new array will be created.
If numpy.ndarray, a writable array of compatible dtype and shape.
If 'memmap', directly memory-map the image data in the TIFF file
if possible; else create a memory-mapped array in a temporary file.
If str or open file, the file name or file object used to
create a memory-map to an array stored in a binary file on disk.
squeeze : bool
If True, all length-1 dimensions (except X and Y) are
squeezed out from the array.
If False, the shape of the returned array might be different from
the page.shape.
lock : {RLock, NullContext}
A reentrant lock used to synchronize reads from file.
If None (default), the lock of the parent's filehandle is used.
reopen : bool
If True (default) and the parent file handle is closed, the file
is temporarily re-opened and closed if no exception occurs.
maxsize: int or None
Maximum size of data before a ValueError is raised.
Can be used to catch DOS. Default: 16 TB.
validate : bool
If True (default), validate various parameters.
If None, only validate parameters and return None.
"""
self_ = self
self = self.keyframe # self or keyframe
if not self._shape or product(self._shape) == 0:
return
tags = self.tags
if validate or validate is None:
if maxsize and product(self._shape) > maxsize:
raise ValueError("data are too large %s" % str(self._shape))
if self.dtype is None:
raise ValueError(
"data type not supported: %s%i"
% (self.sampleformat, self.bitspersample)
)
if self.compression not in TIFF.DECOMPESSORS:
raise ValueError("cannot decompress %s" % self.compression.name)
if "SampleFormat" in tags:
tag = tags["SampleFormat"]
if tag.count != 1 and any((i - tag.value[0] for i in tag.value)):
raise ValueError("sample formats do not match %s" % tag.value)
if self.is_chroma_subsampled and (
self.compression != 7 or self.planarconfig == 2
):
raise NotImplementedError("chroma subsampling not supported")
if validate is None:
return
fh = self_.parent.filehandle
lock = fh.lock if lock is None else lock
with lock:
closed = fh.closed
if closed:
if reopen:
fh.open()
else:
raise IOError("file handle is closed")
dtype = self._dtype
shape = self._shape
imagewidth = self.imagewidth
imagelength = self.imagelength
imagedepth = self.imagedepth
bitspersample = self.bitspersample
typecode = self.parent.byteorder + dtype.char
lsb2msb = self.fillorder == 2
offsets, bytecounts = self_.offsets_bytecounts
istiled = self.is_tiled
if istiled:
tilewidth = self.tilewidth
tilelength = self.tilelength
tiledepth = self.tiledepth
tw = (imagewidth + tilewidth - 1) // tilewidth
tl = (imagelength + tilelength - 1) // tilelength
td = (imagedepth + tiledepth - 1) // tiledepth
shape = (
shape[0],
shape[1],
td * tiledepth,
tl * tilelength,
tw * tilewidth,
shape[-1],
)
tileshape = (tiledepth, tilelength, tilewidth, shape[-1])
runlen = tilewidth
else:
runlen = imagewidth
if self.planarconfig == 1:
runlen *= self.samplesperpixel
if out == "memmap" and self.is_memmappable:
with lock:
result = fh.memmap_array(typecode, shape, offset=offsets[0])
elif self.is_contiguous:
if out is not None:
out = create_output(out, shape, dtype)
with lock:
fh.seek(offsets[0])
result = fh.read_array(typecode, product(shape), out=out)
if out is None and not result.dtype.isnative:
# swap byte order and dtype without copy
result.byteswap(True)
result = result.newbyteorder()
if lsb2msb:
reverse_bitorder(result)
else:
result = create_output(out, shape, dtype)
decompress = TIFF.DECOMPESSORS[self.compression]
if self.compression == 7: # COMPRESSION.JPEG
if bitspersample not in (8, 12):
raise ValueError("unsupported JPEG precision %i" % bitspersample)
if "JPEGTables" in tags:
table = tags["JPEGTables"].value
else:
table = b""
unpack = identityfunc
colorspace = TIFF.PHOTOMETRIC(self.photometric).name
def decompress(
x,
func=decompress,
table=table,
bitspersample=bitspersample,
colorspace=colorspace,
):
return func(x, table, bitspersample, colorspace).reshape(-1)
elif bitspersample in (8, 16, 32, 64, 128):
if (bitspersample * runlen) % 8:
raise ValueError("data and sample size mismatch")
def unpack(x, typecode=typecode):
if self.predictor == 3: # PREDICTOR.FLOATINGPOINT
# the floating point horizontal differencing decoder
# needs the raw byte order
typecode = dtype.char
try:
# read only numpy array
return numpy.frombuffer(x, typecode)
except ValueError:
# strips may be missing EOI
# warnings.warn('unpack: %s' % e)
xlen = (len(x) // (bitspersample // 8)) * (bitspersample // 8)
return numpy.frombuffer(x[:xlen], typecode)
elif isinstance(bitspersample, tuple):
def unpack(x, typecode=typecode, bitspersample=bitspersample):
return unpack_rgb(x, typecode, bitspersample)
else:
def unpack(
x, typecode=typecode, bitspersample=bitspersample, runlen=runlen
):
return unpack_ints(x, typecode, bitspersample, runlen)
if istiled:
writable = None
tw, tl, td, pl = 0, 0, 0, 0
for tile in buffered_read(fh, lock, offsets, bytecounts):
if lsb2msb:
tile = reverse_bitorder(tile)
tile = decompress(tile)
tile = unpack(tile)
try:
tile.shape = tileshape
except ValueError:
# incomplete tiles; see gdal issue #1179
warnings.warn("invalid tile data")
t = numpy.zeros(tileshape, dtype).reshape(-1)
s = min(tile.size, t.size)
t[:s] = tile[:s]
tile = t.reshape(tileshape)
if self.predictor == 2: # PREDICTOR.HORIZONTAL
if writable is None:
writable = tile.flags["WRITEABLE"]
if writable:
numpy.cumsum(tile, axis=-2, dtype=dtype, out=tile)
else:
tile = numpy.cumsum(tile, axis=-2, dtype=dtype)
elif self.predictor == 3: # PREDICTOR.FLOATINGPOINT
raise NotImplementedError()
result[
0,
pl,
td : td + tiledepth,
tl : tl + tilelength,
tw : tw + tilewidth,
:,
] = tile
del tile
tw += tilewidth
if tw >= shape[4]:
tw, tl = 0, tl + tilelength
if tl >= shape[3]:
tl, td = 0, td + tiledepth
if td >= shape[2]:
td, pl = 0, pl + 1
result = result[..., :imagedepth, :imagelength, :imagewidth, :]
else:
strip_size = self.rowsperstrip * self.imagewidth
if self.planarconfig == 1:
strip_size *= self.samplesperpixel
result = result.reshape(-1)
index = 0
for strip in buffered_read(fh, lock, offsets, bytecounts):
if lsb2msb:
strip = reverse_bitorder(strip)
strip = decompress(strip)
strip = unpack(strip)
size = min(result.size, strip.size, strip_size, result.size - index)
result[index : index + size] = strip[:size]
del strip
index += size
result.shape = self._shape
if self.predictor != 1 and not (istiled and not self.is_contiguous):
if self.parent.is_lsm and self.compression == 1:
pass # work around bug in LSM510 software
elif self.predictor == 2: # PREDICTOR.HORIZONTAL
numpy.cumsum(result, axis=-2, dtype=dtype, out=result)
elif self.predictor == 3: # PREDICTOR.FLOATINGPOINT
result = decode_floats(result)
if squeeze:
try:
result.shape = self.shape
except ValueError:
warnings.warn(
"failed to reshape from %s to %s"
% (str(result.shape), str(self.shape))
)
if closed:
# TODO: file should remain open if an exception occurred above
fh.close()
return result
def asrgb(
self,
uint8=False,
alpha=None,
colormap=None,
dmin=None,
dmax=None,
*args,
**kwargs
):
"""Return image data as RGB(A).
Work in progress.
"""
data = self.asarray(*args, **kwargs)
self = self.keyframe # self or keyframe
photometric = self.photometric
PHOTOMETRIC = TIFF.PHOTOMETRIC
if photometric == PHOTOMETRIC.PALETTE:
colormap = self.colormap
if colormap.shape[1] < 2**self.bitspersample or self.dtype.char not in "BH":
raise ValueError("cannot apply colormap")
if uint8:
if colormap.max() > 255:
colormap >>= 8
colormap = colormap.astype("uint8")
if "S" in self.axes:
data = data[..., 0] if self.planarconfig == 1 else data[0]
data = apply_colormap(data, colormap)
elif photometric == PHOTOMETRIC.RGB:
if "ExtraSamples" in self.tags:
if alpha is None:
alpha = TIFF.EXTRASAMPLE
extrasamples = self.extrasamples
if self.tags["ExtraSamples"].count == 1:
extrasamples = (extrasamples,)
for i, exs in enumerate(extrasamples):
if exs in alpha:
if self.planarconfig == 1:
data = data[..., [0, 1, 2, 3 + i]]
else:
data = data[:, [0, 1, 2, 3 + i]]
break
else:
if self.planarconfig == 1:
data = data[..., :3]
else:
data = data[:, :3]
# TODO: convert to uint8?
elif photometric == PHOTOMETRIC.MINISBLACK:
raise NotImplementedError()
elif photometric == PHOTOMETRIC.MINISWHITE:
raise NotImplementedError()
elif photometric == PHOTOMETRIC.SEPARATED:
raise NotImplementedError()
else:
raise NotImplementedError()
return data
def aspage(self):
return self
@property
def keyframe(self):
return self
@keyframe.setter
def keyframe(self, index):
return
@lazyattr
def offsets_bytecounts(self):
"""Return simplified offsets and bytecounts."""
if self.is_contiguous:
offset, byte_count = self.is_contiguous
return [offset], [byte_count]
return clean_offsets_counts(self.dataoffsets, self.databytecounts)
@lazyattr
def is_contiguous(self):
"""Return offset and size of contiguous data, else None.
Excludes prediction and fill_order.
"""
if self.compression != 1 or self.bitspersample not in (8, 16, 32, 64):
return
if "TileWidth" in self.tags:
if (
self.imagewidth != self.tilewidth
or self.imagelength % self.tilelength
or self.tilewidth % 16
or self.tilelength % 16
):
return
if (
"ImageDepth" in self.tags
and "TileDepth" in self.tags
and (
self.imagelength != self.tilelength
or self.imagedepth % self.tiledepth
)
):
return
offsets = self.dataoffsets
bytecounts = self.databytecounts
if len(offsets) == 1:
return offsets[0], bytecounts[0]
if self.is_stk or all(
(
offsets[i] + bytecounts[i] == offsets[i + 1] or bytecounts[i + 1] == 0
) # no data/ignore offset
for i in range(len(offsets) - 1)
):
return offsets[0], sum(bytecounts)
@lazyattr
def is_final(self):
"""Return if page's image data are stored in final form.
Excludes byte-swapping.
"""
return (
self.is_contiguous
and self.fillorder == 1
and self.predictor == 1
and not self.is_chroma_subsampled
)
@lazyattr
def is_memmappable(self):
"""Return if page's image data in file can be memory-mapped."""
return (
self.parent.filehandle.is_file
and self.is_final
and
# (self.bitspersample == 8 or self.parent.isnative) and
self.is_contiguous[0] % self.dtype.itemsize == 0
) # aligned?
def __str__(self, detail=0, width=79):
"""Return string containing information about page."""
if self.keyframe != self:
return TiffFrame.__str__(self, detail)
attr = ""
for name in ("memmappable", "final", "contiguous"):
attr = getattr(self, "is_" + name)
if attr:
attr = name.upper()
break
info = " ".join(
s
for s in (
"x".join(str(i) for i in self.shape),
"%s%s"
% (TIFF.SAMPLEFORMAT(self.sampleformat).name, self.bitspersample),
"|".join(
i
for i in (
TIFF.PHOTOMETRIC(self.photometric).name,
"TILED" if self.is_tiled else "",
self.compression.name if self.compression != 1 else "",
self.planarconfig.name if self.planarconfig != 1 else "",
self.predictor.name if self.predictor != 1 else "",
self.fillorder.name if self.fillorder != 1 else "",
)
if i
),
attr,
"|".join((f.upper() for f in self.flags)),
)
if s
)
info = "TiffPage %i @%i %s" % (self.index, self.offset, info)
if detail <= 0:
return info
info = [info]
tags = self.tags
tlines = []
vlines = []
for tag in sorted(tags.values(), key=lambda x: x.code):
value = tag.__str__(width=width + 1)
tlines.append(value[:width].strip())
if detail > 1 and len(value) > width:
name = tag.name.upper()
if detail <= 2 and ("COUNTS" in name or "OFFSETS" in name):
value = pformat(tag.value, width=width, height=detail * 4)
else:
value = pformat(tag.value, width=width, height=detail * 12)
vlines.append("%s\n%s" % (tag.name, value))
info.append("\n".join(tlines))
if detail > 1:
info.append("\n\n".join(vlines))
if detail > 3:
try:
info.append(
"DATA\n%s" % pformat(self.asarray(), width=width, height=detail * 8)
)
except Exception:
pass
return "\n\n".join(info)
@lazyattr
def flags(self):
"""Return set of flags."""
return set(
(
name.lower()
for name in sorted(TIFF.FILE_FLAGS)
if getattr(self, "is_" + name)
)
)
@property
def ndim(self):
"""Return number of array dimensions."""
return len(self.shape)
@property
def size(self):
"""Return number of elements in array."""
return product(self.shape)
@lazyattr
def andor_tags(self):
"""Return consolidated metadata from Andor tags as dict.
Remove Andor tags from self.tags.
"""
if not self.is_andor:
return
tags = self.tags
result = {"Id": tags["AndorId"].value}
for tag in list(self.tags.values()):
code = tag.code
if not 4864 < code < 5031:
continue
value = tag.value
name = tag.name[5:] if len(tag.name) > 5 else tag.name
result[name] = value
del tags[tag.name]
return result
@lazyattr
def epics_tags(self):
"""Return consolidated metadata from EPICS areaDetector tags as dict.
Remove areaDetector tags from self.tags.
"""
if not self.is_epics:
return
result = {}
tags = self.tags
for tag in list(self.tags.values()):
code = tag.code
if not 65000 <= code < 65500:
continue
value = tag.value
if code == 65000:
result["timeStamp"] = datetime.datetime.fromtimestamp(float(value))
elif code == 65001:
result["uniqueID"] = int(value)
elif code == 65002:
result["epicsTSSec"] = int(value)
elif code == 65003:
result["epicsTSNsec"] = int(value)
else:
key, value = value.split(":", 1)
result[key] = astype(value)
del tags[tag.name]
return result
@lazyattr
def geotiff_tags(self):
"""Return consolidated metadata from GeoTIFF tags as dict."""
if not self.is_geotiff:
return
tags = self.tags
gkd = tags["GeoKeyDirectoryTag"].value
if gkd[0] != 1:
warnings.warn("invalid GeoKeyDirectoryTag")
return {}
result = {
"KeyDirectoryVersion": gkd[0],
"KeyRevision": gkd[1],
"KeyRevisionMinor": gkd[2],
# 'NumberOfKeys': gkd[3],
}
# deltags = ['GeoKeyDirectoryTag']
geokeys = TIFF.GEO_KEYS
geocodes = TIFF.GEO_CODES
for index in range(gkd[3]):
keyid, tagid, count, offset = gkd[4 + index * 4 : index * 4 + 8]
keyid = geokeys.get(keyid, keyid)
if tagid == 0:
value = offset
else:
tagname = TIFF.TAGS[tagid]
# deltags.append(tagname)
value = tags[tagname].value[offset : offset + count]
if tagid == 34737 and count > 1 and value[-1] == "|":
value = value[:-1]
value = value if count > 1 else value[0]
if keyid in geocodes:
try:
value = geocodes[keyid](value)
except Exception:
pass
result[keyid] = value
if "IntergraphMatrixTag" in tags:
value = tags["IntergraphMatrixTag"].value
value = numpy.array(value)
if len(value) == 16:
value = value.reshape((4, 4)).tolist()
result["IntergraphMatrix"] = value
if "ModelPixelScaleTag" in tags:
value = numpy.array(tags["ModelPixelScaleTag"].value).tolist()
result["ModelPixelScale"] = value
if "ModelTiepointTag" in tags:
value = tags["ModelTiepointTag"].value
value = numpy.array(value).reshape((-1, 6)).squeeze().tolist()
result["ModelTiepoint"] = value
if "ModelTransformationTag" in tags:
value = tags["ModelTransformationTag"].value
value = numpy.array(value).reshape((4, 4)).tolist()
result["ModelTransformation"] = value
elif False:
# if 'ModelPixelScaleTag' in tags and 'ModelTiepointTag' in tags:
sx, sy, sz = tags["ModelPixelScaleTag"].value
tiepoints = tags["ModelTiepointTag"].value
transforms = []
for tp in range(0, len(tiepoints), 6):
i, j, k, x, y, z = tiepoints[tp : tp + 6]
transforms.append(
[
[sx, 0.0, 0.0, x - i * sx],
[0.0, -sy, 0.0, y + j * sy],
[0.0, 0.0, sz, z - k * sz],
[0.0, 0.0, 0.0, 1.0],
]
)
if len(tiepoints) == 6:
transforms = transforms[0]
result["ModelTransformation"] = transforms
if "RPCCoefficientTag" in tags:
rpcc = tags["RPCCoefficientTag"].value
result["RPCCoefficient"] = {
"ERR_BIAS": rpcc[0],
"ERR_RAND": rpcc[1],
"LINE_OFF": rpcc[2],
"SAMP_OFF": rpcc[3],
"LAT_OFF": rpcc[4],
"LONG_OFF": rpcc[5],
"HEIGHT_OFF": rpcc[6],
"LINE_SCALE": rpcc[7],
"SAMP_SCALE": rpcc[8],
"LAT_SCALE": rpcc[9],
"LONG_SCALE": rpcc[10],
"HEIGHT_SCALE": rpcc[11],
"LINE_NUM_COEFF": rpcc[12:33],
"LINE_DEN_COEFF ": rpcc[33:53],
"SAMP_NUM_COEFF": rpcc[53:73],
"SAMP_DEN_COEFF": rpcc[73:],
}
return result
@property
def is_tiled(self):
"""Page contains tiled image."""
return "TileWidth" in self.tags
@property
def is_reduced(self):
"""Page is reduced image of another image."""
return "NewSubfileType" in self.tags and self.tags["NewSubfileType"].value & 1
@property
def is_chroma_subsampled(self):
"""Page contains chroma subsampled image."""
return "YCbCrSubSampling" in self.tags and self.tags[
"YCbCrSubSampling"
].value != (1, 1)
@lazyattr
def is_imagej(self):
"""Return ImageJ description if exists, else None."""
for description in (self.description, self.description1):
if not description:
return
if description[:7] == "ImageJ=":
return description
@lazyattr
def is_shaped(self):
"""Return description containing array shape if exists, else None."""
for description in (self.description, self.description1):
if not description:
return
if description[:1] == "{" and '"shape":' in description:
return description
if description[:6] == "shape=":
return description
@property
def is_mdgel(self):
"""Page contains MDFileTag tag."""
return "MDFileTag" in self.tags
@property
def is_mediacy(self):
"""Page contains Media Cybernetics Id tag."""
return "MC_Id" in self.tags and self.tags["MC_Id"].value[:7] == b"MC TIFF"
@property
def is_stk(self):
"""Page contains UIC2Tag tag."""
return "UIC2tag" in self.tags
@property
def is_lsm(self):
"""Page contains CZ_LSMINFO tag."""
return "CZ_LSMINFO" in self.tags
@property
def is_fluoview(self):
"""Page contains FluoView MM_STAMP tag."""
return "MM_Stamp" in self.tags
@property
def is_nih(self):
"""Page contains NIH image header."""
return "NIHImageHeader" in self.tags
@property
def is_sgi(self):
"""Page contains SGI image and tile depth tags."""
return "ImageDepth" in self.tags and "TileDepth" in self.tags
@property
def is_vista(self):
"""Software tag is 'ISS Vista'."""
return self.software == "ISS Vista"
@property
def is_metaseries(self):
"""Page contains MDS MetaSeries metadata in ImageDescription tag."""
if self.index > 1 or self.software != "MetaSeries":
return False
d = self.description
return d.startswith("") and d.endswith("")
@property
def is_ome(self):
"""Page contains OME-XML in ImageDescription tag."""
if self.index > 1 or not self.description:
return False
d = self.description
return d[:14] == ""
@property
def is_scn(self):
"""Page contains Leica SCN XML in ImageDescription tag."""
if self.index > 1 or not self.description:
return False
d = self.description
return d[:14] == ""
@property
def is_micromanager(self):
"""Page contains Micro-Manager metadata."""
return "MicroManagerMetadata" in self.tags
@property
def is_andor(self):
"""Page contains Andor Technology tags."""
return "AndorId" in self.tags
@property
def is_pilatus(self):
"""Page contains Pilatus tags."""
return self.software[:8] == "TVX TIFF" and self.description[:2] == "# "
@property
def is_epics(self):
"""Page contains EPICS areaDetector tags."""
return (
self.description == "EPICS areaDetector"
or self.software == "EPICS areaDetector"
)
@property
def is_tvips(self):
"""Page contains TVIPS metadata."""
return "TVIPS" in self.tags
@property
def is_fei(self):
"""Page contains SFEG or HELIOS metadata."""
return "FEI_SFEG" in self.tags or "FEI_HELIOS" in self.tags
@property
def is_sem(self):
"""Page contains Zeiss SEM metadata."""
return "CZ_SEM" in self.tags
@property
def is_svs(self):
"""Page contains Aperio metadata."""
return self.description[:20] == "Aperio Image Library"
@property
def is_scanimage(self):
"""Page contains ScanImage metadata."""
return (
self.description[:12] == "state.config"
or self.software[:22] == "SI.LINE_FORMAT_VERSION"
or "scanimage.SI." in self.description[-256:]
)
@property
def is_qptiff(self):
"""Page contains PerkinElmer tissue images metadata."""
# The ImageDescription tag contains XML with a top-level
# element
return self.software[:15] == "PerkinElmer-QPI"
@property
def is_geotiff(self):
"""Page contains GeoTIFF metadata."""
return "GeoKeyDirectoryTag" in self.tags
class TiffFrame(object):
"""Lightweight TIFF image file directory (IFD).
Only a limited number of tag values are read from file, e.g. StripOffsets,
and StripByteCounts. Other tag values are assumed to be identical with a
specified TiffPage instance, the keyframe.
TiffFrame is intended to reduce resource usage and speed up reading data
from file, not for introspection of metadata.
Not compatible with Python 2.
"""
__slots__ = (
"keyframe",
"parent",
"index",
"offset",
"dataoffsets",
"databytecounts",
)
is_mdgel = False
tags = {}
def __init__(self, parent, index, keyframe):
"""Read specified tags from file.
The file handle position must be at the offset to a valid IFD.
"""
self.keyframe = keyframe
self.parent = parent
self.index = index
self.dataoffsets = None
self.databytecounts = None
unpack = struct.unpack
fh = parent.filehandle
self.offset = fh.tell()
try:
tagno = unpack(parent.tagnoformat, fh.read(parent.tagnosize))[0]
if tagno > 4096:
raise ValueError("suspicious number of tags")
except Exception:
raise ValueError("corrupted page list at offset %i" % self.offset)
# tags = {}
tagcodes = {273, 279, 324, 325} # TIFF.FRAME_TAGS
tagsize = parent.tagsize
codeformat = parent.tagformat1[:2]
data = fh.read(tagsize * tagno)
index = -tagsize
for _ in range(tagno):
index += tagsize
code = unpack(codeformat, data[index : index + 2])[0]
if code not in tagcodes:
continue
try:
tag = TiffTag(parent, data[index : index + tagsize])
except TiffTag.Error as e:
warnings.warn(str(e))
continue
if code == 273 or code == 324:
setattr(self, "dataoffsets", tag.value)
elif code == 279 or code == 325:
setattr(self, "databytecounts", tag.value)
# elif code == 270:
# tagname = tag.name
# if tagname not in tags:
# tags[tagname] = bytes2str(tag.value)
# elif 'ImageDescription1' not in tags:
# tags['ImageDescription1'] = bytes2str(tag.value)
# else:
# tags[tag.name] = tag.value
def aspage(self):
"""Return TiffPage from file."""
self.parent.filehandle.seek(self.offset)
return TiffPage(self.parent, index=self.index, keyframe=None)
def asarray(self, *args, **kwargs):
"""Read image data from file and return as numpy array."""
# TODO: fix TypeError on Python 2
# "TypeError: unbound method asarray() must be called with TiffPage
# instance as first argument (got TiffFrame instance instead)"
kwargs["validate"] = False
return TiffPage.asarray(self, *args, **kwargs)
def asrgb(self, *args, **kwargs):
"""Read image data from file and return RGB image as numpy array."""
kwargs["validate"] = False
return TiffPage.asrgb(self, *args, **kwargs)
@property
def offsets_bytecounts(self):
"""Return simplified offsets and bytecounts."""
if self.keyframe.is_contiguous:
return self.dataoffsets[:1], self.keyframe.is_contiguous[1:]
return clean_offsets_counts(self.dataoffsets, self.databytecounts)
@property
def is_contiguous(self):
"""Return offset and size of contiguous data, else None."""
if self.keyframe.is_contiguous:
return self.dataoffsets[0], self.keyframe.is_contiguous[1]
@property
def is_memmappable(self):
"""Return if page's image data in file can be memory-mapped."""
return self.keyframe.is_memmappable
def __getattr__(self, name):
"""Return attribute from keyframe."""
if name in TIFF.FRAME_ATTRS:
return getattr(self.keyframe, name)
# this error could be raised because an AttributeError was
# raised inside a @property function
raise AttributeError(
"'%s' object has no attribute '%s'" % (self.__class__.__name__, name)
)
def __str__(self, detail=0):
"""Return string containing information about frame."""
info = " ".join(
s for s in ("x".join(str(i) for i in self.shape), str(self.dtype))
)
return "TiffFrame %i @%i %s" % (self.index, self.offset, info)
class TiffTag(object):
"""TIFF tag structure.
Attributes
----------
name : string
Name of tag.
code : int
Decimal code of tag.
dtype : str
Datatype of tag data. One of TIFF DATA_FORMATS.
count : int
Number of values.
value : various types
Tag data as Python object.
ImageSourceData : int
Location of value in file.
All attributes are read-only.
"""
__slots__ = ("code", "count", "dtype", "value", "valueoffset")
class Error(Exception):
pass
def __init__(self, parent, tagheader, **kwargs):
"""Initialize instance from tag header."""
fh = parent.filehandle
byteorder = parent.byteorder
unpack = struct.unpack
offsetsize = parent.offsetsize
self.valueoffset = fh.tell() + offsetsize + 4
code, type_ = unpack(parent.tagformat1, tagheader[:4])
count, value = unpack(parent.tagformat2, tagheader[4:])
try:
dtype = TIFF.DATA_FORMATS[type_]
except KeyError:
raise TiffTag.Error("unknown tag data type %i" % type_)
fmt = "%s%i%s" % (byteorder, count * int(dtype[0]), dtype[1])
size = struct.calcsize(fmt)
if size > offsetsize or code in TIFF.TAG_READERS:
self.valueoffset = offset = unpack(parent.offsetformat, value)[0]
if offset < 8 or offset > fh.size - size:
raise TiffTag.Error("invalid tag value offset")
# if offset % 2:
# warnings.warn('tag value does not begin on word boundary')
fh.seek(offset)
if code in TIFF.TAG_READERS:
readfunc = TIFF.TAG_READERS[code]
value = readfunc(fh, byteorder, dtype, count, offsetsize)
elif type_ == 7 or (count > 1 and dtype[-1] == "B"):
value = read_bytes(fh, byteorder, dtype, count, offsetsize)
elif code in TIFF.TAGS or dtype[-1] == "s":
value = unpack(fmt, fh.read(size))
else:
value = read_numpy(fh, byteorder, dtype, count, offsetsize)
elif dtype[-1] == "B" or type_ == 7:
value = value[:size]
else:
value = unpack(fmt, value[:size])
process = (
code not in TIFF.TAG_READERS and code not in TIFF.TAG_TUPLE and type_ != 7
)
if process and dtype[-1] == "s" and isinstance(value[0], bytes):
# TIFF ASCII fields can contain multiple strings,
# each terminated with a NUL
value = value[0]
try:
value = bytes2str(stripascii(value).strip())
except UnicodeDecodeError:
warnings.warn("tag %i: coercing invalid ASCII to bytes" % code)
dtype = "1B"
else:
if code in TIFF.TAG_ENUM:
t = TIFF.TAG_ENUM[code]
try:
value = tuple(t(v) for v in value)
except ValueError as e:
warnings.warn(str(e))
if process:
if len(value) == 1:
value = value[0]
self.code = code
self.dtype = dtype
self.count = count
self.value = value
@property
def name(self):
return TIFF.TAGS.get(self.code, str(self.code))
def _fix_lsm_bitspersample(self, parent):
"""Correct LSM bitspersample tag.
Old LSM writers may use a separate region for two 16-bit values,
although they fit into the tag value element of the tag.
"""
if self.code == 258 and self.count == 2:
# TODO: test this case; need example file
warnings.warn("correcting LSM bitspersample tag")
tof = parent.offsetformat[parent.offsetsize]
self.valueoffset = struct.unpack(tof, self._value)[0]
parent.filehandle.seek(self.valueoffset)
self.value = struct.unpack(">> # read image stack from sequence of TIFF files
>>> imsave('temp_C001T001.tif', numpy.random.rand(64, 64))
>>> imsave('temp_C001T002.tif', numpy.random.rand(64, 64))
>>> tifs = TiffSequence('temp_C001*.tif')
>>> tifs.shape
(1, 2)
>>> tifs.axes
'CT'
>>> data = tifs.asarray()
>>> data.shape
(1, 2, 64, 64)
"""
_patterns = {
"axes": r"""
# matches Olympus OIF and Leica TIFF series
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
"""
}
class ParseError(Exception):
pass
def __init__(self, files, imread=TiffFile, pattern="axes", *args, **kwargs):
"""Initialize instance from multiple files.
Parameters
----------
files : str, pathlib.Path, or sequence thereof
Glob pattern or sequence of file names.
Binary streams are not supported.
imread : function or class
Image read function or class with asarray function returning numpy
array from single file.
pattern : str
Regular expression pattern that matches axes names and sequence
indices in file names.
By default, the pattern matches Olympus OIF and Leica TIFF series.
"""
if isinstance(files, pathlib.Path):
files = str(files)
if isinstance(files, basestring):
files = natural_sorted(glob.glob(files))
files = list(files)
if not files:
raise ValueError("no files found")
if isinstance(files[0], pathlib.Path):
files = [str(pathlib.Path(f)) for f in files]
elif not isinstance(files[0], basestring):
raise ValueError("not a file name")
self.files = files
if hasattr(imread, "asarray"):
# redefine imread
_imread = imread
def imread(fname, *args, **kwargs):
with _imread(fname) as im:
return im.asarray(*args, **kwargs)
self.imread = imread
self.pattern = self._patterns.get(pattern, pattern)
try:
self._parse()
if not self.axes:
self.axes = "I"
except self.ParseError:
self.axes = "I"
self.shape = (len(files),)
self._startindex = (0,)
self._indices = tuple((i,) for i in range(len(files)))
def __str__(self):
"""Return string with information about image sequence."""
return "\n".join(
[
self.files[0],
" size: %i" % len(self.files),
" axes: %s" % self.axes,
" shape: %s" % str(self.shape),
]
)
def __len__(self):
return len(self.files)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def close(self):
pass
def asarray(self, out=None, *args, **kwargs):
"""Read image data from all files and return as numpy array.
The args and kwargs parameters are passed to the imread function.
Raise IndexError or ValueError if image shapes do not match.
"""
im = self.imread(self.files[0], *args, **kwargs)
shape = self.shape + im.shape
result = create_output(out, shape, dtype=im.dtype)
result = result.reshape(-1, *im.shape)
for index, fname in zip(self._indices, self.files):
index = [i - j for i, j in zip(index, self._startindex)]
index = numpy.ravel_multi_index(index, self.shape)
im = self.imread(fname, *args, **kwargs)
result[index] = im
result.shape = shape
return result
def _parse(self):
"""Get axes and shape from file names."""
if not self.pattern:
raise self.ParseError("invalid pattern")
pattern = re.compile(self.pattern, re.IGNORECASE | re.VERBOSE)
matches = pattern.findall(self.files[0])
if not matches:
raise self.ParseError("pattern does not match file names")
matches = matches[-1]
if len(matches) % 2:
raise self.ParseError("pattern does not match axis name and index")
axes = "".join(m for m in matches[::2] if m)
if not axes:
raise self.ParseError("pattern does not match file names")
indices = []
for fname in self.files:
matches = pattern.findall(fname)[-1]
if axes != "".join(m for m in matches[::2] if m):
raise ValueError("axes do not match within the image sequence")
indices.append([int(m) for m in matches[1::2] if m])
shape = tuple(numpy.max(indices, axis=0))
startindex = tuple(numpy.min(indices, axis=0))
shape = tuple(i - j + 1 for i, j in zip(shape, startindex))
if product(shape) != len(self.files):
warnings.warn("files are missing. Missing data are zeroed")
self.axes = axes.upper()
self.shape = shape
self._indices = indices
self._startindex = startindex
class FileHandle(object):
"""Binary file handle.
A limited, special purpose file handler that can:
* handle embedded files (for CZI within CZI files)
* re-open closed files (for multi-file formats, such as OME-TIFF)
* read and write numpy arrays and records from file like objects
Only 'rb' and 'wb' modes are supported. Concurrently reading and writing
of the same stream is untested.
When initialized from another file handle, do not use it unless this
FileHandle is closed.
Attributes
----------
name : str
Name of the file.
path : str
Absolute path to file.
size : int
Size of file in bytes.
is_file : bool
If True, file has a filno and can be memory-mapped.
All attributes are read-only.
"""
__slots__ = (
"_fh",
"_file",
"_mode",
"_name",
"_dir",
"_lock",
"_offset",
"_size",
"_close",
"is_file",
)
def __init__(self, file, mode="rb", name=None, offset=None, size=None):
"""Initialize file handle from file name or another file handle.
Parameters
----------
file : str, pathlib.Path, binary stream, or FileHandle
File name or seekable binary stream, such as an open file
or BytesIO.
mode : str
File open mode in case 'file' is a file name. Must be 'rb' or 'wb'.
name : str
Optional name of file in case 'file' is a binary stream.
offset : int
Optional start position of embedded file. By default, this is
the current file position.
size : int
Optional size of embedded file. By default, this is the number
of bytes from the 'offset' to the end of the file.
"""
self._file = file
self._fh = None
self._mode = mode
self._name = name
self._dir = ""
self._offset = offset
self._size = size
self._close = True
self.is_file = False
self._lock = NullContext()
self.open()
def open(self):
"""Open or re-open file."""
if self._fh:
return # file is open
if isinstance(self._file, pathlib.Path):
self._file = str(self._file)
if isinstance(self._file, basestring):
# file name
self._file = os.path.realpath(self._file)
self._dir, self._name = os.path.split(self._file)
self._fh = open(self._file, self._mode)
self._close = True
if self._offset is None:
self._offset = 0
elif isinstance(self._file, FileHandle):
# FileHandle
self._fh = self._file._fh
if self._offset is None:
self._offset = 0
self._offset += self._file._offset
self._close = False
if not self._name:
if self._offset:
name, ext = os.path.splitext(self._file._name)
self._name = "%s@%i%s" % (name, self._offset, ext)
else:
self._name = self._file._name
if self._mode and self._mode != self._file._mode:
raise ValueError("FileHandle has wrong mode")
self._mode = self._file._mode
self._dir = self._file._dir
elif hasattr(self._file, "seek"):
# binary stream: open file, BytesIO
try:
self._file.tell()
except Exception:
raise ValueError("binary stream is not seekable")
self._fh = self._file
if self._offset is None:
self._offset = self._file.tell()
self._close = False
if not self._name:
try:
self._dir, self._name = os.path.split(self._fh.name)
except AttributeError:
self._name = "Unnamed binary stream"
try:
self._mode = self._fh.mode
except AttributeError:
pass
else:
raise ValueError(
"The first parameter must be a file name, "
"seekable binary stream, or FileHandle"
)
if self._offset:
self._fh.seek(self._offset)
if self._size is None:
pos = self._fh.tell()
self._fh.seek(self._offset, 2)
self._size = self._fh.tell()
self._fh.seek(pos)
try:
self._fh.fileno()
self.is_file = True
except Exception:
self.is_file = False
def read(self, size=-1):
"""Read 'size' bytes from file, or until EOF is reached."""
if size < 0 and self._offset:
size = self._size
return self._fh.read(size)
def write(self, bytestring):
"""Write bytestring to file."""
return self._fh.write(bytestring)
def flush(self):
"""Flush write buffers if applicable."""
return self._fh.flush()
def memmap_array(self, dtype, shape, offset=0, mode="r", order="C"):
"""Return numpy.memmap of data stored in file."""
if not self.is_file:
raise ValueError("Cannot memory-map file without fileno")
return numpy.memmap(
self._fh,
dtype=dtype,
mode=mode,
offset=self._offset + offset,
shape=shape,
order=order,
)
def read_array(
self, dtype, count=-1, sep="", chunksize=2**25, out=None, native=False
):
"""Return numpy array from file.
Work around numpy issue #2230, "numpy.fromfile does not accept
StringIO object" https://github.com/numpy/numpy/issues/2230.
"""
fh = self._fh
dtype = numpy.dtype(dtype)
size = self._size if count < 0 else count * dtype.itemsize
if out is None:
try:
result = numpy.fromfile(fh, dtype, count, sep)
except IOError:
# ByteIO
data = fh.read(size)
result = numpy.frombuffer(data, dtype, count).copy()
if native and not result.dtype.isnative:
# swap byte order and dtype without copy
result.byteswap(True)
result = result.newbyteorder()
return result
# Read data from file in chunks and copy to output array
shape = out.shape
size = min(out.nbytes, size)
out = out.reshape(-1)
index = 0
while size > 0:
data = fh.read(min(chunksize, size))
datasize = len(data)
if datasize == 0:
break
size -= datasize
data = numpy.frombuffer(data, dtype)
out[index : index + data.size] = data
index += data.size
if hasattr(out, "flush"):
out.flush()
return out.reshape(shape)
def read_record(self, dtype, shape=1, byteorder=None):
"""Return numpy record from file."""
rec = numpy.rec
try:
record = rec.fromfile(self._fh, dtype, shape, byteorder=byteorder)
except Exception:
dtype = numpy.dtype(dtype)
if shape is None:
shape = self._size // dtype.itemsize
size = product(sequence(shape)) * dtype.itemsize
data = self._fh.read(size)
record = rec.fromstring(data, dtype, shape, byteorder=byteorder)
return record[0] if shape == 1 else record
def write_empty(self, size):
"""Append size bytes to file. Position must be at end of file."""
if size < 1:
return
self._fh.seek(size - 1, 1)
self._fh.write(b"\x00")
def write_array(self, data):
"""Write numpy array to binary file."""
try:
data.tofile(self._fh)
except Exception:
# BytesIO
self._fh.write(data.tostring())
def tell(self):
"""Return file's current position."""
return self._fh.tell() - self._offset
def seek(self, offset, whence=0):
"""Set file's current position."""
if self._offset:
if whence == 0:
self._fh.seek(self._offset + offset, whence)
return
elif whence == 2 and self._size > 0:
self._fh.seek(self._offset + self._size + offset, 0)
return
self._fh.seek(offset, whence)
def close(self):
"""Close file."""
if self._close and self._fh:
self._fh.close()
self._fh = None
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def __getattr__(self, name):
"""Return attribute from underlying file object."""
if self._offset:
warnings.warn("FileHandle: '%s' not implemented for embedded files" % name)
return getattr(self._fh, name)
@property
def name(self):
return self._name
@property
def dirname(self):
return self._dir
@property
def path(self):
return os.path.join(self._dir, self._name)
@property
def size(self):
return self._size
@property
def closed(self):
return self._fh is None
@property
def lock(self):
return self._lock
@lock.setter
def lock(self, value):
self._lock = threading.RLock() if value else NullContext()
class NullContext(object):
"""Null context manager.
>>> with NullContext():
... pass
"""
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
class OpenFileCache(object):
"""Keep files open."""
__slots__ = ("files", "past", "lock", "size")
def __init__(self, size, lock=None):
"""Initialize open file cache."""
self.past = [] # FIFO of opened files
self.files = {} # refcounts of opened files
self.lock = NullContext() if lock is None else lock
self.size = int(size)
def open(self, filehandle):
"""Re-open file if necessary."""
with self.lock:
if filehandle in self.files:
self.files[filehandle] += 1
elif filehandle.closed:
filehandle.open()
self.files[filehandle] = 1
self.past.append(filehandle)
def close(self, filehandle):
"""Close opened file if no longer used."""
with self.lock:
if filehandle in self.files:
self.files[filehandle] -= 1
# trim the file cache
index = 0
size = len(self.past)
while size > self.size and index < size:
filehandle = self.past[index]
if self.files[filehandle] == 0:
filehandle.close()
del self.files[filehandle]
del self.past[index]
size -= 1
else:
index += 1
def clear(self):
"""Close all opened files if not in use."""
with self.lock:
for filehandle, refcount in list(self.files.items()):
if refcount == 0:
filehandle.close()
del self.files[filehandle]
del self.past[self.past.index(filehandle)]
class LazyConst(object):
"""Class whose attributes are computed on first access from its methods."""
def __init__(self, cls):
self._cls = cls
self.__doc__ = getattr(cls, "__doc__")
def __getattr__(self, name):
func = getattr(self._cls, name)
if not callable(func):
return func
try:
value = func()
except TypeError:
# Python 2 unbound method
value = func.__func__()
setattr(self, name, value)
return value
@LazyConst
class TIFF(object):
"""Namespace for module constants."""
def TAGS():
# TIFF tag codes and names from TIFF6, TIFF/EP, EXIF, and other specs
return {
11: "ProcessingSoftware",
254: "NewSubfileType",
255: "SubfileType",
256: "ImageWidth",
257: "ImageLength",
258: "BitsPerSample",
259: "Compression",
262: "PhotometricInterpretation",
263: "Thresholding",
264: "CellWidth",
265: "CellLength",
266: "FillOrder",
269: "DocumentName",
270: "ImageDescription",
271: "Make",
272: "Model",
273: "StripOffsets",
274: "Orientation",
277: "SamplesPerPixel",
278: "RowsPerStrip",
279: "StripByteCounts",
280: "MinSampleValue",
281: "MaxSampleValue",
282: "XResolution",
283: "YResolution",
284: "PlanarConfiguration",
285: "PageName",
286: "XPosition",
287: "YPosition",
288: "FreeOffsets",
289: "FreeByteCounts",
290: "GrayResponseUnit",
291: "GrayResponseCurve",
292: "T4Options",
293: "T6Options",
296: "ResolutionUnit",
297: "PageNumber",
300: "ColorResponseUnit",
301: "TransferFunction",
305: "Software",
306: "DateTime",
315: "Artist",
316: "HostComputer",
317: "Predictor",
318: "WhitePoint",
319: "PrimaryChromaticities",
320: "ColorMap",
321: "HalftoneHints",
322: "TileWidth",
323: "TileLength",
324: "TileOffsets",
325: "TileByteCounts",
326: "BadFaxLines",
327: "CleanFaxData",
328: "ConsecutiveBadFaxLines",
330: "SubIFDs",
332: "InkSet",
333: "InkNames",
334: "NumberOfInks",
336: "DotRange",
337: "TargetPrinter",
338: "ExtraSamples",
339: "SampleFormat",
340: "SMinSampleValue",
341: "SMaxSampleValue",
342: "TransferRange",
343: "ClipPath",
344: "XClipPathUnits",
345: "YClipPathUnits",
346: "Indexed",
347: "JPEGTables",
351: "OPIProxy",
400: "GlobalParametersIFD",
401: "ProfileType",
402: "FaxProfile",
403: "CodingMethods",
404: "VersionYear",
405: "ModeNumber",
433: "Decode",
434: "DefaultImageColor",
435: "T82Options",
437: "JPEGTables_", # 347
512: "JPEGProc",
513: "JPEGInterchangeFormat",
514: "JPEGInterchangeFormatLength",
515: "JPEGRestartInterval",
517: "JPEGLosslessPredictors",
518: "JPEGPointTransforms",
519: "JPEGQTables",
520: "JPEGDCTables",
521: "JPEGACTables",
529: "YCbCrCoefficients",
530: "YCbCrSubSampling",
531: "YCbCrPositioning",
532: "ReferenceBlackWhite",
559: "StripRowCounts",
700: "XMP", # XMLPacket
769: "GDIGamma", # GDI+
770: "ICCProfileDescriptor", # GDI+
771: "SRGBRenderingIntent", # GDI+
800: "ImageTitle", # GDI+
999: "USPTO_Miscellaneous",
4864: "AndorId", # TODO: Andor Technology 4864 - 5030
4869: "AndorTemperature",
4876: "AndorExposureTime",
4878: "AndorKineticCycleTime",
4879: "AndorAccumulations",
4881: "AndorAcquisitionCycleTime",
4882: "AndorReadoutTime",
4884: "AndorPhotonCounting",
4885: "AndorEmDacLevel",
4890: "AndorFrames",
4896: "AndorHorizontalFlip",
4897: "AndorVerticalFlip",
4898: "AndorClockwise",
4899: "AndorCounterClockwise",
4904: "AndorVerticalClockVoltage",
4905: "AndorVerticalShiftSpeed",
4907: "AndorPreAmpSetting",
4908: "AndorCameraSerial",
4911: "AndorActualTemperature",
4912: "AndorBaselineClamp",
4913: "AndorPrescans",
4914: "AndorModel",
4915: "AndorChipSizeX",
4916: "AndorChipSizeY",
4944: "AndorBaselineOffset",
4966: "AndorSoftwareVersion",
18246: "Rating",
18247: "XP_DIP_XML",
18248: "StitchInfo",
18249: "RatingPercent",
20481: "ResolutionXUnit", # GDI+
20482: "ResolutionYUnit", # GDI+
20483: "ResolutionXLengthUnit", # GDI+
20484: "ResolutionYLengthUnit", # GDI+
20485: "PrintFlags", # GDI+
20486: "PrintFlagsVersion", # GDI+
20487: "PrintFlagsCrop", # GDI+
20488: "PrintFlagsBleedWidth", # GDI+
20489: "PrintFlagsBleedWidthScale", # GDI+
20490: "HalftoneLPI", # GDI+
20491: "HalftoneLPIUnit", # GDI+
20492: "HalftoneDegree", # GDI+
20493: "HalftoneShape", # GDI+
20494: "HalftoneMisc", # GDI+
20495: "HalftoneScreen", # GDI+
20496: "JPEGQuality", # GDI+
20497: "GridSize", # GDI+
20498: "ThumbnailFormat", # GDI+
20499: "ThumbnailWidth", # GDI+
20500: "ThumbnailHeight", # GDI+
20501: "ThumbnailColorDepth", # GDI+
20502: "ThumbnailPlanes", # GDI+
20503: "ThumbnailRawBytes", # GDI+
20504: "ThumbnailSize", # GDI+
20505: "ThumbnailCompressedSize", # GDI+
20506: "ColorTransferFunction", # GDI+
20507: "ThumbnailData",
20512: "ThumbnailImageWidth", # GDI+
20513: "ThumbnailImageHeight", # GDI+
20514: "ThumbnailBitsPerSample", # GDI+
20515: "ThumbnailCompression",
20516: "ThumbnailPhotometricInterp", # GDI+
20517: "ThumbnailImageDescription", # GDI+
20518: "ThumbnailEquipMake", # GDI+
20519: "ThumbnailEquipModel", # GDI+
20520: "ThumbnailStripOffsets", # GDI+
20521: "ThumbnailOrientation", # GDI+
20522: "ThumbnailSamplesPerPixel", # GDI+
20523: "ThumbnailRowsPerStrip", # GDI+
20524: "ThumbnailStripBytesCount", # GDI+
20525: "ThumbnailResolutionX",
20526: "ThumbnailResolutionY",
20527: "ThumbnailPlanarConfig", # GDI+
20528: "ThumbnailResolutionUnit",
20529: "ThumbnailTransferFunction",
20530: "ThumbnailSoftwareUsed", # GDI+
20531: "ThumbnailDateTime", # GDI+
20532: "ThumbnailArtist", # GDI+
20533: "ThumbnailWhitePoint", # GDI+
20534: "ThumbnailPrimaryChromaticities", # GDI+
20535: "ThumbnailYCbCrCoefficients", # GDI+
20536: "ThumbnailYCbCrSubsampling", # GDI+
20537: "ThumbnailYCbCrPositioning",
20538: "ThumbnailRefBlackWhite", # GDI+
20539: "ThumbnailCopyRight", # GDI+
20545: "InteroperabilityIndex",
20546: "InteroperabilityVersion",
20624: "LuminanceTable",
20625: "ChrominanceTable",
20736: "FrameDelay", # GDI+
20737: "LoopCount", # GDI+
20738: "GlobalPalette", # GDI+
20739: "IndexBackground", # GDI+
20740: "IndexTransparent", # GDI+
20752: "PixelUnit", # GDI+
20753: "PixelPerUnitX", # GDI+
20754: "PixelPerUnitY", # GDI+
20755: "PaletteHistogram", # GDI+
28672: "SonyRawFileType", # Sony ARW
28722: "VignettingCorrParams", # Sony ARW
28725: "ChromaticAberrationCorrParams", # Sony ARW
28727: "DistortionCorrParams", # Sony ARW
# Private tags >= 32768
32781: "ImageID",
32931: "WangTag1",
32932: "WangAnnotation",
32933: "WangTag3",
32934: "WangTag4",
32953: "ImageReferencePoints",
32954: "RegionXformTackPoint",
32955: "WarpQuadrilateral",
32956: "AffineTransformMat",
32995: "Matteing",
32996: "DataType",
32997: "ImageDepth",
32998: "TileDepth",
33300: "ImageFullWidth",
33301: "ImageFullLength",
33302: "TextureFormat",
33303: "TextureWrapModes",
33304: "FieldOfViewCotangent",
33305: "MatrixWorldToScreen",
33306: "MatrixWorldToCamera",
33405: "Model2",
33421: "CFARepeatPatternDim",
33422: "CFAPattern",
33423: "BatteryLevel",
33424: "KodakIFD",
33434: "ExposureTime",
33437: "FNumber",
33432: "Copyright",
33445: "MDFileTag",
33446: "MDScalePixel",
33447: "MDColorTable",
33448: "MDLabName",
33449: "MDSampleInfo",
33450: "MDPrepDate",
33451: "MDPrepTime",
33452: "MDFileUnits",
33550: "ModelPixelScaleTag",
33589: "AdventScale",
33590: "AdventRevision",
33628: "UIC1tag", # Metamorph Universal Imaging Corp STK
33629: "UIC2tag",
33630: "UIC3tag",
33631: "UIC4tag",
33723: "IPTCNAA",
33858: "ExtendedTagsOffset", # DEFF points IFD with private tags
33918: "IntergraphPacketData", # INGRPacketDataTag
33919: "IntergraphFlagRegisters", # INGRFlagRegisters
33920: "IntergraphMatrixTag", # IrasBTransformationMatrix
33921: "INGRReserved",
33922: "ModelTiepointTag",
33923: "LeicaMagic",
34016: "Site",
34017: "ColorSequence",
34018: "IT8Header",
34019: "RasterPadding",
34020: "BitsPerRunLength",
34021: "BitsPerExtendedRunLength",
34022: "ColorTable",
34023: "ImageColorIndicator",
34024: "BackgroundColorIndicator",
34025: "ImageColorValue",
34026: "BackgroundColorValue",
34027: "PixelIntensityRange",
34028: "TransparencyIndicator",
34029: "ColorCharacterization",
34030: "HCUsage",
34031: "TrapIndicator",
34032: "CMYKEquivalent",
34118: "CZ_SEM", # Zeiss SEM
34152: "AFCP_IPTC",
34232: "PixelMagicJBIGOptions",
34263: "JPLCartoIFD",
34122: "IPLAB", # number of images
34264: "ModelTransformationTag",
34306: "WB_GRGBLevels", # Leaf MOS
34310: "LeafData",
34361: "MM_Header",
34362: "MM_Stamp",
34363: "MM_Unknown",
34377: "ImageResources", # Photoshop
34386: "MM_UserBlock",
34412: "CZ_LSMINFO",
34665: "ExifTag",
34675: "InterColorProfile", # ICCProfile
34680: "FEI_SFEG", #
34682: "FEI_HELIOS", #
34683: "FEI_TITAN", #
34687: "FXExtensions",
34688: "MultiProfiles",
34689: "SharedData",
34690: "T88Options",
34710: "MarCCD", # offset to MarCCD header
34732: "ImageLayer",
34735: "GeoKeyDirectoryTag",
34736: "GeoDoubleParamsTag",
34737: "GeoAsciiParamsTag",
34750: "JBIGOptions",
34821: "PIXTIFF", # ? Pixel Translations Inc
34850: "ExposureProgram",
34852: "SpectralSensitivity",
34853: "GPSTag", # GPSIFD
34855: "ISOSpeedRatings",
34856: "OECF",
34857: "Interlace",
34858: "TimeZoneOffset",
34859: "SelfTimerMode",
34864: "SensitivityType",
34865: "StandardOutputSensitivity",
34866: "RecommendedExposureIndex",
34867: "ISOSpeed",
34868: "ISOSpeedLatitudeyyy",
34869: "ISOSpeedLatitudezzz",
34908: "HylaFAXFaxRecvParams",
34909: "HylaFAXFaxSubAddress",
34910: "HylaFAXFaxRecvTime",
34911: "FaxDcs",
34929: "FedexEDR",
34954: "LeafSubIFD",
34959: "Aphelion1",
34960: "Aphelion2",
34961: "AphelionInternal", # ADCIS
36864: "ExifVersion",
36867: "DateTimeOriginal",
36868: "DateTimeDigitized",
36873: "GooglePlusUploadCode",
36880: "OffsetTime",
36881: "OffsetTimeOriginal",
36882: "OffsetTimeDigitized",
# TODO: Pilatus/CHESS/TV6 36864..37120 conflicting with Exif tags
# 36864: 'TVX ?',
# 36865: 'TVX_NumExposure',
# 36866: 'TVX_NumBackground',
# 36867: 'TVX_ExposureTime',
# 36868: 'TVX_BackgroundTime',
# 36870: 'TVX ?',
# 36873: 'TVX_SubBpp',
# 36874: 'TVX_SubWide',
# 36875: 'TVX_SubHigh',
# 36876: 'TVX_BlackLevel',
# 36877: 'TVX_DarkCurrent',
# 36878: 'TVX_ReadNoise',
# 36879: 'TVX_DarkCurrentNoise',
# 36880: 'TVX_BeamMonitor',
# 37120: 'TVX_UserVariables', # A/D values
37121: "ComponentsConfiguration",
37122: "CompressedBitsPerPixel",
37377: "ShutterSpeedValue",
37378: "ApertureValue",
37379: "BrightnessValue",
37380: "ExposureBiasValue",
37381: "MaxApertureValue",
37382: "SubjectDistance",
37383: "MeteringMode",
37384: "LightSource",
37385: "Flash",
37386: "FocalLength",
37387: "FlashEnergy_", # 37387
37388: "SpatialFrequencyResponse_", # 37388
37389: "Noise",
37390: "FocalPlaneXResolution",
37391: "FocalPlaneYResolution",
37392: "FocalPlaneResolutionUnit",
37393: "ImageNumber",
37394: "SecurityClassification",
37395: "ImageHistory",
37396: "SubjectLocation",
37397: "ExposureIndex",
37398: "TIFFEPStandardID",
37399: "SensingMethod",
37434: "CIP3DataFile",
37435: "CIP3Sheet",
37436: "CIP3Side",
37439: "StoNits",
37500: "MakerNote",
37510: "UserComment",
37520: "SubsecTime",
37521: "SubsecTimeOriginal",
37522: "SubsecTimeDigitized",
37679: "MODIText", # Microsoft Office Document Imaging
37680: "MODIOLEPropertySetStorage",
37681: "MODIPositioning",
37706: "TVIPS", # offset to TemData structure
37707: "TVIPS1",
37708: "TVIPS2", # same TemData structure as undefined
37724: "ImageSourceData", # Photoshop
37888: "Temperature",
37889: "Humidity",
37890: "Pressure",
37891: "WaterDepth",
37892: "Acceleration",
37893: "CameraElevationAngle",
40001: "MC_IpWinScal", # Media Cybernetics
40100: "MC_IdOld",
40965: "InteroperabilityTag", # InteropOffset
40091: "XPTitle",
40092: "XPComment",
40093: "XPAuthor",
40094: "XPKeywords",
40095: "XPSubject",
40960: "FlashpixVersion",
40961: "ColorSpace",
40962: "PixelXDimension",
40963: "PixelYDimension",
40964: "RelatedSoundFile",
40976: "SamsungRawPointersOffset",
40977: "SamsungRawPointersLength",
41217: "SamsungRawByteOrder",
41218: "SamsungRawUnknown",
41483: "FlashEnergy",
41484: "SpatialFrequencyResponse",
41485: "Noise_", # 37389
41486: "FocalPlaneXResolution_", # 37390
41487: "FocalPlaneYResolution_", # 37391
41488: "FocalPlaneResolutionUnit_", # 37392
41489: "ImageNumber_", # 37393
41490: "SecurityClassification_", # 37394
41491: "ImageHistory_", # 37395
41492: "SubjectLocation_", # 37395
41493: "ExposureIndex_ ", # 37397
41494: "TIFF-EPStandardID",
41495: "SensingMethod_", # 37399
41728: "FileSource",
41729: "SceneType",
41730: "CFAPattern_", # 33422
41985: "CustomRendered",
41986: "ExposureMode",
41987: "WhiteBalance",
41988: "DigitalZoomRatio",
41989: "FocalLengthIn35mmFilm",
41990: "SceneCaptureType",
41991: "GainControl",
41992: "Contrast",
41993: "Saturation",
41994: "Sharpness",
41995: "DeviceSettingDescription",
41996: "SubjectDistanceRange",
42016: "ImageUniqueID",
42032: "CameraOwnerName",
42033: "BodySerialNumber",
42034: "LensSpecification",
42035: "LensMake",
42036: "LensModel",
42037: "LensSerialNumber",
42112: "GDAL_METADATA",
42113: "GDAL_NODATA",
42240: "Gamma",
43314: "NIHImageHeader",
44992: "ExpandSoftware",
44993: "ExpandLens",
44994: "ExpandFilm",
44995: "ExpandFilterLens",
44996: "ExpandScanner",
44997: "ExpandFlashLamp",
48129: "PixelFormat", # HDP and WDP
48130: "Transformation",
48131: "Uncompressed",
48132: "ImageType",
48256: "ImageWidth_", # 256
48257: "ImageHeight_",
48258: "WidthResolution",
48259: "HeightResolution",
48320: "ImageOffset",
48321: "ImageByteCount",
48322: "AlphaOffset",
48323: "AlphaByteCount",
48324: "ImageDataDiscard",
48325: "AlphaDataDiscard",
50215: "OceScanjobDescription",
50216: "OceApplicationSelector",
50217: "OceIdentificationNumber",
50218: "OceImageLogicCharacteristics",
50255: "Annotations",
50288: "MC_Id", # Media Cybernetics
50289: "MC_XYPosition",
50290: "MC_ZPosition",
50291: "MC_XYCalibration",
50292: "MC_LensCharacteristics",
50293: "MC_ChannelName",
50294: "MC_ExcitationWavelength",
50295: "MC_TimeStamp",
50296: "MC_FrameProperties",
50341: "PrintImageMatching",
50495: "PCO_RAW", # TODO: PCO CamWare
50547: "OriginalFileName",
50560: "USPTO_OriginalContentType", # US Patent Office
50561: "USPTO_RotationCode",
50656: "CR2CFAPattern",
50706: "DNGVersion", # DNG 50706 .. 51112
50707: "DNGBackwardVersion",
50708: "UniqueCameraModel",
50709: "LocalizedCameraModel",
50710: "CFAPlaneColor",
50711: "CFALayout",
50712: "LinearizationTable",
50713: "BlackLevelRepeatDim",
50714: "BlackLevel",
50715: "BlackLevelDeltaH",
50716: "BlackLevelDeltaV",
50717: "WhiteLevel",
50718: "DefaultScale",
50719: "DefaultCropOrigin",
50720: "DefaultCropSize",
50721: "ColorMatrix1",
50722: "ColorMatrix2",
50723: "CameraCalibration1",
50724: "CameraCalibration2",
50725: "ReductionMatrix1",
50726: "ReductionMatrix2",
50727: "AnalogBalance",
50728: "AsShotNeutral",
50729: "AsShotWhiteXY",
50730: "BaselineExposure",
50731: "BaselineNoise",
50732: "BaselineSharpness",
50733: "BayerGreenSplit",
50734: "LinearResponseLimit",
50735: "CameraSerialNumber",
50736: "LensInfo",
50737: "ChromaBlurRadius",
50738: "AntiAliasStrength",
50739: "ShadowScale",
50740: "DNGPrivateData",
50741: "MakerNoteSafety",
50752: "RawImageSegmentation",
50778: "CalibrationIlluminant1",
50779: "CalibrationIlluminant2",
50780: "BestQualityScale",
50781: "RawDataUniqueID",
50784: "AliasLayerMetadata",
50827: "OriginalRawFileName",
50828: "OriginalRawFileData",
50829: "ActiveArea",
50830: "MaskedAreas",
50831: "AsShotICCProfile",
50832: "AsShotPreProfileMatrix",
50833: "CurrentICCProfile",
50834: "CurrentPreProfileMatrix",
50838: "IJMetadataByteCounts",
50839: "IJMetadata",
50844: "RPCCoefficientTag",
50879: "ColorimetricReference",
50885: "SRawType",
50898: "PanasonicTitle",
50899: "PanasonicTitle2",
50931: "CameraCalibrationSignature",
50932: "ProfileCalibrationSignature",
50933: "ProfileIFD",
50934: "AsShotProfileName",
50935: "NoiseReductionApplied",
50936: "ProfileName",
50937: "ProfileHueSatMapDims",
50938: "ProfileHueSatMapData1",
50939: "ProfileHueSatMapData2",
50940: "ProfileToneCurve",
50941: "ProfileEmbedPolicy",
50942: "ProfileCopyright",
50964: "ForwardMatrix1",
50965: "ForwardMatrix2",
50966: "PreviewApplicationName",
50967: "PreviewApplicationVersion",
50968: "PreviewSettingsName",
50969: "PreviewSettingsDigest",
50970: "PreviewColorSpace",
50971: "PreviewDateTime",
50972: "RawImageDigest",
50973: "OriginalRawFileDigest",
50974: "SubTileBlockSize",
50975: "RowInterleaveFactor",
50981: "ProfileLookTableDims",
50982: "ProfileLookTableData",
51008: "OpcodeList1",
51009: "OpcodeList2",
51022: "OpcodeList3",
51023: "FibicsXML", #
51041: "NoiseProfile",
51043: "TimeCodes",
51044: "FrameRate",
51058: "TStop",
51081: "ReelName",
51089: "OriginalDefaultFinalSize",
51090: "OriginalBestQualitySize",
51091: "OriginalDefaultCropSize",
51105: "CameraLabel",
51107: "ProfileHueSatMapEncoding",
51108: "ProfileLookTableEncoding",
51109: "BaselineExposureOffset",
51110: "DefaultBlackRender",
51111: "NewRawImageDigest",
51112: "RawToPreviewGain",
51125: "DefaultUserCrop",
51123: "MicroManagerMetadata",
59932: "Padding",
59933: "OffsetSchema",
# Reusable Tags 65000-65535
# 65000: Dimap_Document XML
# 65000-65112: Photoshop Camera RAW EXIF tags
# 65000: 'OwnerName',
# 65001: 'SerialNumber',
# 65002: 'Lens',
# 65024: 'KDC_IFD',
# 65100: 'RawFile',
# 65101: 'Converter',
# 65102: 'WhiteBalance',
# 65105: 'Exposure',
# 65106: 'Shadows',
# 65107: 'Brightness',
# 65108: 'Contrast',
# 65109: 'Saturation',
# 65110: 'Sharpness',
# 65111: 'Smoothness',
# 65112: 'MoireFilter',
65200: "FlexXML", #
65563: "PerSample",
}
def TAG_NAMES():
return {v: c for c, v in TIFF.TAGS.items()}
def TAG_READERS():
# Map TIFF tag codes to import functions
return {
320: read_colormap,
# 700: read_bytes, # read_utf8,
# 34377: read_bytes,
33723: read_bytes,
# 34675: read_bytes,
33628: read_uic1tag, # Universal Imaging Corp STK
33629: read_uic2tag,
33630: read_uic3tag,
33631: read_uic4tag,
34118: read_cz_sem, # Carl Zeiss SEM
34361: read_mm_header, # Olympus FluoView
34362: read_mm_stamp,
34363: read_numpy, # MM_Unknown
34386: read_numpy, # MM_UserBlock
34412: read_cz_lsminfo, # Carl Zeiss LSM
34680: read_fei_metadata, # S-FEG
34682: read_fei_metadata, # Helios NanoLab
37706: read_tvips_header, # TVIPS EMMENU
37724: read_bytes, # ImageSourceData
33923: read_bytes, # read_leica_magic
43314: read_nih_image_header,
# 40001: read_bytes,
40100: read_bytes,
50288: read_bytes,
50296: read_bytes,
50839: read_bytes,
51123: read_json,
34665: read_exif_ifd,
34853: read_gps_ifd,
40965: read_interoperability_ifd,
}
def TAG_TUPLE():
# Tags whose values must be stored as tuples
return frozenset((273, 279, 324, 325, 530, 531, 34736))
def TAG_ATTRIBUTES():
# Map tag codes to TiffPage attribute names
return {
"ImageWidth": "imagewidth",
"ImageLength": "imagelength",
"BitsPerSample": "bitspersample",
"Compression": "compression",
"PlanarConfiguration": "planarconfig",
"FillOrder": "fillorder",
"PhotometricInterpretation": "photometric",
"ColorMap": "colormap",
"ImageDescription": "description",
"ImageDescription1": "description1",
"SamplesPerPixel": "samplesperpixel",
"RowsPerStrip": "rowsperstrip",
"Software": "software",
"Predictor": "predictor",
"TileWidth": "tilewidth",
"TileLength": "tilelength",
"ExtraSamples": "extrasamples",
"SampleFormat": "sampleformat",
"ImageDepth": "imagedepth",
"TileDepth": "tiledepth",
}
def TAG_ENUM():
return {
# 254: TIFF.FILETYPE,
255: TIFF.OFILETYPE,
259: TIFF.COMPRESSION,
262: TIFF.PHOTOMETRIC,
263: TIFF.THRESHHOLD,
266: TIFF.FILLORDER,
274: TIFF.ORIENTATION,
284: TIFF.PLANARCONFIG,
290: TIFF.GRAYRESPONSEUNIT,
# 292: TIFF.GROUP3OPT,
# 293: TIFF.GROUP4OPT,
296: TIFF.RESUNIT,
300: TIFF.COLORRESPONSEUNIT,
317: TIFF.PREDICTOR,
338: TIFF.EXTRASAMPLE,
339: TIFF.SAMPLEFORMAT,
# 512: TIFF.JPEGPROC,
# 531: TIFF.YCBCRPOSITION,
}
def FILETYPE():
class FILETYPE(enum.IntFlag):
# Python 3.6 only
UNDEFINED = 0
REDUCEDIMAGE = 1
PAGE = 2
MASK = 4
return FILETYPE
def OFILETYPE():
class OFILETYPE(enum.IntEnum):
UNDEFINED = 0
IMAGE = 1
REDUCEDIMAGE = 2
PAGE = 3
return OFILETYPE
def COMPRESSION():
class COMPRESSION(enum.IntEnum):
NONE = 1 # Uncompressed
CCITTRLE = 2 # CCITT 1D
CCITT_T4 = 3 # 'T4/Group 3 Fax',
CCITT_T6 = 4 # 'T6/Group 4 Fax',
LZW = 5
OJPEG = 6 # old-style JPEG
JPEG = 7
ADOBE_DEFLATE = 8
JBIG_BW = 9
JBIG_COLOR = 10
JPEG_99 = 99
KODAK_262 = 262
NEXT = 32766
SONY_ARW = 32767
PACKED_RAW = 32769
SAMSUNG_SRW = 32770
CCIRLEW = 32771
SAMSUNG_SRW2 = 32772
PACKBITS = 32773
THUNDERSCAN = 32809
IT8CTPAD = 32895
IT8LW = 32896
IT8MP = 32897
IT8BL = 32898
PIXARFILM = 32908
PIXARLOG = 32909
DEFLATE = 32946
DCS = 32947
APERIO_JP2000_YCBC = 33003 # Leica Aperio
APERIO_JP2000_RGB = 33005 # Leica Aperio
JBIG = 34661
SGILOG = 34676
SGILOG24 = 34677
JPEG2000 = 34712
NIKON_NEF = 34713
JBIG2 = 34715
MDI_BINARY = 34718 # 'Microsoft Document Imaging
MDI_PROGRESSIVE = 34719 # 'Microsoft Document Imaging
MDI_VECTOR = 34720 # 'Microsoft Document Imaging
JPEG_LOSSY = 34892
LZMA = 34925
ZSTD = 34926
OPS_PNG = 34933 # Objective Pathology Services
OPS_JPEGXR = 34934 # Objective Pathology Services
PIXTIFF = 50013
KODAK_DCR = 65000
PENTAX_PEF = 65535
# def __bool__(self): return self != 1 # Python 3.6 only
return COMPRESSION
def PHOTOMETRIC():
class PHOTOMETRIC(enum.IntEnum):
MINISWHITE = 0
MINISBLACK = 1
RGB = 2
PALETTE = 3
MASK = 4
SEPARATED = 5 # CMYK
YCBCR = 6
CIELAB = 8
ICCLAB = 9
ITULAB = 10
CFA = 32803 # Color Filter Array
LOGL = 32844
LOGLUV = 32845
LINEAR_RAW = 34892
return PHOTOMETRIC
def THRESHHOLD():
class THRESHHOLD(enum.IntEnum):
BILEVEL = 1
HALFTONE = 2
ERRORDIFFUSE = 3
return THRESHHOLD
def FILLORDER():
class FILLORDER(enum.IntEnum):
MSB2LSB = 1
LSB2MSB = 2
return FILLORDER
def ORIENTATION():
class ORIENTATION(enum.IntEnum):
TOPLEFT = 1
TOPRIGHT = 2
BOTRIGHT = 3
BOTLEFT = 4
LEFTTOP = 5
RIGHTTOP = 6
RIGHTBOT = 7
LEFTBOT = 8
return ORIENTATION
def PLANARCONFIG():
class PLANARCONFIG(enum.IntEnum):
CONTIG = 1
SEPARATE = 2
return PLANARCONFIG
def GRAYRESPONSEUNIT():
class GRAYRESPONSEUNIT(enum.IntEnum):
_10S = 1
_100S = 2
_1000S = 3
_10000S = 4
_100000S = 5
return GRAYRESPONSEUNIT
def GROUP4OPT():
class GROUP4OPT(enum.IntEnum):
UNCOMPRESSED = 2
return GROUP4OPT
def RESUNIT():
class RESUNIT(enum.IntEnum):
NONE = 1
INCH = 2
CENTIMETER = 3
# def __bool__(self): return self != 1 # Python 3.6 only
return RESUNIT
def COLORRESPONSEUNIT():
class COLORRESPONSEUNIT(enum.IntEnum):
_10S = 1
_100S = 2
_1000S = 3
_10000S = 4
_100000S = 5
return COLORRESPONSEUNIT
def PREDICTOR():
class PREDICTOR(enum.IntEnum):
NONE = 1
HORIZONTAL = 2
FLOATINGPOINT = 3
# def __bool__(self): return self != 1 # Python 3.6 only
return PREDICTOR
def EXTRASAMPLE():
class EXTRASAMPLE(enum.IntEnum):
UNSPECIFIED = 0
ASSOCALPHA = 1
UNASSALPHA = 2
return EXTRASAMPLE
def SAMPLEFORMAT():
class SAMPLEFORMAT(enum.IntEnum):
UINT = 1
INT = 2
IEEEFP = 3
VOID = 4
COMPLEXINT = 5
COMPLEXIEEEFP = 6
return SAMPLEFORMAT
def DATATYPES():
class DATATYPES(enum.IntEnum):
NOTYPE = 0
BYTE = 1
ASCII = 2
SHORT = 3
LONG = 4
RATIONAL = 5
SBYTE = 6
UNDEFINED = 7
SSHORT = 8
SLONG = 9
SRATIONAL = 10
FLOAT = 11
DOUBLE = 12
IFD = 13
UNICODE = 14
COMPLEX = 15
LONG8 = 16
SLONG8 = 17
IFD8 = 18
return DATATYPES
def DATA_FORMATS():
# Map TIFF DATATYPES to Python struct formats
return {
1: "1B", # BYTE 8-bit unsigned integer.
2: "1s", # ASCII 8-bit byte that contains a 7-bit ASCII code;
# the last byte must be NULL (binary zero).
3: "1H", # SHORT 16-bit (2-byte) unsigned integer
4: "1I", # LONG 32-bit (4-byte) unsigned integer.
5: "2I", # RATIONAL Two LONGs: the first represents the numerator
# of a fraction; the second, the denominator.
6: "1b", # SBYTE An 8-bit signed (twos-complement) integer.
7: "1B", # UNDEFINED An 8-bit byte that may contain anything,
# depending on the definition of the field.
8: "1h", # SSHORT A 16-bit (2-byte) signed (twos-complement)
# integer.
9: "1i", # SLONG A 32-bit (4-byte) signed (twos-complement)
# integer.
10: "2i", # SRATIONAL Two SLONGs: the first represents the
# numerator of a fraction, the second the denominator.
11: "1f", # FLOAT Single precision (4-byte) IEEE format.
12: "1d", # DOUBLE Double precision (8-byte) IEEE format.
13: "1I", # IFD unsigned 4 byte IFD offset.
# 14: '', # UNICODE
# 15: '', # COMPLEX
16: "1Q", # LONG8 unsigned 8 byte integer (BigTiff)
17: "1q", # SLONG8 signed 8 byte integer (BigTiff)
18: "1Q", # IFD8 unsigned 8 byte IFD offset (BigTiff)
}
def DATA_DTYPES():
# Map numpy dtypes to TIFF DATATYPES
return {
"B": 1,
"s": 2,
"H": 3,
"I": 4,
"2I": 5,
"b": 6,
"h": 8,
"i": 9,
"2i": 10,
"f": 11,
"d": 12,
"Q": 16,
"q": 17,
}
def SAMPLE_DTYPES():
# Map TIFF SampleFormats and BitsPerSample to numpy dtype
return {
(1, 1): "?", # bitmap
(1, 2): "B",
(1, 3): "B",
(1, 4): "B",
(1, 5): "B",
(1, 6): "B",
(1, 7): "B",
(1, 8): "B",
(1, 9): "H",
(1, 10): "H",
(1, 11): "H",
(1, 12): "H",
(1, 13): "H",
(1, 14): "H",
(1, 15): "H",
(1, 16): "H",
(1, 17): "I",
(1, 18): "I",
(1, 19): "I",
(1, 20): "I",
(1, 21): "I",
(1, 22): "I",
(1, 23): "I",
(1, 24): "I",
(1, 25): "I",
(1, 26): "I",
(1, 27): "I",
(1, 28): "I",
(1, 29): "I",
(1, 30): "I",
(1, 31): "I",
(1, 32): "I",
(1, 64): "Q",
(2, 8): "b",
(2, 16): "h",
(2, 32): "i",
(2, 64): "q",
(3, 16): "e",
(3, 32): "f",
(3, 64): "d",
(6, 64): "F",
(6, 128): "D",
(1, (5, 6, 5)): "B",
}
def COMPESSORS():
# Map COMPRESSION to compress functions and default compression levels
class Compressors(object):
"""Delay import compressor functions."""
def __init__(self):
self._compressors = {8: (zlib.compress, 6), 32946: (zlib.compress, 6)}
def __getitem__(self, key):
if key in self._compressors:
return self._compressors[key]
if key == 34925:
try:
import lzma # delayed import
except ImportError:
try:
import backports.lzma as lzma # delayed import
except ImportError:
raise KeyError
def lzma_compress(x, level):
return lzma.compress(x)
self._compressors[key] = lzma_compress, 0
return lzma_compress, 0
if key == 34926:
try:
import zstd # delayed import
except ImportError:
raise KeyError
self._compressors[key] = zstd.compress, 9
return zstd.compress, 9
raise KeyError
def __contains__(self, key):
try:
self[key]
return True
except KeyError:
return False
return Compressors()
def DECOMPESSORS():
# Map COMPRESSION to decompress functions
class Decompressors(object):
"""Delay import decompressor functions."""
def __init__(self):
self._decompressors = {
None: identityfunc,
1: identityfunc,
5: decode_lzw,
8: zlib.decompress,
32773: decode_packbits,
32946: zlib.decompress,
}
def __getitem__(self, key):
if key in self._decompressors:
return self._decompressors[key]
if key == 7:
try:
from imagecodecs import jpeg, jpeg_12
except ImportError:
raise KeyError
def decode_jpeg(x, table, bps, colorspace=None):
if bps == 8:
return jpeg.decode_jpeg(x, table, colorspace)
elif bps == 12:
return jpeg_12.decode_jpeg_12(x, table, colorspace)
else:
raise ValueError("bitspersample not supported")
self._decompressors[key] = decode_jpeg
return decode_jpeg
if key == 34925:
try:
import lzma # delayed import
except ImportError:
try:
import backports.lzma as lzma # delayed import
except ImportError:
raise KeyError
self._decompressors[key] = lzma.decompress
return lzma.decompress
if key == 34926:
try:
import zstd # delayed import
except ImportError:
raise KeyError
self._decompressors[key] = zstd.decompress
return zstd.decompress
raise KeyError
def __contains__(self, item):
try:
self[item]
return True
except KeyError:
return False
return Decompressors()
def FRAME_ATTRS():
# Attributes that a TiffFrame shares with its keyframe
return set("shape ndim size dtype axes is_final".split())
def FILE_FLAGS():
# TiffFile and TiffPage 'is_\*' attributes
exclude = set(
"reduced final memmappable contiguous tiled " "chroma_subsampled".split()
)
return set(
a[3:] for a in dir(TiffPage) if a[:3] == "is_" and a[3:] not in exclude
)
def FILE_EXTENSIONS():
# TIFF file extensions
return tuple(
"tif tiff ome.tif lsm stk qptiff pcoraw "
"gel seq svs bif tf8 tf2 btf".split()
)
def FILEOPEN_FILTER():
# String for use in Windows File Open box
return [
("%s files" % ext.upper(), "*.%s" % ext) for ext in TIFF.FILE_EXTENSIONS
] + [("allfiles", "*")]
def AXES_LABELS():
# TODO: is there a standard for character axes labels?
axes = {
"X": "width",
"Y": "height",
"Z": "depth",
"S": "sample", # rgb(a)
"I": "series", # general sequence, plane, page, IFD
"T": "time",
"C": "channel", # color, emission wavelength
"A": "angle",
"P": "phase", # formerly F # P is Position in LSM!
"R": "tile", # region, point, mosaic
"H": "lifetime", # histogram
"E": "lambda", # excitation wavelength
"L": "exposure", # lux
"V": "event",
"Q": "other",
"M": "mosaic", # LSM 6
}
axes.update(dict((v, k) for k, v in axes.items()))
return axes
def ANDOR_TAGS():
# Andor Technology tags #4864 - 5030
return set(range(4864, 5030))
def EXIF_TAGS():
tags = {
# 65000 - 65112 Photoshop Camera RAW EXIF tags
65000: "OwnerName",
65001: "SerialNumber",
65002: "Lens",
65100: "RawFile",
65101: "Converter",
65102: "WhiteBalance",
65105: "Exposure",
65106: "Shadows",
65107: "Brightness",
65108: "Contrast",
65109: "Saturation",
65110: "Sharpness",
65111: "Smoothness",
65112: "MoireFilter",
}
tags.update(TIFF.TAGS)
return tags
def GPS_TAGS():
return {
0: "GPSVersionID",
1: "GPSLatitudeRef",
2: "GPSLatitude",
3: "GPSLongitudeRef",
4: "GPSLongitude",
5: "GPSAltitudeRef",
6: "GPSAltitude",
7: "GPSTimeStamp",
8: "GPSSatellites",
9: "GPSStatus",
10: "GPSMeasureMode",
11: "GPSDOP",
12: "GPSSpeedRef",
13: "GPSSpeed",
14: "GPSTrackRef",
15: "GPSTrack",
16: "GPSImgDirectionRef",
17: "GPSImgDirection",
18: "GPSMapDatum",
19: "GPSDestLatitudeRef",
20: "GPSDestLatitude",
21: "GPSDestLongitudeRef",
22: "GPSDestLongitude",
23: "GPSDestBearingRef",
24: "GPSDestBearing",
25: "GPSDestDistanceRef",
26: "GPSDestDistance",
27: "GPSProcessingMethod",
28: "GPSAreaInformation",
29: "GPSDateStamp",
30: "GPSDifferential",
31: "GPSHPositioningError",
}
def IOP_TAGS():
return {
1: "InteroperabilityIndex",
2: "InteroperabilityVersion",
4096: "RelatedImageFileFormat",
4097: "RelatedImageWidth",
4098: "RelatedImageLength",
}
def GEO_KEYS():
return {
1024: "GTModelTypeGeoKey",
1025: "GTRasterTypeGeoKey",
1026: "GTCitationGeoKey",
2048: "GeographicTypeGeoKey",
2049: "GeogCitationGeoKey",
2050: "GeogGeodeticDatumGeoKey",
2051: "GeogPrimeMeridianGeoKey",
2052: "GeogLinearUnitsGeoKey",
2053: "GeogLinearUnitSizeGeoKey",
2054: "GeogAngularUnitsGeoKey",
2055: "GeogAngularUnitsSizeGeoKey",
2056: "GeogEllipsoidGeoKey",
2057: "GeogSemiMajorAxisGeoKey",
2058: "GeogSemiMinorAxisGeoKey",
2059: "GeogInvFlatteningGeoKey",
2060: "GeogAzimuthUnitsGeoKey",
2061: "GeogPrimeMeridianLongGeoKey",
2062: "GeogTOWGS84GeoKey",
3059: "ProjLinearUnitsInterpCorrectGeoKey", # GDAL
3072: "ProjectedCSTypeGeoKey",
3073: "PCSCitationGeoKey",
3074: "ProjectionGeoKey",
3075: "ProjCoordTransGeoKey",
3076: "ProjLinearUnitsGeoKey",
3077: "ProjLinearUnitSizeGeoKey",
3078: "ProjStdParallel1GeoKey",
3079: "ProjStdParallel2GeoKey",
3080: "ProjNatOriginLongGeoKey",
3081: "ProjNatOriginLatGeoKey",
3082: "ProjFalseEastingGeoKey",
3083: "ProjFalseNorthingGeoKey",
3084: "ProjFalseOriginLongGeoKey",
3085: "ProjFalseOriginLatGeoKey",
3086: "ProjFalseOriginEastingGeoKey",
3087: "ProjFalseOriginNorthingGeoKey",
3088: "ProjCenterLongGeoKey",
3089: "ProjCenterLatGeoKey",
3090: "ProjCenterEastingGeoKey",
3091: "ProjFalseOriginNorthingGeoKey",
3092: "ProjScaleAtNatOriginGeoKey",
3093: "ProjScaleAtCenterGeoKey",
3094: "ProjAzimuthAngleGeoKey",
3095: "ProjStraightVertPoleLongGeoKey",
3096: "ProjRectifiedGridAngleGeoKey",
4096: "VerticalCSTypeGeoKey",
4097: "VerticalCitationGeoKey",
4098: "VerticalDatumGeoKey",
4099: "VerticalUnitsGeoKey",
}
def GEO_CODES():
try:
from .tifffile_geodb import GEO_CODES # delayed import
except (ImportError, ValueError):
try:
from tifffile_geodb import GEO_CODES # delayed import
except (ImportError, ValueError):
GEO_CODES = {}
return GEO_CODES
def CZ_LSMINFO():
return [
("MagicNumber", "u4"),
("StructureSize", "i4"),
("DimensionX", "i4"),
("DimensionY", "i4"),
("DimensionZ", "i4"),
("DimensionChannels", "i4"),
("DimensionTime", "i4"),
("DataType", "i4"), # DATATYPES
("ThumbnailX", "i4"),
("ThumbnailY", "i4"),
("VoxelSizeX", "f8"),
("VoxelSizeY", "f8"),
("VoxelSizeZ", "f8"),
("OriginX", "f8"),
("OriginY", "f8"),
("OriginZ", "f8"),
("ScanType", "u2"),
("SpectralScan", "u2"),
("TypeOfData", "u4"), # TYPEOFDATA
("OffsetVectorOverlay", "u4"),
("OffsetInputLut", "u4"),
("OffsetOutputLut", "u4"),
("OffsetChannelColors", "u4"),
("TimeIntervall", "f8"),
("OffsetChannelDataTypes", "u4"),
("OffsetScanInformation", "u4"), # SCANINFO
("OffsetKsData", "u4"),
("OffsetTimeStamps", "u4"),
("OffsetEventList", "u4"),
("OffsetRoi", "u4"),
("OffsetBleachRoi", "u4"),
("OffsetNextRecording", "u4"),
# LSM 2.0 ends here
("DisplayAspectX", "f8"),
("DisplayAspectY", "f8"),
("DisplayAspectZ", "f8"),
("DisplayAspectTime", "f8"),
("OffsetMeanOfRoisOverlay", "u4"),
("OffsetTopoIsolineOverlay", "u4"),
("OffsetTopoProfileOverlay", "u4"),
("OffsetLinescanOverlay", "u4"),
("ToolbarFlags", "u4"),
("OffsetChannelWavelength", "u4"),
("OffsetChannelFactors", "u4"),
("ObjectiveSphereCorrection", "f8"),
("OffsetUnmixParameters", "u4"),
# LSM 3.2, 4.0 end here
("OffsetAcquisitionParameters", "u4"),
("OffsetCharacteristics", "u4"),
("OffsetPalette", "u4"),
("TimeDifferenceX", "f8"),
("TimeDifferenceY", "f8"),
("TimeDifferenceZ", "f8"),
("InternalUse1", "u4"),
("DimensionP", "i4"),
("DimensionM", "i4"),
("DimensionsReserved", "16i4"),
("OffsetTilePositions", "u4"),
("", "9u4"), # Reserved
("OffsetPositions", "u4"),
# ('', '21u4'), # must be 0
]
def CZ_LSMINFO_READERS():
# Import functions for CZ_LSMINFO sub-records
# TODO: read more CZ_LSMINFO sub-records
return {
"ScanInformation": read_lsm_scaninfo,
"TimeStamps": read_lsm_timestamps,
"EventList": read_lsm_eventlist,
"ChannelColors": read_lsm_channelcolors,
"Positions": read_lsm_floatpairs,
"TilePositions": read_lsm_floatpairs,
"VectorOverlay": None,
"InputLut": None,
"OutputLut": None,
"TimeIntervall": None,
"ChannelDataTypes": None,
"KsData": None,
"Roi": None,
"BleachRoi": None,
"NextRecording": None,
"MeanOfRoisOverlay": None,
"TopoIsolineOverlay": None,
"TopoProfileOverlay": None,
"ChannelWavelength": None,
"SphereCorrection": None,
"ChannelFactors": None,
"UnmixParameters": None,
"AcquisitionParameters": None,
"Characteristics": None,
}
def CZ_LSMINFO_SCANTYPE():
# Map CZ_LSMINFO.ScanType to dimension order
return {
0: "XYZCT", # 'Stack' normal x-y-z-scan
1: "XYZCT", # 'Z-Scan' x-z-plane Y=1
2: "XYZCT", # 'Line'
3: "XYTCZ", # 'Time Series Plane' time series x-y XYCTZ ? Z=1
4: "XYZTC", # 'Time Series z-Scan' time series x-z
5: "XYTCZ", # 'Time Series Mean-of-ROIs'
6: "XYZTC", # 'Time Series Stack' time series x-y-z
7: "XYCTZ", # Spline Scan
8: "XYCZT", # Spline Plane x-z
9: "XYTCZ", # Time Series Spline Plane x-z
10: "XYZCT", # 'Time Series Point' point mode
}
def CZ_LSMINFO_DIMENSIONS():
# Map dimension codes to CZ_LSMINFO attribute
return {
"X": "DimensionX",
"Y": "DimensionY",
"Z": "DimensionZ",
"C": "DimensionChannels",
"T": "DimensionTime",
"P": "DimensionP",
"M": "DimensionM",
}
def CZ_LSMINFO_DATATYPES():
# Description of CZ_LSMINFO.DataType
return {
0: "varying data types",
1: "8 bit unsigned integer",
2: "12 bit unsigned integer",
5: "32 bit float",
}
def CZ_LSMINFO_TYPEOFDATA():
# Description of CZ_LSMINFO.TypeOfData
return {
0: "Original scan data",
1: "Calculated data",
2: "3D reconstruction",
3: "Topography height map",
}
def CZ_LSMINFO_SCANINFO_ARRAYS():
return {
0x20000000: "Tracks",
0x30000000: "Lasers",
0x60000000: "DetectionChannels",
0x80000000: "IlluminationChannels",
0xA0000000: "BeamSplitters",
0xC0000000: "DataChannels",
0x11000000: "Timers",
0x13000000: "Markers",
}
def CZ_LSMINFO_SCANINFO_STRUCTS():
return {
# 0x10000000: 'Recording',
0x40000000: "Track",
0x50000000: "Laser",
0x70000000: "DetectionChannel",
0x90000000: "IlluminationChannel",
0xB0000000: "BeamSplitter",
0xD0000000: "DataChannel",
0x12000000: "Timer",
0x14000000: "Marker",
}
def CZ_LSMINFO_SCANINFO_ATTRIBUTES():
return {
# Recording
0x10000001: "Name",
0x10000002: "Description",
0x10000003: "Notes",
0x10000004: "Objective",
0x10000005: "ProcessingSummary",
0x10000006: "SpecialScanMode",
0x10000007: "ScanType",
0x10000008: "ScanMode",
0x10000009: "NumberOfStacks",
0x1000000A: "LinesPerPlane",
0x1000000B: "SamplesPerLine",
0x1000000C: "PlanesPerVolume",
0x1000000D: "ImagesWidth",
0x1000000E: "ImagesHeight",
0x1000000F: "ImagesNumberPlanes",
0x10000010: "ImagesNumberStacks",
0x10000011: "ImagesNumberChannels",
0x10000012: "LinscanXySize",
0x10000013: "ScanDirection",
0x10000014: "TimeSeries",
0x10000015: "OriginalScanData",
0x10000016: "ZoomX",
0x10000017: "ZoomY",
0x10000018: "ZoomZ",
0x10000019: "Sample0X",
0x1000001A: "Sample0Y",
0x1000001B: "Sample0Z",
0x1000001C: "SampleSpacing",
0x1000001D: "LineSpacing",
0x1000001E: "PlaneSpacing",
0x1000001F: "PlaneWidth",
0x10000020: "PlaneHeight",
0x10000021: "VolumeDepth",
0x10000023: "Nutation",
0x10000034: "Rotation",
0x10000035: "Precession",
0x10000036: "Sample0time",
0x10000037: "StartScanTriggerIn",
0x10000038: "StartScanTriggerOut",
0x10000039: "StartScanEvent",
0x10000040: "StartScanTime",
0x10000041: "StopScanTriggerIn",
0x10000042: "StopScanTriggerOut",
0x10000043: "StopScanEvent",
0x10000044: "StopScanTime",
0x10000045: "UseRois",
0x10000046: "UseReducedMemoryRois",
0x10000047: "User",
0x10000048: "UseBcCorrection",
0x10000049: "PositionBcCorrection1",
0x10000050: "PositionBcCorrection2",
0x10000051: "InterpolationY",
0x10000052: "CameraBinning",
0x10000053: "CameraSupersampling",
0x10000054: "CameraFrameWidth",
0x10000055: "CameraFrameHeight",
0x10000056: "CameraOffsetX",
0x10000057: "CameraOffsetY",
0x10000059: "RtBinning",
0x1000005A: "RtFrameWidth",
0x1000005B: "RtFrameHeight",
0x1000005C: "RtRegionWidth",
0x1000005D: "RtRegionHeight",
0x1000005E: "RtOffsetX",
0x1000005F: "RtOffsetY",
0x10000060: "RtZoom",
0x10000061: "RtLinePeriod",
0x10000062: "Prescan",
0x10000063: "ScanDirectionZ",
# Track
0x40000001: "MultiplexType", # 0 After Line; 1 After Frame
0x40000002: "MultiplexOrder",
0x40000003: "SamplingMode", # 0 Sample; 1 Line Avg; 2 Frame Avg
0x40000004: "SamplingMethod", # 1 Mean; 2 Sum
0x40000005: "SamplingNumber",
0x40000006: "Acquire",
0x40000007: "SampleObservationTime",
0x4000000B: "TimeBetweenStacks",
0x4000000C: "Name",
0x4000000D: "Collimator1Name",
0x4000000E: "Collimator1Position",
0x4000000F: "Collimator2Name",
0x40000010: "Collimator2Position",
0x40000011: "IsBleachTrack",
0x40000012: "IsBleachAfterScanNumber",
0x40000013: "BleachScanNumber",
0x40000014: "TriggerIn",
0x40000015: "TriggerOut",
0x40000016: "IsRatioTrack",
0x40000017: "BleachCount",
0x40000018: "SpiCenterWavelength",
0x40000019: "PixelTime",
0x40000021: "CondensorFrontlens",
0x40000023: "FieldStopValue",
0x40000024: "IdCondensorAperture",
0x40000025: "CondensorAperture",
0x40000026: "IdCondensorRevolver",
0x40000027: "CondensorFilter",
0x40000028: "IdTransmissionFilter1",
0x40000029: "IdTransmission1",
0x40000030: "IdTransmissionFilter2",
0x40000031: "IdTransmission2",
0x40000032: "RepeatBleach",
0x40000033: "EnableSpotBleachPos",
0x40000034: "SpotBleachPosx",
0x40000035: "SpotBleachPosy",
0x40000036: "SpotBleachPosz",
0x40000037: "IdTubelens",
0x40000038: "IdTubelensPosition",
0x40000039: "TransmittedLight",
0x4000003A: "ReflectedLight",
0x4000003B: "SimultanGrabAndBleach",
0x4000003C: "BleachPixelTime",
# Laser
0x50000001: "Name",
0x50000002: "Acquire",
0x50000003: "Power",
# DetectionChannel
0x70000001: "IntegrationMode",
0x70000002: "SpecialMode",
0x70000003: "DetectorGainFirst",
0x70000004: "DetectorGainLast",
0x70000005: "AmplifierGainFirst",
0x70000006: "AmplifierGainLast",
0x70000007: "AmplifierOffsFirst",
0x70000008: "AmplifierOffsLast",
0x70000009: "PinholeDiameter",
0x7000000A: "CountingTrigger",
0x7000000B: "Acquire",
0x7000000C: "PointDetectorName",
0x7000000D: "AmplifierName",
0x7000000E: "PinholeName",
0x7000000F: "FilterSetName",
0x70000010: "FilterName",
0x70000013: "IntegratorName",
0x70000014: "ChannelName",
0x70000015: "DetectorGainBc1",
0x70000016: "DetectorGainBc2",
0x70000017: "AmplifierGainBc1",
0x70000018: "AmplifierGainBc2",
0x70000019: "AmplifierOffsetBc1",
0x70000020: "AmplifierOffsetBc2",
0x70000021: "SpectralScanChannels",
0x70000022: "SpiWavelengthStart",
0x70000023: "SpiWavelengthStop",
0x70000026: "DyeName",
0x70000027: "DyeFolder",
# IlluminationChannel
0x90000001: "Name",
0x90000002: "Power",
0x90000003: "Wavelength",
0x90000004: "Aquire",
0x90000005: "DetchannelName",
0x90000006: "PowerBc1",
0x90000007: "PowerBc2",
# BeamSplitter
0xB0000001: "FilterSet",
0xB0000002: "Filter",
0xB0000003: "Name",
# DataChannel
0xD0000001: "Name",
0xD0000003: "Acquire",
0xD0000004: "Color",
0xD0000005: "SampleType",
0xD0000006: "BitsPerSample",
0xD0000007: "RatioType",
0xD0000008: "RatioTrack1",
0xD0000009: "RatioTrack2",
0xD000000A: "RatioChannel1",
0xD000000B: "RatioChannel2",
0xD000000C: "RatioConst1",
0xD000000D: "RatioConst2",
0xD000000E: "RatioConst3",
0xD000000F: "RatioConst4",
0xD0000010: "RatioConst5",
0xD0000011: "RatioConst6",
0xD0000012: "RatioFirstImages1",
0xD0000013: "RatioFirstImages2",
0xD0000014: "DyeName",
0xD0000015: "DyeFolder",
0xD0000016: "Spectrum",
0xD0000017: "Acquire",
# Timer
0x12000001: "Name",
0x12000002: "Description",
0x12000003: "Interval",
0x12000004: "TriggerIn",
0x12000005: "TriggerOut",
0x12000006: "ActivationTime",
0x12000007: "ActivationNumber",
# Marker
0x14000001: "Name",
0x14000002: "Description",
0x14000003: "TriggerIn",
0x14000004: "TriggerOut",
}
def NIH_IMAGE_HEADER():
return [
("FileID", "a8"),
("nLines", "i2"),
("PixelsPerLine", "i2"),
("Version", "i2"),
("OldLutMode", "i2"),
("OldnColors", "i2"),
("Colors", "u1", (3, 32)),
("OldColorStart", "i2"),
("ColorWidth", "i2"),
("ExtraColors", "u2", (6, 3)),
("nExtraColors", "i2"),
("ForegroundIndex", "i2"),
("BackgroundIndex", "i2"),
("XScale", "f8"),
("Unused2", "i2"),
("Unused3", "i2"),
("UnitsID", "i2"), # NIH_UNITS_TYPE
("p1", [("x", "i2"), ("y", "i2")]),
("p2", [("x", "i2"), ("y", "i2")]),
("CurveFitType", "i2"), # NIH_CURVEFIT_TYPE
("nCoefficients", "i2"),
("Coeff", "f8", 6),
("UMsize", "u1"),
("UM", "a15"),
("UnusedBoolean", "u1"),
("BinaryPic", "b1"),
("SliceStart", "i2"),
("SliceEnd", "i2"),
("ScaleMagnification", "f4"),
("nSlices", "i2"),
("SliceSpacing", "f4"),
("CurrentSlice", "i2"),
("FrameInterval", "f4"),
("PixelAspectRatio", "f4"),
("ColorStart", "i2"),
("ColorEnd", "i2"),
("nColors", "i2"),
("Fill1", "3u2"),
("Fill2", "3u2"),
("Table", "u1"), # NIH_COLORTABLE_TYPE
("LutMode", "u1"), # NIH_LUTMODE_TYPE
("InvertedTable", "b1"),
("ZeroClip", "b1"),
("XUnitSize", "u1"),
("XUnit", "a11"),
("StackType", "i2"), # NIH_STACKTYPE_TYPE
# ('UnusedBytes', 'u1', 200)
]
def NIH_COLORTABLE_TYPE():
return (
"CustomTable",
"AppleDefault",
"Pseudo20",
"Pseudo32",
"Rainbow",
"Fire1",
"Fire2",
"Ice",
"Grays",
"Spectrum",
)
def NIH_LUTMODE_TYPE():
return (
"PseudoColor",
"OldAppleDefault",
"OldSpectrum",
"GrayScale",
"ColorLut",
"CustomGrayscale",
)
def NIH_CURVEFIT_TYPE():
return (
"StraightLine",
"Poly2",
"Poly3",
"Poly4",
"Poly5",
"ExpoFit",
"PowerFit",
"LogFit",
"RodbardFit",
"SpareFit1",
"Uncalibrated",
"UncalibratedOD",
)
def NIH_UNITS_TYPE():
return (
"Nanometers",
"Micrometers",
"Millimeters",
"Centimeters",
"Meters",
"Kilometers",
"Inches",
"Feet",
"Miles",
"Pixels",
"OtherUnits",
)
def NIH_STACKTYPE_TYPE():
return ("VolumeStack", "RGBStack", "MovieStack", "HSVStack")
def TVIPS_HEADER_V1():
# TVIPS TemData structure from EMMENU Help file
return [
("Version", "i4"),
("CommentV1", "a80"),
("HighTension", "i4"),
("SphericalAberration", "i4"),
("IlluminationAperture", "i4"),
("Magnification", "i4"),
("PostMagnification", "i4"),
("FocalLength", "i4"),
("Defocus", "i4"),
("Astigmatism", "i4"),
("AstigmatismDirection", "i4"),
("BiprismVoltage", "i4"),
("SpecimenTiltAngle", "i4"),
("SpecimenTiltDirection", "i4"),
("IlluminationTiltDirection", "i4"),
("IlluminationTiltAngle", "i4"),
("ImageMode", "i4"),
("EnergySpread", "i4"),
("ChromaticAberration", "i4"),
("ShutterType", "i4"),
("DefocusSpread", "i4"),
("CcdNumber", "i4"),
("CcdSize", "i4"),
("OffsetXV1", "i4"),
("OffsetYV1", "i4"),
("PhysicalPixelSize", "i4"),
("Binning", "i4"),
("ReadoutSpeed", "i4"),
("GainV1", "i4"),
("SensitivityV1", "i4"),
("ExposureTimeV1", "i4"),
("FlatCorrected", "i4"),
("DeadPxCorrected", "i4"),
("ImageMean", "i4"),
("ImageStd", "i4"),
("DisplacementX", "i4"),
("DisplacementY", "i4"),
("DateV1", "i4"),
("TimeV1", "i4"),
("ImageMin", "i4"),
("ImageMax", "i4"),
("ImageStatisticsQuality", "i4"),
]
def TVIPS_HEADER_V2():
return [
("ImageName", "V160"), # utf16
("ImageFolder", "V160"),
("ImageSizeX", "i4"),
("ImageSizeY", "i4"),
("ImageSizeZ", "i4"),
("ImageSizeE", "i4"),
("ImageDataType", "i4"),
("Date", "i4"),
("Time", "i4"),
("Comment", "V1024"),
("ImageHistory", "V1024"),
("Scaling", "16f4"),
("ImageStatistics", "16c16"),
("ImageType", "i4"),
("ImageDisplaType", "i4"),
("PixelSizeX", "f4"), # distance between two px in x, [nm]
("PixelSizeY", "f4"), # distance between two px in y, [nm]
("ImageDistanceZ", "f4"),
("ImageDistanceE", "f4"),
("ImageMisc", "32f4"),
("TemType", "V160"),
("TemHighTension", "f4"),
("TemAberrations", "32f4"),
("TemEnergy", "32f4"),
("TemMode", "i4"),
("TemMagnification", "f4"),
("TemMagnificationCorrection", "f4"),
("PostMagnification", "f4"),
("TemStageType", "i4"),
("TemStagePosition", "5f4"), # x, y, z, a, b
("TemImageShift", "2f4"),
("TemBeamShift", "2f4"),
("TemBeamTilt", "2f4"),
("TilingParameters", "7f4"), # 0: tiling? 1:x 2:y 3: max x
# 4: max y 5: overlap x 6: overlap y
("TemIllumination", "3f4"), # 0: spotsize 1: intensity
("TemShutter", "i4"),
("TemMisc", "32f4"),
("CameraType", "V160"),
("PhysicalPixelSizeX", "f4"),
("PhysicalPixelSizeY", "f4"),
("OffsetX", "i4"),
("OffsetY", "i4"),
("BinningX", "i4"),
("BinningY", "i4"),
("ExposureTime", "f4"),
("Gain", "f4"),
("ReadoutRate", "f4"),
("FlatfieldDescription", "V160"),
("Sensitivity", "f4"),
("Dose", "f4"),
("CamMisc", "32f4"),
("FeiMicroscopeInformation", "V1024"),
("FeiSpecimenInformation", "V1024"),
("Magic", "u4"),
]
def MM_HEADER():
# Olympus FluoView MM_Header
MM_DIMENSION = [
("Name", "a16"),
("Size", "i4"),
("Origin", "f8"),
("Resolution", "f8"),
("Unit", "a64"),
]
return [
("HeaderFlag", "i2"),
("ImageType", "u1"),
("ImageName", "a257"),
("OffsetData", "u4"),
("PaletteSize", "i4"),
("OffsetPalette0", "u4"),
("OffsetPalette1", "u4"),
("CommentSize", "i4"),
("OffsetComment", "u4"),
("Dimensions", MM_DIMENSION, 10),
("OffsetPosition", "u4"),
("MapType", "i2"),
("MapMin", "f8"),
("MapMax", "f8"),
("MinValue", "f8"),
("MaxValue", "f8"),
("OffsetMap", "u4"),
("Gamma", "f8"),
("Offset", "f8"),
("GrayChannel", MM_DIMENSION),
("OffsetThumbnail", "u4"),
("VoiceField", "i4"),
("OffsetVoiceField", "u4"),
]
def MM_DIMENSIONS():
# Map FluoView MM_Header.Dimensions to axes characters
return {
"X": "X",
"Y": "Y",
"Z": "Z",
"T": "T",
"CH": "C",
"WAVELENGTH": "C",
"TIME": "T",
"XY": "R",
"EVENT": "V",
"EXPOSURE": "L",
}
def UIC_TAGS():
# Map Universal Imaging Corporation MetaMorph internal tag ids to
# name and type
from fractions import Fraction # delayed import
return [
("AutoScale", int),
("MinScale", int),
("MaxScale", int),
("SpatialCalibration", int),
("XCalibration", Fraction),
("YCalibration", Fraction),
("CalibrationUnits", str),
("Name", str),
("ThreshState", int),
("ThreshStateRed", int),
("tagid_10", None), # undefined
("ThreshStateGreen", int),
("ThreshStateBlue", int),
("ThreshStateLo", int),
("ThreshStateHi", int),
("Zoom", int),
("CreateTime", julian_datetime),
("LastSavedTime", julian_datetime),
("currentBuffer", int),
("grayFit", None),
("grayPointCount", None),
("grayX", Fraction),
("grayY", Fraction),
("grayMin", Fraction),
("grayMax", Fraction),
("grayUnitName", str),
("StandardLUT", int),
("wavelength", int),
("StagePosition", "(%i,2,2)u4"), # N xy positions as fract
("CameraChipOffset", "(%i,2,2)u4"), # N xy offsets as fract
("OverlayMask", None),
("OverlayCompress", None),
("Overlay", None),
("SpecialOverlayMask", None),
("SpecialOverlayCompress", None),
("SpecialOverlay", None),
("ImageProperty", read_uic_image_property),
("StageLabel", "%ip"), # N str
("AutoScaleLoInfo", Fraction),
("AutoScaleHiInfo", Fraction),
("AbsoluteZ", "(%i,2)u4"), # N fractions
("AbsoluteZValid", "(%i,)u4"), # N long
("Gamma", "I"), # 'I' uses offset
("GammaRed", "I"),
("GammaGreen", "I"),
("GammaBlue", "I"),
("CameraBin", "2I"),
("NewLUT", int),
("ImagePropertyEx", None),
("PlaneProperty", int),
("UserLutTable", "(256,3)u1"),
("RedAutoScaleInfo", int),
("RedAutoScaleLoInfo", Fraction),
("RedAutoScaleHiInfo", Fraction),
("RedMinScaleInfo", int),
("RedMaxScaleInfo", int),
("GreenAutoScaleInfo", int),
("GreenAutoScaleLoInfo", Fraction),
("GreenAutoScaleHiInfo", Fraction),
("GreenMinScaleInfo", int),
("GreenMaxScaleInfo", int),
("BlueAutoScaleInfo", int),
("BlueAutoScaleLoInfo", Fraction),
("BlueAutoScaleHiInfo", Fraction),
("BlueMinScaleInfo", int),
("BlueMaxScaleInfo", int),
# ('OverlayPlaneColor', read_uic_overlay_plane_color),
]
def PILATUS_HEADER():
# PILATUS CBF Header Specification, Version 1.4
# Map key to [value_indices], type
return {
"Detector": ([slice(1, None)], str),
"Pixel_size": ([1, 4], float),
"Silicon": ([3], float),
"Exposure_time": ([1], float),
"Exposure_period": ([1], float),
"Tau": ([1], float),
"Count_cutoff": ([1], int),
"Threshold_setting": ([1], float),
"Gain_setting": ([1, 2], str),
"N_excluded_pixels": ([1], int),
"Excluded_pixels": ([1], str),
"Flat_field": ([1], str),
"Trim_file": ([1], str),
"Image_path": ([1], str),
# optional
"Wavelength": ([1], float),
"Energy_range": ([1, 2], float),
"Detector_distance": ([1], float),
"Detector_Voffset": ([1], float),
"Beam_xy": ([1, 2], float),
"Flux": ([1], str),
"Filter_transmission": ([1], float),
"Start_angle": ([1], float),
"Angle_increment": ([1], float),
"Detector_2theta": ([1], float),
"Polarization": ([1], float),
"Alpha": ([1], float),
"Kappa": ([1], float),
"Phi": ([1], float),
"Phi_increment": ([1], float),
"Chi": ([1], float),
"Chi_increment": ([1], float),
"Oscillation_axis": ([slice(1, None)], str),
"N_oscillations": ([1], int),
"Start_position": ([1], float),
"Position_increment": ([1], float),
"Shutter_time": ([1], float),
"Omega": ([1], float),
"Omega_increment": ([1], float),
}
def REVERSE_BITORDER_BYTES():
# Bytes with reversed bitorder
return (
b"\x00\x80@\xc0 \xa0`\xe0\x10\x90P\xd00\xb0p\xf0\x08\x88H\xc8("
b"\xa8h\xe8\x18\x98X\xd88\xb8x\xf8\x04\x84D\xc4$\xa4d\xe4\x14"
b"\x94T\xd44\xb4t\xf4\x0c\x8cL\xcc,\xacl\xec\x1c\x9c\\\xdc<\xbc|"
b'\xfc\x02\x82B\xc2"\xa2b\xe2\x12\x92R\xd22\xb2r\xf2\n\x8aJ\xca*'
b"\xaaj\xea\x1a\x9aZ\xda:\xbaz\xfa\x06\x86F\xc6&\xa6f\xe6\x16"
b"\x96V\xd66\xb6v\xf6\x0e\x8eN\xce.\xaen\xee\x1e\x9e^\xde>\xbe~"
b"\xfe\x01\x81A\xc1!\xa1a\xe1\x11\x91Q\xd11\xb1q\xf1\t\x89I\xc9)"
b"\xa9i\xe9\x19\x99Y\xd99\xb9y\xf9\x05\x85E\xc5%\xa5e\xe5\x15"
b"\x95U\xd55\xb5u\xf5\r\x8dM\xcd-\xadm\xed\x1d\x9d]\xdd=\xbd}"
b"\xfd\x03\x83C\xc3#\xa3c\xe3\x13\x93S\xd33\xb3s\xf3\x0b\x8bK"
b"\xcb+\xabk\xeb\x1b\x9b[\xdb;\xbb{\xfb\x07\x87G\xc7'\xa7g\xe7"
b"\x17\x97W\xd77\xb7w\xf7\x0f\x8fO\xcf/\xafo\xef\x1f\x9f_"
b"\xdf?\xbf\x7f\xff"
)
def REVERSE_BITORDER_ARRAY():
# Numpy array of bytes with reversed bitorder
return numpy.frombuffer(TIFF.REVERSE_BITORDER_BYTES, dtype="uint8")
def ALLOCATIONGRANULARITY():
# alignment for writing contiguous data to TIFF
import mmap # delayed import
return mmap.ALLOCATIONGRANULARITY
def read_tags(fh, byteorder, offsetsize, tagnames, customtags=None, maxifds=None):
"""Read tags from chain of IFDs and return as list of dicts.
The file handle position must be at a valid IFD header.
"""
if offsetsize == 4:
offsetformat = byteorder + "I"
tagnosize = 2
tagnoformat = byteorder + "H"
tagsize = 12
tagformat1 = byteorder + "HH"
tagformat2 = byteorder + "I4s"
elif offsetsize == 8:
offsetformat = byteorder + "Q"
tagnosize = 8
tagnoformat = byteorder + "Q"
tagsize = 20
tagformat1 = byteorder + "HH"
tagformat2 = byteorder + "Q8s"
else:
raise ValueError("invalid offset size")
if customtags is None:
customtags = {}
if maxifds is None:
maxifds = 2**32
result = []
unpack = struct.unpack
offset = fh.tell()
while len(result) < maxifds:
# loop over IFDs
try:
tagno = unpack(tagnoformat, fh.read(tagnosize))[0]
if tagno > 4096:
raise ValueError("suspicious number of tags")
except Exception:
warnings.warn("corrupted tag list at offset %i" % offset)
break
tags = {}
data = fh.read(tagsize * tagno)
pos = fh.tell()
index = 0
for _ in range(tagno):
code, type_ = unpack(tagformat1, data[index : index + 4])
count, value = unpack(tagformat2, data[index + 4 : index + tagsize])
index += tagsize
name = tagnames.get(code, str(code))
try:
dtype = TIFF.DATA_FORMATS[type_]
except KeyError:
raise TiffTag.Error("unknown tag data type %i" % type_)
fmt = "%s%i%s" % (byteorder, count * int(dtype[0]), dtype[1])
size = struct.calcsize(fmt)
if size > offsetsize or code in customtags:
offset = unpack(offsetformat, value)[0]
if offset < 8 or offset > fh.size - size:
raise TiffTag.Error("invalid tag value offset %i" % offset)
fh.seek(offset)
if code in customtags:
readfunc = customtags[code][1]
value = readfunc(fh, byteorder, dtype, count, offsetsize)
elif type_ == 7 or (count > 1 and dtype[-1] == "B"):
value = read_bytes(fh, byteorder, dtype, count, offsetsize)
elif code in tagnames or dtype[-1] == "s":
value = unpack(fmt, fh.read(size))
else:
value = read_numpy(fh, byteorder, dtype, count, offsetsize)
elif dtype[-1] == "B" or type_ == 7:
value = value[:size]
else:
value = unpack(fmt, value[:size])
if code not in customtags and code not in TIFF.TAG_TUPLE:
if len(value) == 1:
value = value[0]
if type_ != 7 and dtype[-1] == "s" and isinstance(value, bytes):
# TIFF ASCII fields can contain multiple strings,
# each terminated with a NUL
try:
value = bytes2str(stripascii(value).strip())
except UnicodeDecodeError:
warnings.warn("tag %i: coercing invalid ASCII to bytes" % code)
tags[name] = value
result.append(tags)
# read offset to next page
fh.seek(pos)
offset = unpack(offsetformat, fh.read(offsetsize))[0]
if offset == 0:
break
if offset >= fh.size:
warnings.warn("invalid page offset %i" % offset)
break
fh.seek(offset)
if result and maxifds == 1:
result = result[0]
return result
def read_exif_ifd(fh, byteorder, dtype, count, offsetsize):
"""Read EXIF tags from file and return as dict."""
exif = read_tags(fh, byteorder, offsetsize, TIFF.EXIF_TAGS, maxifds=1)
for name in ("ExifVersion", "FlashpixVersion"):
try:
exif[name] = bytes2str(exif[name])
except Exception:
pass
if "UserComment" in exif:
idcode = exif["UserComment"][:8]
try:
if idcode == b"ASCII\x00\x00\x00":
exif["UserComment"] = bytes2str(exif["UserComment"][8:])
elif idcode == b"UNICODE\x00":
exif["UserComment"] = exif["UserComment"][8:].decode("utf-16")
except Exception:
pass
return exif
def read_gps_ifd(fh, byteorder, dtype, count, offsetsize):
"""Read GPS tags from file and return as dict."""
return read_tags(fh, byteorder, offsetsize, TIFF.GPS_TAGS, maxifds=1)
def read_interoperability_ifd(fh, byteorder, dtype, count, offsetsize):
"""Read Interoperability tags from file and return as dict."""
tag_names = {1: "InteroperabilityIndex"}
return read_tags(fh, byteorder, offsetsize, tag_names, maxifds=1)
def read_bytes(fh, byteorder, dtype, count, offsetsize):
"""Read tag data from file and return as byte string."""
dtype = "B" if dtype[-1] == "s" else byteorder + dtype[-1]
count *= numpy.dtype(dtype).itemsize
data = fh.read(count)
if len(data) != count:
warnings.warn("failed to read all bytes: %i, %i" % (len(data), count))
return data
def read_utf8(fh, byteorder, dtype, count, offsetsize):
"""Read tag data from file and return as unicode string."""
return fh.read(count).decode("utf-8")
def read_numpy(fh, byteorder, dtype, count, offsetsize):
"""Read tag data from file and return as numpy array."""
dtype = "b" if dtype[-1] == "s" else byteorder + dtype[-1]
return fh.read_array(dtype, count)
def read_colormap(fh, byteorder, dtype, count, offsetsize):
"""Read ColorMap data from file and return as numpy array."""
cmap = fh.read_array(byteorder + dtype[-1], count)
cmap.shape = (3, -1)
return cmap
def read_json(fh, byteorder, dtype, count, offsetsize):
"""Read JSON tag data from file and return as object."""
data = fh.read(count)
try:
return json.loads(unicode(stripnull(data), "utf-8"))
except ValueError:
warnings.warn("invalid JSON '%s'" % data)
def read_mm_header(fh, byteorder, dtype, count, offsetsize):
"""Read FluoView mm_header tag from file and return as dict."""
mmh = fh.read_record(TIFF.MM_HEADER, byteorder=byteorder)
mmh = recarray2dict(mmh)
mmh["Dimensions"] = [
(bytes2str(d[0]).strip(), d[1], d[2], d[3], bytes2str(d[4]).strip())
for d in mmh["Dimensions"]
]
d = mmh["GrayChannel"]
mmh["GrayChannel"] = (
bytes2str(d[0]).strip(),
d[1],
d[2],
d[3],
bytes2str(d[4]).strip(),
)
return mmh
def read_mm_stamp(fh, byteorder, dtype, count, offsetsize):
"""Read FluoView mm_stamp tag from file and return as numpy.ndarray."""
return fh.read_array(byteorder + "f8", 8)
def read_uic1tag(fh, byteorder, dtype, count, offsetsize, planecount=None):
"""Read MetaMorph STK UIC1Tag from file and return as dict.
Return empty dictionary if planecount is unknown.
"""
assert dtype in ("2I", "1I") and byteorder == "<"
result = {}
if dtype == "2I":
# pre MetaMorph 2.5 (not tested)
values = fh.read_array(" structure_size:
break
lsminfo.append((name, dtype))
else:
lsminfo = TIFF.CZ_LSMINFO
lsminfo = fh.read_record(lsminfo, byteorder=byteorder)
lsminfo = recarray2dict(lsminfo)
# read LSM info subrecords at offsets
for name, reader in TIFF.CZ_LSMINFO_READERS.items():
if reader is None:
continue
offset = lsminfo.get("Offset" + name, 0)
if offset < 8:
continue
fh.seek(offset)
try:
lsminfo[name] = reader(fh)
except ValueError:
pass
return lsminfo
def read_lsm_floatpairs(fh):
"""Read LSM sequence of float pairs from file and return as list."""
size = struct.unpack(" 0:
esize, etime, etype = struct.unpack(" 4:
size = struct.unpack(" 1 else {}
return frame_data, roi_data
def read_micromanager_metadata(fh):
"""Read MicroManager non-TIFF settings from open file and return as dict.
The settings can be used to read image data without parsing the TIFF file.
Raise ValueError if the file does not contain valid MicroManager metadata.
"""
fh.seek(0)
try:
byteorder = {b"II": "<", b"MM": ">"}[fh.read(2)]
except IndexError:
raise ValueError("not a MicroManager TIFF file")
result = {}
fh.seek(8)
(
index_header,
index_offset,
display_header,
display_offset,
comments_header,
comments_offset,
summary_header,
summary_length,
) = struct.unpack(byteorder + "IIIIIIII", fh.read(32))
if summary_header != 2355492:
raise ValueError("invalid MicroManager summary header")
result["Summary"] = read_json(fh, byteorder, None, summary_length, None)
if index_header != 54773648:
raise ValueError("invalid MicroManager index header")
fh.seek(index_offset)
header, count = struct.unpack(byteorder + "II", fh.read(8))
if header != 3453623:
raise ValueError("invalid MicroManager index header")
data = struct.unpack(byteorder + "IIIII" * count, fh.read(20 * count))
result["IndexMap"] = {
"Channel": data[::5],
"Slice": data[1::5],
"Frame": data[2::5],
"Position": data[3::5],
"Offset": data[4::5],
}
if display_header != 483765892:
raise ValueError("invalid MicroManager display header")
fh.seek(display_offset)
header, count = struct.unpack(byteorder + "II", fh.read(8))
if header != 347834724:
raise ValueError("invalid MicroManager display header")
result["DisplaySettings"] = read_json(fh, byteorder, None, count, None)
if comments_header != 99384722:
raise ValueError("invalid MicroManager comments header")
fh.seek(comments_offset)
header, count = struct.unpack(byteorder + "II", fh.read(8))
if header != 84720485:
raise ValueError("invalid MicroManager comments header")
result["Comments"] = read_json(fh, byteorder, None, count, None)
return result
def read_metaseries_catalog(fh):
"""Read MetaSeries non-TIFF hint catalog from file.
Raise ValueError if the file does not contain a valid hint catalog.
"""
# TODO: implement read_metaseries_catalog
raise NotImplementedError()
def imagej_metadata_tags(metadata, byteorder):
"""Return IJMetadata and IJMetadataByteCounts tags from metadata dict.
The tags can be passed to the TiffWriter.save function as extratags.
The metadata dict may contain the following keys and values:
Info : str
Human-readable information as string.
Labels : sequence of str
Human-readable labels for each channel.
Ranges : sequence of doubles
Lower and upper values for each channel.
LUTs : sequence of (3, 256) uint8 ndarrays
Color palettes for each channel.
Plot : bytes
Undocumented ImageJ internal format.
ROI: bytes
Undocumented ImageJ internal region of interest format.
Overlays : bytes
Undocumented ImageJ internal format.
"""
header = [{">": b"IJIJ", "<": b"JIJI"}[byteorder]]
bytecounts = [0]
body = []
def _string(data, byteorder):
return data.encode("utf-16" + {">": "be", "<": "le"}[byteorder])
def _doubles(data, byteorder):
return struct.pack(byteorder + ("d" * len(data)), *data)
def _ndarray(data, byteorder):
return data.tobytes()
def _bytes(data, byteorder):
return data
metadata_types = (
("Info", b"info", 1, _string),
("Labels", b"labl", None, _string),
("Ranges", b"rang", 1, _doubles),
("LUTs", b"luts", None, _ndarray),
("Plot", b"plot", 1, _bytes),
("ROI", b"roi ", 1, _bytes),
("Overlays", b"over", None, _bytes),
)
for key, mtype, count, func in metadata_types:
if key.lower() in metadata:
key = key.lower()
elif key not in metadata:
continue
if byteorder == "<":
mtype = mtype[::-1]
values = metadata[key]
if count is None:
count = len(values)
else:
values = [values]
header.append(mtype + struct.pack(byteorder + "I", count))
for value in values:
data = func(value, byteorder)
body.append(data)
bytecounts.append(len(data))
if not body:
return ()
body = b"".join(body)
header = b"".join(header)
data = header + body
bytecounts[0] = len(header)
bytecounts = struct.pack(byteorder + ("I" * len(bytecounts)), *bytecounts)
return (
(50839, "B", len(data), data, True),
(50838, "I", len(bytecounts) // 4, bytecounts, True),
)
def imagej_metadata(data, bytecounts, byteorder):
"""Return IJMetadata tag value as dict.
The 'Info' string can have multiple formats, e.g. OIF or ScanImage,
that might be parsed into dicts using the matlabstr2py or
oiffile.SettingsFile functions.
"""
def _string(data, byteorder):
return data.decode("utf-16" + {">": "be", "<": "le"}[byteorder])
def _doubles(data, byteorder):
return struct.unpack(byteorder + ("d" * (len(data) // 8)), data)
def _lut(data, byteorder):
return numpy.frombuffer(data, "uint8").reshape(-1, 256)
def _bytes(data, byteorder):
return data
metadata_types = { # big-endian
b"info": ("Info", _string),
b"labl": ("Labels", _string),
b"rang": ("Ranges", _doubles),
b"luts": ("LUTs", _lut),
b"plot": ("Plots", _bytes),
b"roi ": ("ROI", _bytes),
b"over": ("Overlays", _bytes),
}
metadata_types.update( # little-endian
dict((k[::-1], v) for k, v in metadata_types.items())
)
if not bytecounts:
raise ValueError("no ImageJ metadata")
if data[:4] not in (b"IJIJ", b"JIJI"):
raise ValueError("invalid ImageJ metadata")
header_size = bytecounts[0]
if header_size < 12 or header_size > 804:
raise ValueError("invalid ImageJ metadata header size")
ntypes = (header_size - 4) // 8
header = struct.unpack(byteorder + "4sI" * ntypes, data[4 : 4 + ntypes * 8])
pos = 4 + ntypes * 8
counter = 0
result = {}
for mtype, count in zip(header[::2], header[1::2]):
values = []
name, func = metadata_types.get(mtype, (bytes2str(mtype), read_bytes))
for _ in range(count):
counter += 1
pos1 = pos + bytecounts[counter]
values.append(func(data[pos:pos1], byteorder))
pos = pos1
result[name.strip()] = values[0] if count == 1 else values
return result
def imagej_description_metadata(description):
"""Return metatata from ImageJ image description as dict.
Raise ValueError if not a valid ImageJ description.
>>> description = 'ImageJ=1.11a\\nimages=510\\nhyperstack=true\\n'
>>> imagej_description_metadata(description) # doctest: +SKIP
{'ImageJ': '1.11a', 'images': 510, 'hyperstack': True}
"""
def _bool(val):
return {"true": True, "false": False}[val.lower()]
result = {}
for line in description.splitlines():
try:
key, val = line.split("=")
except Exception:
continue
key = key.strip()
val = val.strip()
for dtype in (int, float, _bool):
try:
val = dtype(val)
break
except Exception:
pass
result[key] = val
if "ImageJ" not in result:
raise ValueError("not a ImageJ image description")
return result
def imagej_description(
shape,
rgb=None,
colormaped=False,
version="1.11a",
hyperstack=None,
mode=None,
loop=None,
**kwargs
):
"""Return ImageJ image description from data shape.
ImageJ can handle up to 6 dimensions in order TZCYXS.
>>> imagej_description((51, 5, 2, 196, 171)) # doctest: +SKIP
ImageJ=1.11a
images=510
channels=2
slices=5
frames=51
hyperstack=true
mode=grayscale
loop=false
"""
if colormaped:
raise NotImplementedError("ImageJ colormapping not supported")
shape = imagej_shape(shape, rgb=rgb)
rgb = shape[-1] in (3, 4)
result = ["ImageJ=%s" % version]
append = []
result.append("images=%i" % product(shape[:-3]))
if hyperstack is None:
hyperstack = True
append.append("hyperstack=true")
else:
append.append("hyperstack=%s" % bool(hyperstack))
if shape[2] > 1:
result.append("channels=%i" % shape[2])
if mode is None and not rgb:
mode = "grayscale"
if hyperstack and mode:
append.append("mode=%s" % mode)
if shape[1] > 1:
result.append("slices=%i" % shape[1])
if shape[0] > 1:
result.append("frames=%i" % shape[0])
if loop is None:
append.append("loop=false")
if loop is not None:
append.append("loop=%s" % bool(loop))
for key, value in kwargs.items():
append.append("%s=%s" % (key.lower(), value))
return "\n".join(result + append + [""])
def imagej_shape(shape, rgb=None):
"""Return shape normalized to 6D ImageJ hyperstack TZCYXS.
Raise ValueError if not a valid ImageJ hyperstack shape.
>>> imagej_shape((2, 3, 4, 5, 3), False)
(2, 3, 4, 5, 3, 1)
"""
shape = tuple(int(i) for i in shape)
ndim = len(shape)
if 1 > ndim > 6:
raise ValueError("invalid ImageJ hyperstack: not 2 to 6 dimensional")
if rgb is None:
rgb = shape[-1] in (3, 4) and ndim > 2
if rgb and shape[-1] not in (3, 4):
raise ValueError("invalid ImageJ hyperstack: not a RGB image")
if not rgb and ndim == 6 and shape[-1] != 1:
raise ValueError("invalid ImageJ hyperstack: not a non-RGB image")
if rgb or shape[-1] == 1:
return (1,) * (6 - ndim) + shape
return (1,) * (5 - ndim) + shape + (1,)
def json_description(shape, **metadata):
"""Return JSON image description from data shape and other meta data.
Return UTF-8 encoded JSON.
>>> json_description((256, 256, 3), axes='YXS') # doctest: +SKIP
b'{"shape": [256, 256, 3], "axes": "YXS"}'
"""
metadata.update(shape=shape)
return json.dumps(metadata) # .encode('utf-8')
def json_description_metadata(description):
"""Return metatata from JSON formatted image description as dict.
Raise ValuError if description is of unknown format.
>>> description = '{"shape": [256, 256, 3], "axes": "YXS"}'
>>> json_description_metadata(description) # doctest: +SKIP
{'shape': [256, 256, 3], 'axes': 'YXS'}
>>> json_description_metadata('shape=(256, 256, 3)')
{'shape': (256, 256, 3)}
"""
if description[:6] == "shape=":
# old style 'shaped' description; not JSON
shape = tuple(int(i) for i in description[7:-1].split(","))
return dict(shape=shape)
if description[:1] == "{" and description[-1:] == "}":
# JSON description
return json.loads(description)
raise ValueError("invalid JSON image description", description)
def fluoview_description_metadata(description, ignoresections=None):
"""Return metatata from FluoView image description as dict.
The FluoView image description format is unspecified. Expect failures.
>>> descr = ('[Intensity Mapping]\\nMap Ch0: Range=00000 to 02047\\n'
... '[Intensity Mapping End]')
>>> fluoview_description_metadata(descr)
{'Intensity Mapping': {'Map Ch0: Range': '00000 to 02047'}}
"""
if not description.startswith("["):
raise ValueError("invalid FluoView image description")
if ignoresections is None:
ignoresections = {"Region Info (Fields)", "Protocol Description"}
result = {}
sections = [result]
comment = False
for line in description.splitlines():
if not comment:
line = line.strip()
if not line:
continue
if line[0] == "[":
if line[-5:] == " End]":
# close section
del sections[-1]
section = sections[-1]
name = line[1:-5]
if comment:
section[name] = "\n".join(section[name])
if name[:4] == "LUT ":
a = numpy.array(section[name], dtype="uint8")
a.shape = -1, 3
section[name] = a
continue
# new section
comment = False
name = line[1:-1]
if name[:4] == "LUT ":
section = []
elif name in ignoresections:
section = []
comment = True
else:
section = {}
sections.append(section)
result[name] = section
continue
# add entry
if comment:
section.append(line)
continue
line = line.split("=", 1)
if len(line) == 1:
section[line[0].strip()] = None
continue
key, value = line
if key[:4] == "RGB ":
section.extend(int(rgb) for rgb in value.split())
else:
section[key.strip()] = astype(value.strip())
return result
def pilatus_description_metadata(description):
"""Return metatata from Pilatus image description as dict.
Return metadata from Pilatus pixel array detectors by Dectris, created
by camserver or TVX software.
>>> pilatus_description_metadata('# Pixel_size 172e-6 m x 172e-6 m')
{'Pixel_size': (0.000172, 0.000172)}
"""
result = {}
if not description.startswith("# "):
return result
for c in "#:=,()":
description = description.replace(c, " ")
for line in description.split("\n"):
if line[:2] != " ":
continue
line = line.split()
name = line[0]
if line[0] not in TIFF.PILATUS_HEADER:
try:
result["DateTime"] = datetime.datetime.strptime(
" ".join(line), "%Y-%m-%dT%H %M %S.%f"
)
except Exception:
result[name] = " ".join(line[1:])
continue
indices, dtype = TIFF.PILATUS_HEADER[line[0]]
if isinstance(indices[0], slice):
# assumes one slice
values = line[indices[0]]
else:
values = [line[i] for i in indices]
if dtype is float and values[0] == "not":
values = ["NaN"]
values = tuple(dtype(v) for v in values)
if dtype == str:
values = " ".join(values)
elif len(values) == 1:
values = values[0]
result[name] = values
return result
def svs_description_metadata(description):
"""Return metatata from Aperio image description as dict.
The Aperio image description format is unspecified. Expect failures.
>>> svs_description_metadata('Aperio Image Library v1.0')
{'Aperio Image Library': 'v1.0'}
"""
if not description.startswith("Aperio Image Library "):
raise ValueError("invalid Aperio image description")
result = {}
lines = description.split("\n")
key, value = lines[0].strip().rsplit(None, 1) # 'Aperio Image Library'
result[key.strip()] = value.strip()
if len(lines) == 1:
return result
items = lines[1].split("|")
result[""] = items[0].strip() # TODO: parse this?
for item in items[1:]:
key, value = item.split(" = ")
result[key.strip()] = astype(value.strip())
return result
def stk_description_metadata(description):
"""Return metadata from MetaMorph image description as list of dict.
The MetaMorph image description format is unspecified. Expect failures.
"""
description = description.strip()
if not description:
return []
try:
description = bytes2str(description)
except UnicodeDecodeError:
warnings.warn("failed to parse MetaMorph image description")
return []
result = []
for plane in description.split("\x00"):
d = {}
for line in plane.split("\r\n"):
line = line.split(":", 1)
if len(line) > 1:
name, value = line
d[name.strip()] = astype(value.strip())
else:
value = line[0].strip()
if value:
if "" in d:
d[""].append(value)
else:
d[""] = [value]
result.append(d)
return result
def metaseries_description_metadata(description):
"""Return metatata from MetaSeries image description as dict."""
if not description.startswith(""):
raise ValueError("invalid MetaSeries image description")
from xml.etree import cElementTree as etree # delayed import
root = etree.fromstring(description)
types = {"float": float, "int": int, "bool": lambda x: asbool(x, "on", "off")}
def parse(root, result):
# recursive
for child in root:
attrib = child.attrib
if not attrib:
result[child.tag] = parse(child, {})
continue
if "id" in attrib:
i = attrib["id"]
t = attrib["type"]
v = attrib["value"]
if t in types:
result[i] = types[t](v)
else:
result[i] = v
return result
adict = parse(root, {})
if "Description" in adict:
adict["Description"] = adict["Description"].replace("
", "\n")
return adict
def scanimage_description_metadata(description):
"""Return metatata from ScanImage image description as dict."""
return matlabstr2py(description)
def scanimage_artist_metadata(artist):
"""Return metatata from ScanImage artist tag as dict."""
try:
return json.loads(artist)
except ValueError:
warnings.warn("invalid JSON '%s'" % artist)
def _replace_by(module_function, package=__package__, warn=None, prefix="_"):
"""Try replace decorated function by module.function."""
return lambda f: f # imageio: just use what's in here
def _warn(e, warn):
if warn is None:
warn = "\n Functionality might be degraded or be slow.\n"
elif warn is True:
warn = ""
elif not warn:
return
warnings.warn("%s%s" % (e, warn))
try:
from importlib import import_module
except ImportError as e:
_warn(e, warn)
return identityfunc
def decorate(func, module_function=module_function, warn=warn):
module, function = module_function.split(".")
try:
if package:
module = import_module("." + module, package=package)
else:
module = import_module(module)
except Exception as e:
_warn(e, warn)
return func
try:
func, oldfunc = getattr(module, function), func
except Exception as e:
_warn(e, warn)
return func
globals()[prefix + func.__name__] = oldfunc
return func
return decorate
def decode_floats(data):
"""Decode floating point horizontal differencing.
The TIFF predictor type 3 reorders the bytes of the image values and
applies horizontal byte differencing to improve compression of floating
point images. The ordering of interleaved color channels is preserved.
Parameters
----------
data : numpy.ndarray
The image to be decoded. The dtype must be a floating point.
The shape must include the number of contiguous samples per pixel
even if 1.
"""
shape = data.shape
dtype = data.dtype
if len(shape) < 3:
raise ValueError("invalid data shape")
if dtype.char not in "dfe":
raise ValueError("not a floating point image")
littleendian = data.dtype.byteorder == "<" or (
sys.byteorder == "little" and data.dtype.byteorder == "="
)
# undo horizontal byte differencing
data = data.view("uint8")
data.shape = shape[:-2] + (-1,) + shape[-1:]
numpy.cumsum(data, axis=-2, dtype="uint8", out=data)
# reorder bytes
if littleendian:
data.shape = shape[:-2] + (-1,) + shape[-2:]
data = numpy.swapaxes(data, -3, -2)
data = numpy.swapaxes(data, -2, -1)
data = data[..., ::-1]
# back to float
data = numpy.ascontiguousarray(data)
data = data.view(dtype)
data.shape = shape
return data
@_replace_by("_tifffile.decode_packbits")
def decode_packbits(encoded):
"""Decompress PackBits encoded byte string.
PackBits is a simple byte-oriented run-length compression scheme.
"""
func = ord if sys.version[0] == "2" else identityfunc
result = []
result_extend = result.extend
i = 0
try:
while True:
n = func(encoded[i]) + 1
i += 1
if n < 129:
result_extend(encoded[i : i + n])
i += n
elif n > 129:
result_extend(encoded[i : i + 1] * (258 - n))
i += 1
except IndexError:
pass
return b"".join(result) if sys.version[0] == "2" else bytes(result)
@_replace_by("_tifffile.decode_lzw")
def decode_lzw(encoded):
"""Decompress LZW (Lempel-Ziv-Welch) encoded TIFF strip (byte string).
The strip must begin with a CLEAR code and end with an EOI code.
This implementation of the LZW decoding algorithm is described in (1) and
is not compatible with old style LZW compressed files like quad-lzw.tif.
"""
len_encoded = len(encoded)
bitcount_max = len_encoded * 8
unpack = struct.unpack
if sys.version[0] == "2":
newtable = [chr(i) for i in range(256)]
else:
newtable = [bytes([i]) for i in range(256)]
newtable.extend((0, 0))
def next_code():
"""Return integer of 'bitw' bits at 'bitcount' position in encoded."""
start = bitcount // 8
s = encoded[start : start + 4]
try:
code = unpack(">I", s)[0]
except Exception:
code = unpack(">I", s + b"\x00" * (4 - len(s)))[0]
code <<= bitcount % 8
code &= mask
return code >> shr
switchbitch = { # code: bit-width, shr-bits, bit-mask
255: (9, 23, int(9 * "1" + "0" * 23, 2)),
511: (10, 22, int(10 * "1" + "0" * 22, 2)),
1023: (11, 21, int(11 * "1" + "0" * 21, 2)),
2047: (12, 20, int(12 * "1" + "0" * 20, 2)),
}
bitw, shr, mask = switchbitch[255]
bitcount = 0
if len_encoded < 4:
raise ValueError("strip must be at least 4 characters long")
if next_code() != 256:
raise ValueError("strip must begin with CLEAR code")
code = 0
oldcode = 0
result = []
result_append = result.append
while True:
code = next_code() # ~5% faster when inlining this function
bitcount += bitw
if code == 257 or bitcount >= bitcount_max: # EOI
break
if code == 256: # CLEAR
table = newtable[:]
table_append = table.append
lentable = 258
bitw, shr, mask = switchbitch[255]
code = next_code()
bitcount += bitw
if code == 257: # EOI
break
result_append(table[code])
else:
if code < lentable:
decoded = table[code]
newcode = table[oldcode] + decoded[:1]
else:
newcode = table[oldcode]
newcode += newcode[:1]
decoded = newcode
result_append(decoded)
table_append(newcode)
lentable += 1
oldcode = code
if lentable in switchbitch:
bitw, shr, mask = switchbitch[lentable]
if code != 257:
warnings.warn("unexpected end of LZW stream (code %i)" % code)
return b"".join(result)
@_replace_by("_tifffile.unpack_ints")
def unpack_ints(data, dtype, itemsize, runlen=0):
"""Decompress byte string to array of integers of any bit size <= 32.
This Python implementation is slow and only handles itemsizes 1, 2, 4, 8,
16, 32, and 64.
Parameters
----------
data : byte str
Data to decompress.
dtype : numpy.dtype or str
A numpy boolean or integer type.
itemsize : int
Number of bits per integer.
runlen : int
Number of consecutive integers, after which to start at next byte.
Examples
--------
>>> unpack_ints(b'a', 'B', 1)
array([0, 1, 1, 0, 0, 0, 0, 1], dtype=uint8)
>>> unpack_ints(b'ab', 'B', 2)
array([1, 2, 0, 1, 1, 2, 0, 2], dtype=uint8)
"""
if itemsize == 1: # bitarray
data = numpy.frombuffer(data, "|B")
data = numpy.unpackbits(data)
if runlen % 8:
data = data.reshape(-1, runlen + (8 - runlen % 8))
data = data[:, :runlen].reshape(-1)
return data.astype(dtype)
dtype = numpy.dtype(dtype)
if itemsize in (8, 16, 32, 64):
return numpy.frombuffer(data, dtype)
if itemsize not in (1, 2, 4, 8, 16, 32):
raise ValueError("itemsize not supported: %i" % itemsize)
if dtype.kind not in "biu":
raise ValueError("invalid dtype")
itembytes = next(i for i in (1, 2, 4, 8) if 8 * i >= itemsize)
if itembytes != dtype.itemsize:
raise ValueError("dtype.itemsize too small")
if runlen == 0:
runlen = (8 * len(data)) // itemsize
skipbits = runlen * itemsize % 8
if skipbits:
skipbits = 8 - skipbits
shrbits = itembytes * 8 - itemsize
bitmask = int(itemsize * "1" + "0" * shrbits, 2)
dtypestr = ">" + dtype.char # dtype always big-endian?
unpack = struct.unpack
size = runlen * (len(data) * 8 // (runlen * itemsize + skipbits))
result = numpy.empty((size,), dtype)
bitcount = 0
for i in range(size):
start = bitcount // 8
s = data[start : start + itembytes]
try:
code = unpack(dtypestr, s)[0]
except Exception:
code = unpack(dtypestr, s + b"\x00" * (itembytes - len(s)))[0]
code <<= bitcount % 8
code &= bitmask
result[i] = code >> shrbits
bitcount += itemsize
if (i + 1) % runlen == 0:
bitcount += skipbits
return result
def unpack_rgb(data, dtype=">> data = struct.pack('BBBB', 0x21, 0x08, 0xff, 0xff)
>>> print(unpack_rgb(data, '>> print(unpack_rgb(data, '>> print(unpack_rgb(data, '= bits)
data = numpy.frombuffer(data, dtype.byteorder + dt)
result = numpy.empty((data.size, len(bitspersample)), dtype.char)
for i, bps in enumerate(bitspersample):
t = data >> int(numpy.sum(bitspersample[i + 1 :]))
t &= int("0b" + "1" * bps, 2)
if rescale:
o = ((dtype.itemsize * 8) // bps + 1) * bps
if o > data.dtype.itemsize * 8:
t = t.astype("I")
t *= (2**o - 1) // (2**bps - 1)
t //= 2 ** (o - (dtype.itemsize * 8))
result[:, i] = t
return result.reshape(-1)
@_replace_by("_tifffile.reverse_bitorder")
def reverse_bitorder(data):
"""Reverse bits in each byte of byte string or numpy array.
Decode data where pixels with lower column values are stored in the
lower-order bits of the bytes (FillOrder is LSB2MSB).
Parameters
----------
data : byte string or ndarray
The data to be bit reversed. If byte string, a new bit-reversed byte
string is returned. Numpy arrays are bit-reversed in-place.
Examples
--------
>>> reverse_bitorder(b'\\x01\\x64')
b'\\x80&'
>>> data = numpy.array([1, 666], dtype='uint16')
>>> reverse_bitorder(data)
>>> data
array([ 128, 16473], dtype=uint16)
"""
try:
view = data.view("uint8")
numpy.take(TIFF.REVERSE_BITORDER_ARRAY, view, out=view)
except AttributeError:
return data.translate(TIFF.REVERSE_BITORDER_BYTES)
except ValueError:
raise NotImplementedError("slices of arrays not supported")
def apply_colormap(image, colormap, contig=True):
"""Return palette-colored image.
The image values are used to index the colormap on axis 1. The returned
image is of shape image.shape+colormap.shape[0] and dtype colormap.dtype.
Parameters
----------
image : numpy.ndarray
Indexes into the colormap.
colormap : numpy.ndarray
RGB lookup table aka palette of shape (3, 2**bits_per_sample).
contig : bool
If True, return a contiguous array.
Examples
--------
>>> image = numpy.arange(256, dtype='uint8')
>>> colormap = numpy.vstack([image, image, image]).astype('uint16') * 256
>>> apply_colormap(image, colormap)[-1]
array([65280, 65280, 65280], dtype=uint16)
"""
image = numpy.take(colormap, image, axis=1)
image = numpy.rollaxis(image, 0, image.ndim)
if contig:
image = numpy.ascontiguousarray(image)
return image
def reorient(image, orientation):
"""Return reoriented view of image array.
Parameters
----------
image : numpy.ndarray
Non-squeezed output of asarray() functions.
Axes -3 and -2 must be image length and width respectively.
orientation : int or str
One of TIFF.ORIENTATION names or values.
"""
ORIENTATION = TIFF.ORIENTATION
orientation = enumarg(ORIENTATION, orientation)
if orientation == ORIENTATION.TOPLEFT:
return image
elif orientation == ORIENTATION.TOPRIGHT:
return image[..., ::-1, :]
elif orientation == ORIENTATION.BOTLEFT:
return image[..., ::-1, :, :]
elif orientation == ORIENTATION.BOTRIGHT:
return image[..., ::-1, ::-1, :]
elif orientation == ORIENTATION.LEFTTOP:
return numpy.swapaxes(image, -3, -2)
elif orientation == ORIENTATION.RIGHTTOP:
return numpy.swapaxes(image, -3, -2)[..., ::-1, :]
elif orientation == ORIENTATION.RIGHTBOT:
return numpy.swapaxes(image, -3, -2)[..., ::-1, :, :]
elif orientation == ORIENTATION.LEFTBOT:
return numpy.swapaxes(image, -3, -2)[..., ::-1, ::-1, :]
def repeat_nd(a, repeats):
"""Return read-only view into input array with elements repeated.
Zoom nD image by integer factors using nearest neighbor interpolation
(box filter).
Parameters
----------
a : array_like
Input array.
repeats : sequence of int
The number of repetitions to apply along each dimension of input array.
Example
-------
>>> repeat_nd([[1, 2], [3, 4]], (2, 2))
array([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 3, 4, 4],
[3, 3, 4, 4]])
"""
a = numpy.asarray(a)
reshape = []
shape = []
strides = []
for i, j, k in zip(a.strides, a.shape, repeats):
shape.extend((j, k))
strides.extend((i, 0))
reshape.append(j * k)
return numpy.lib.stride_tricks.as_strided(
a, shape, strides, writeable=False
).reshape(reshape)
def reshape_nd(data_or_shape, ndim):
"""Return image array or shape with at least ndim dimensions.
Prepend 1s to image shape as necessary.
>>> reshape_nd(numpy.empty(0), 1).shape
(0,)
>>> reshape_nd(numpy.empty(1), 2).shape
(1, 1)
>>> reshape_nd(numpy.empty((2, 3)), 3).shape
(1, 2, 3)
>>> reshape_nd(numpy.empty((3, 4, 5)), 3).shape
(3, 4, 5)
>>> reshape_nd((2, 3), 3)
(1, 2, 3)
"""
is_shape = isinstance(data_or_shape, tuple)
shape = data_or_shape if is_shape else data_or_shape.shape
if len(shape) >= ndim:
return data_or_shape
shape = (1,) * (ndim - len(shape)) + shape
return shape if is_shape else data_or_shape.reshape(shape)
def squeeze_axes(shape, axes, skip="XY"):
"""Return shape and axes with single-dimensional entries removed.
Remove unused dimensions unless their axes are listed in 'skip'.
>>> squeeze_axes((5, 1, 2, 1, 1), 'TZYXC')
((5, 2, 1), 'TYX')
"""
if len(shape) != len(axes):
raise ValueError("dimensions of axes and shape do not match")
shape, axes = zip(*(i for i in zip(shape, axes) if i[0] > 1 or i[1] in skip))
return tuple(shape), "".join(axes)
def transpose_axes(image, axes, asaxes="CTZYX"):
"""Return image with its axes permuted to match specified axes.
A view is returned if possible.
>>> transpose_axes(numpy.zeros((2, 3, 4, 5)), 'TYXC', asaxes='CTZYX').shape
(5, 2, 1, 3, 4)
"""
for ax in axes:
if ax not in asaxes:
raise ValueError("unknown axis %s" % ax)
# add missing axes to image
shape = image.shape
for ax in reversed(asaxes):
if ax not in axes:
axes = ax + axes
shape = (1,) + shape
image = image.reshape(shape)
# transpose axes
image = image.transpose([axes.index(ax) for ax in asaxes])
return image
def reshape_axes(axes, shape, newshape, unknown="Q"):
"""Return axes matching new shape.
Unknown dimensions are labelled 'Q'.
>>> reshape_axes('YXS', (219, 301, 1), (219, 301))
'YX'
>>> reshape_axes('IYX', (12, 219, 301), (3, 4, 219, 1, 301, 1))
'QQYQXQ'
"""
shape = tuple(shape)
newshape = tuple(newshape)
if len(axes) != len(shape):
raise ValueError("axes do not match shape")
size = product(shape)
newsize = product(newshape)
if size != newsize:
raise ValueError("cannot reshape %s to %s" % (shape, newshape))
if not axes or not newshape:
return ""
lendiff = max(0, len(shape) - len(newshape))
if lendiff:
newshape = newshape + (1,) * lendiff
i = len(shape) - 1
prodns = 1
prods = 1
result = []
for ns in newshape[::-1]:
prodns *= ns
while i > 0 and shape[i] == 1 and ns != 1:
i -= 1
if ns == shape[i] and prodns == prods * shape[i]:
prods *= shape[i]
result.append(axes[i])
i -= 1
else:
result.append(unknown)
return "".join(reversed(result[lendiff:]))
def stack_pages(pages, out=None, maxworkers=1, *args, **kwargs):
"""Read data from sequence of TiffPage and stack them vertically.
Additional parameters are passed to the TiffPage.asarray function.
"""
npages = len(pages)
if npages == 0:
raise ValueError("no pages")
if npages == 1:
return pages[0].asarray(out=out, *args, **kwargs)
page0 = next(p for p in pages if p is not None)
page0.asarray(validate=None) # ThreadPoolExecutor swallows exceptions
shape = (npages,) + page0.keyframe.shape
dtype = page0.keyframe.dtype
out = create_output(out, shape, dtype)
if maxworkers is None:
maxworkers = multiprocessing.cpu_count() // 2
page0.parent.filehandle.lock = maxworkers > 1
filecache = OpenFileCache(
size=max(4, maxworkers), lock=page0.parent.filehandle.lock
)
def func(page, index, out=out, filecache=filecache, args=args, kwargs=kwargs):
"""Read, decode, and copy page data."""
if page is not None:
filecache.open(page.parent.filehandle)
out[index] = page.asarray(
lock=filecache.lock, reopen=False, validate=False, *args, **kwargs
)
filecache.close(page.parent.filehandle)
if maxworkers < 2:
for i, page in enumerate(pages):
func(page, i)
else:
with concurrent.futures.ThreadPoolExecutor(maxworkers) as executor:
executor.map(func, pages, range(npages))
filecache.clear()
page0.parent.filehandle.lock = None
return out
def clean_offsets_counts(offsets, counts):
"""Return cleaned offsets and byte counts.
Remove zero offsets and counts. Use to sanitize _offsets and _bytecounts
tag values for strips or tiles.
"""
offsets = list(offsets)
counts = list(counts)
assert len(offsets) == len(counts)
j = 0
for i, (o, b) in enumerate(zip(offsets, counts)):
if o > 0 and b > 0:
if i > j:
offsets[j] = o
counts[j] = b
j += 1
elif b > 0 and o <= 0:
raise ValueError("invalid offset")
else:
warnings.warn("empty byte count")
if j == 0:
j = 1
return offsets[:j], counts[:j]
def buffered_read(fh, lock, offsets, bytecounts, buffersize=2**26):
"""Return iterator over blocks read from file."""
length = len(offsets)
i = 0
while i < length:
data = []
with lock:
size = 0
while size < buffersize and i < length:
fh.seek(offsets[i])
bytecount = bytecounts[i]
data.append(fh.read(bytecount))
size += bytecount
i += 1
for block in data:
yield block
def create_output(out, shape, dtype, mode="w+", suffix=".memmap"):
"""Return numpy array where image data of shape and dtype can be copied.
The 'out' parameter may have the following values or types:
None
An empty array of shape and dtype is created and returned.
numpy.ndarray
An existing writable array of compatible dtype and shape. A view of
the same array is returned after verification.
'memmap' or 'memmap:tempdir'
A memory-map to an array stored in a temporary binary file on disk
is created and returned.
str or open file
The file name or file object used to create a memory-map to an array
stored in a binary file on disk. The created memory-mapped array is
returned.
"""
if out is None:
return numpy.zeros(shape, dtype)
if isinstance(out, str) and out[:6] == "memmap":
tempdir = out[7:] if len(out) > 7 else None
with tempfile.NamedTemporaryFile(dir=tempdir, suffix=suffix) as fh:
return numpy.memmap(fh, shape=shape, dtype=dtype, mode=mode)
if isinstance(out, numpy.ndarray):
if product(shape) != product(out.shape):
raise ValueError("incompatible output shape")
if not numpy.can_cast(dtype, out.dtype):
raise ValueError("incompatible output dtype")
return out.reshape(shape)
if isinstance(out, pathlib.Path):
out = str(out)
return numpy.memmap(out, shape=shape, dtype=dtype, mode=mode)
def matlabstr2py(string):
"""Return Python object from Matlab string representation.
Return str, bool, int, float, list (Matlab arrays or cells), or
dict (Matlab structures) types.
Use to access ScanImage metadata.
>>> matlabstr2py('1')
1
>>> matlabstr2py("['x y z' true false; 1 2.0 -3e4; NaN Inf @class]")
[['x y z', True, False], [1, 2.0, -30000.0], [nan, inf, '@class']]
>>> d = matlabstr2py("SI.hChannels.channelType = {'stripe' 'stripe'}\\n"
... "SI.hChannels.channelsActive = 2")
>>> d['SI.hChannels.channelType']
['stripe', 'stripe']
"""
# TODO: handle invalid input
# TODO: review unboxing of multidimensional arrays
def lex(s):
# return sequence of tokens from matlab string representation
tokens = ["["]
while True:
t, i = next_token(s)
if t is None:
break
if t == ";":
tokens.extend(("]", "["))
elif t == "[":
tokens.extend(("[", "["))
elif t == "]":
tokens.extend(("]", "]"))
else:
tokens.append(t)
s = s[i:]
tokens.append("]")
return tokens
def next_token(s):
# return next token in matlab string
length = len(s)
if length == 0:
return None, 0
i = 0
while i < length and s[i] == " ":
i += 1
if i == length:
return None, i
if s[i] in "{[;]}":
return s[i], i + 1
if s[i] == "'":
j = i + 1
while j < length and s[j] != "'":
j += 1
return s[i : j + 1], j + 1
if s[i] == "<":
j = i + 1
while j < length and s[j] != ">":
j += 1
return s[i : j + 1], j + 1
j = i
while j < length and s[j] not in " {[;]}":
j += 1
return s[i:j], j
def value(s, fail=False):
# return Python value of token
s = s.strip()
if not s:
return s
if len(s) == 1:
try:
return int(s)
except Exception:
if fail:
raise ValueError()
return s
if s[0] == "'":
if fail and s[-1] != "'" or "'" in s[1:-1]:
raise ValueError()
return s[1:-1]
if s[0] == "<":
if fail and s[-1] != ">" or "<" in s[1:-1]:
raise ValueError()
return s
if fail and any(i in s for i in " ';[]{}"):
raise ValueError()
if s[0] == "@":
return s
if s in ("true", "True"):
return True
if s in ("false", "False"):
return False
if s[:6] == "zeros(":
return numpy.zeros([int(i) for i in s[6:-1].split(",")]).tolist()
if s[:5] == "ones(":
return numpy.ones([int(i) for i in s[5:-1].split(",")]).tolist()
if "." in s or "e" in s:
try:
return float(s)
except Exception:
pass
try:
return int(s)
except Exception:
pass
try:
return float(s) # nan, inf
except Exception:
if fail:
raise ValueError()
return s
def parse(s):
# return Python value from string representation of Matlab value
s = s.strip()
try:
return value(s, fail=True)
except ValueError:
pass
result = add2 = []
levels = [add2]
for t in lex(s):
if t in "[{":
add2 = []
levels.append(add2)
elif t in "]}":
x = levels.pop()
if len(x) == 1 and isinstance(x[0], (list, str)):
x = x[0]
add2 = levels[-1]
add2.append(x)
else:
add2.append(value(t))
if len(result) == 1 and isinstance(result[0], (list, str)):
result = result[0]
return result
if "\r" in string or "\n" in string:
# structure
d = {}
for line in string.splitlines():
line = line.strip()
if not line or line[0] == "%":
continue
k, v = line.split("=", 1)
k = k.strip()
if any(c in k for c in " ';[]{}<>"):
continue
d[k] = parse(v)
return d
return parse(string)
def stripnull(string, null=b"\x00"):
"""Return string truncated at first null character.
Clean NULL terminated C strings. For unicode strings use null='\\0'.
>>> stripnull(b'string\\x00')
b'string'
>>> stripnull('string\\x00', null='\\0')
'string'
"""
i = string.find(null)
return string if (i < 0) else string[:i]
def stripascii(string):
"""Return string truncated at last byte that is 7-bit ASCII.
Clean NULL separated and terminated TIFF strings.
>>> stripascii(b'string\\x00string\\n\\x01\\x00')
b'string\\x00string\\n'
>>> stripascii(b'\\x00')
b''
"""
# TODO: pythonize this
i = len(string)
while i:
i -= 1
if 8 < byte2int(string[i]) < 127:
break
else:
i = -1
return string[: i + 1]
def asbool(value, true=(b"true", "true"), false=(b"false", "false")):
"""Return string as bool if possible, else raise TypeError.
>>> asbool(b' False ')
False
"""
value = value.strip().lower()
if value in true: # might raise UnicodeWarning/BytesWarning
return True
if value in false:
return False
raise TypeError()
def astype(value, types=None):
"""Return argument as one of types if possible.
>>> astype('42')
42
>>> astype('3.14')
3.14
>>> astype('True')
True
>>> astype(b'Neee-Wom')
'Neee-Wom'
"""
if types is None:
types = int, float, asbool, bytes2str
for typ in types:
try:
return typ(value)
except (ValueError, AttributeError, TypeError, UnicodeEncodeError):
pass
return value
def format_size(size, threshold=1536):
"""Return file size as string from byte size.
>>> format_size(1234)
'1234 B'
>>> format_size(12345678901)
'11.50 GiB'
"""
if size < threshold:
return "%i B" % size
for unit in ("KiB", "MiB", "GiB", "TiB", "PiB"):
size /= 1024.0
if size < threshold:
return "%.2f %s" % (size, unit)
def identityfunc(arg):
"""Single argument identity function.
>>> identityfunc('arg')
'arg'
"""
return arg
def nullfunc(*args, **kwargs):
"""Null function.
>>> nullfunc('arg', kwarg='kwarg')
"""
return
def sequence(value):
"""Return tuple containing value if value is not a sequence.
>>> sequence(1)
(1,)
>>> sequence([1])
[1]
"""
try:
len(value)
return value
except TypeError:
return (value,)
def product(iterable):
"""Return product of sequence of numbers.
Equivalent of functools.reduce(operator.mul, iterable, 1).
Multiplying numpy integers might overflow.
>>> product([2**8, 2**30])
274877906944
>>> product([])
1
"""
prod = 1
for i in iterable:
prod *= i
return prod
def natural_sorted(iterable):
"""Return human sorted list of strings.
E.g. for sorting file names.
>>> natural_sorted(['f1', 'f2', 'f10'])
['f1', 'f2', 'f10']
"""
def sortkey(x):
return [(int(c) if c.isdigit() else c) for c in re.split(numbers, x)]
numbers = re.compile(r"(\d+)")
return sorted(iterable, key=sortkey)
def excel_datetime(timestamp, epoch=datetime.datetime.fromordinal(693594)):
"""Return datetime object from timestamp in Excel serial format.
Convert LSM time stamps.
>>> excel_datetime(40237.029999999795)
datetime.datetime(2010, 2, 28, 0, 43, 11, 999982)
"""
return epoch + datetime.timedelta(timestamp)
def julian_datetime(julianday, milisecond=0):
"""Return datetime from days since 1/1/4713 BC and ms since midnight.
Convert Julian dates according to MetaMorph.
>>> julian_datetime(2451576, 54362783)
datetime.datetime(2000, 2, 2, 15, 6, 2, 783)
"""
if julianday <= 1721423:
# no datetime before year 1
return None
a = julianday + 1
if a > 2299160:
alpha = math.trunc((a - 1867216.25) / 36524.25)
a += 1 + alpha - alpha // 4
b = a + (1524 if a > 1721423 else 1158)
c = math.trunc((b - 122.1) / 365.25)
d = math.trunc(365.25 * c)
e = math.trunc((b - d) / 30.6001)
day = b - d - math.trunc(30.6001 * e)
month = e - (1 if e < 13.5 else 13)
year = c - (4716 if month > 2.5 else 4715)
hour, milisecond = divmod(milisecond, 1000 * 60 * 60)
minute, milisecond = divmod(milisecond, 1000 * 60)
second, milisecond = divmod(milisecond, 1000)
return datetime.datetime(year, month, day, hour, minute, second, milisecond)
def byteorder_isnative(byteorder):
"""Return if byteorder matches the system's byteorder.
>>> byteorder_isnative('=')
True
"""
if byteorder == "=" or byteorder == sys.byteorder:
return True
keys = {"big": ">", "little": "<"}
return keys.get(byteorder, byteorder) == keys[sys.byteorder]
def recarray2dict(recarray):
"""Return numpy.recarray as dict."""
# TODO: subarrays
result = {}
for descr, value in zip(recarray.dtype.descr, recarray):
name, dtype = descr[:2]
if dtype[1] == "S":
value = bytes2str(stripnull(value))
elif value.ndim < 2:
value = value.tolist()
result[name] = value
return result
def xml2dict(xml, sanitize=True, prefix=None):
"""Return XML as dict.
>>> xml2dict('1')
{'root': {'key': 1, 'attr': 'name'}}
"""
from xml.etree import cElementTree as etree # delayed import
at = tx = ""
if prefix:
at, tx = prefix
def astype(value):
# return value as int, float, bool, or str
for t in (int, float, asbool):
try:
return t(value)
except Exception:
pass
return value
def etree2dict(t):
# adapted from https://stackoverflow.com/a/10077069/453463
key = t.tag
if sanitize:
key = key.rsplit("}", 1)[-1]
d = {key: {} if t.attrib else None}
children = list(t)
if children:
dd = collections.defaultdict(list)
for dc in map(etree2dict, children):
for k, v in dc.items():
dd[k].append(astype(v))
d = {
key: {
k: astype(v[0]) if len(v) == 1 else astype(v) for k, v in dd.items()
}
}
if t.attrib:
d[key].update((at + k, astype(v)) for k, v in t.attrib.items())
if t.text:
text = t.text.strip()
if children or t.attrib:
if text:
d[key][tx + "value"] = astype(text)
else:
d[key] = astype(text)
return d
return etree2dict(etree.fromstring(xml))
def hexdump(bytestr, width=75, height=24, snipat=-2, modulo=2, ellipsis="..."):
"""Return hexdump representation of byte string.
>>> hexdump(binascii.unhexlify('49492a00080000000e00fe0004000100'))
'49 49 2a 00 08 00 00 00 0e 00 fe 00 04 00 01 00 II*.............'
"""
size = len(bytestr)
if size < 1 or width < 2 or height < 1:
return ""
if height == 1:
addr = b""
bytesperline = min(modulo * (((width - len(addr)) // 4) // modulo), size)
if bytesperline < 1:
return ""
nlines = 1
else:
addr = b"%%0%ix: " % len(b"%x" % size)
bytesperline = min(modulo * (((width - len(addr % 1)) // 4) // modulo), size)
if bytesperline < 1:
return ""
width = 3 * bytesperline + len(addr % 1)
nlines = (size - 1) // bytesperline + 1
if snipat is None or snipat == 1:
snipat = height
elif 0 < abs(snipat) < 1:
snipat = int(math.floor(height * snipat))
if snipat < 0:
snipat += height
if height == 1 or nlines == 1:
blocks = [(0, bytestr[:bytesperline])]
addr = b""
height = 1
width = 3 * bytesperline
elif height is None or nlines <= height:
blocks = [(0, bytestr)]
elif snipat <= 0:
start = bytesperline * (nlines - height)
blocks = [(start, bytestr[start:])] # (start, None)
elif snipat >= height or height < 3:
end = bytesperline * height
blocks = [(0, bytestr[:end])] # (end, None)
else:
end1 = bytesperline * snipat
end2 = bytesperline * (height - snipat - 1)
blocks = [
(0, bytestr[:end1]),
(size - end1 - end2, None),
(size - end2, bytestr[size - end2 :]),
]
ellipsis = str2bytes(ellipsis)
result = []
for start, bytestr in blocks:
if bytestr is None:
result.append(ellipsis) # 'skip %i bytes' % start)
continue
hexstr = binascii.hexlify(bytestr)
strstr = re.sub(rb"[^\x20-\x7f]", b".", bytestr)
for i in range(0, len(bytestr), bytesperline):
h = hexstr[2 * i : 2 * i + bytesperline * 2]
r = (addr % (i + start)) if height > 1 else addr
r += b" ".join(h[i : i + 2] for i in range(0, 2 * bytesperline, 2))
r += b" " * (width - len(r))
r += strstr[i : i + bytesperline]
result.append(r)
result = b"\n".join(result)
if sys.version_info[0] == 3:
result = result.decode("ascii")
return result
def isprintable(string):
"""Return if all characters in string are printable.
>>> isprintable('abc')
True
>>> isprintable(b'\01')
False
"""
string = string.strip()
if len(string) < 1:
return True
if sys.version_info[0] == 3:
try:
return string.isprintable()
except Exception:
pass
try:
return string.decode("utf-8").isprintable()
except Exception:
pass
else:
if string.isalnum():
return True
printable = (
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST"
"UVWXYZ!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c"
)
return all(c in printable for c in string)
def clean_whitespace(string, compact=False):
"""Return string with compressed whitespace."""
for a, b in (
("\r\n", "\n"),
("\r", "\n"),
("\n\n", "\n"),
("\t", " "),
(" ", " "),
):
string = string.replace(a, b)
if compact:
for a, b in (("\n", " "), ("[ ", "["), (" ", " "), (" ", " "), (" ", " ")):
string = string.replace(a, b)
return string.strip()
def pformat_xml(xml):
"""Return pretty formatted XML."""
try:
import lxml.etree as etree # delayed import
if not isinstance(xml, bytes):
xml = xml.encode("utf-8")
xml = etree.parse(io.BytesIO(xml))
xml = etree.tostring(
xml, pretty_print=True, xml_declaration=True, encoding=xml.docinfo.encoding
)
xml = bytes2str(xml)
except Exception:
if isinstance(xml, bytes):
xml = bytes2str(xml)
xml = xml.replace("><", ">\n<")
return xml.replace(" ", " ").replace("\t", " ")
def pformat(arg, width=79, height=24, compact=True):
"""Return pretty formatted representation of object as string.
Whitespace might be altered.
"""
if height is None or height < 1:
height = 1024
if width is None or width < 1:
width = 256
npopt = numpy.get_printoptions()
numpy.set_printoptions(threshold=100, linewidth=width)
if isinstance(arg, basestring):
if arg[:5].lower() in (" height:
arg = "\n".join(argl[: height // 2] + ["..."] + argl[-height // 2 :])
return arg
def snipstr(string, width=79, snipat=0.5, ellipsis="..."):
"""Return string cut to specified length.
>>> snipstr('abcdefghijklmnop', 8)
'abc...op'
"""
if ellipsis is None:
if isinstance(string, bytes):
ellipsis = b"..."
else:
ellipsis = "\u2026" # does not print on win-py3.5
esize = len(ellipsis)
splitlines = string.splitlines()
# TODO: finish and test multiline snip
result = []
for line in splitlines:
if line is None:
result.append(ellipsis)
continue
linelen = len(line)
if linelen <= width:
result.append(string)
continue
split = snipat
if split is None or split == 1:
split = linelen
elif 0 < abs(split) < 1:
split = int(math.floor(linelen * split))
if split < 0:
split += linelen
if split < 0:
split = 0
if esize == 0 or width < esize + 1:
if split <= 0:
result.append(string[-width:])
else:
result.append(string[:width])
elif split <= 0:
result.append(ellipsis + string[esize - width :])
elif split >= linelen or width < esize + 4:
result.append(string[: width - esize] + ellipsis)
else:
splitlen = linelen - width + esize
end1 = split - splitlen // 2
end2 = end1 + splitlen
result.append(string[:end1] + ellipsis + string[end2:])
if isinstance(string, bytes):
return b"\n".join(result)
else:
return "\n".join(result)
def enumarg(enum, arg):
"""Return enum member from its name or value.
>>> enumarg(TIFF.PHOTOMETRIC, 2)
>>> enumarg(TIFF.PHOTOMETRIC, 'RGB')
"""
try:
return enum(arg)
except Exception:
try:
return enum[arg.upper()]
except Exception:
raise ValueError("invalid argument %s" % arg)
def parse_kwargs(kwargs, *keys, **keyvalues):
"""Return dict with keys from keys|keyvals and values from kwargs|keyvals.
Existing keys are deleted from kwargs.
>>> kwargs = {'one': 1, 'two': 2, 'four': 4}
>>> kwargs2 = parse_kwargs(kwargs, 'two', 'three', four=None, five=5)
>>> kwargs == {'one': 1}
True
>>> kwargs2 == {'two': 2, 'four': 4, 'five': 5}
True
"""
result = {}
for key in keys:
if key in kwargs:
result[key] = kwargs[key]
del kwargs[key]
for key, value in keyvalues.items():
if key in kwargs:
result[key] = kwargs[key]
del kwargs[key]
else:
result[key] = value
return result
def update_kwargs(kwargs, **keyvalues):
"""Update dict with keys and values if keys do not already exist.
>>> kwargs = {'one': 1, }
>>> update_kwargs(kwargs, one=None, two=2)
>>> kwargs == {'one': 1, 'two': 2}
True
"""
for key, value in keyvalues.items():
if key not in kwargs:
kwargs[key] = value
def validate_jhove(filename, jhove="jhove", ignore=("More than 50 IFDs",)):
"""Validate TIFF file using jhove -m TIFF-hul.
Raise ValueError if jhove outputs an error message unless the message
contains one of the strings in 'ignore'.
JHOVE does not support bigtiff or more than 50 IFDs.
See `JHOVE TIFF-hul Module `_
"""
import subprocess # noqa: delayed import
out = subprocess.check_output([jhove, filename, "-m", "TIFF-hul"])
if b"ErrorMessage: " in out:
for line in out.splitlines():
line = line.strip()
if line.startswith(b"ErrorMessage: "):
error = line[14:].decode("utf8")
for i in ignore:
if i in error:
break
else:
raise ValueError(error)
break
def lsm2bin(lsmfile, binfile=None, tile=(256, 256), verbose=True):
"""Convert [MP]TZCYX LSM file to series of BIN files.
One BIN file containing 'ZCYX' data are created for each position, time,
and tile. The position, time, and tile indices are encoded at the end
of the filenames.
"""
verbose = print_ if verbose else nullfunc
if binfile is None:
binfile = lsmfile
elif binfile.lower() == "none":
binfile = None
if binfile:
binfile += "_(z%ic%iy%ix%i)_m%%ip%%it%%03iy%%ix%%i.bin"
verbose("\nOpening LSM file... ", end="", flush=True)
start_time = time.time()
with TiffFile(lsmfile) as lsm:
if not lsm.is_lsm:
verbose("\n", lsm, flush=True)
raise ValueError("not a LSM file")
series = lsm.series[0] # first series contains the image data
shape = series.shape
axes = series.axes
dtype = series.dtype
size = product(shape) * dtype.itemsize
verbose("%.3f s" % (time.time() - start_time))
# verbose(lsm, flush=True)
verbose(
"Image\n axes: %s\n shape: %s\n dtype: %s\n size: %s"
% (axes, shape, dtype, format_size(size)),
flush=True,
)
if not series.axes.endswith("TZCYX"):
raise ValueError("not a *TZCYX LSM file")
verbose("Copying image from LSM to BIN files", end="", flush=True)
start_time = time.time()
tiles = shape[-2] // tile[-2], shape[-1] // tile[-1]
if binfile:
binfile = binfile % (shape[-4], shape[-3], tile[0], tile[1])
shape = (1,) * (7 - len(shape)) + shape
# cache for ZCYX stacks and output files
data = numpy.empty(shape[3:], dtype=dtype)
out = numpy.empty((shape[-4], shape[-3], tile[0], tile[1]), dtype=dtype)
# iterate over Tiff pages containing data
pages = iter(series.pages)
for m in range(shape[0]): # mosaic axis
for p in range(shape[1]): # position axis
for t in range(shape[2]): # time axis
for z in range(shape[3]): # z slices
data[z] = next(pages).asarray()
for y in range(tiles[0]): # tile y
for x in range(tiles[1]): # tile x
out[:] = data[
...,
y * tile[0] : (y + 1) * tile[0],
x * tile[1] : (x + 1) * tile[1],
]
if binfile:
out.tofile(binfile % (m, p, t, y, x))
verbose(".", end="", flush=True)
verbose(" %.3f s" % (time.time() - start_time))
def imshow(
data,
title=None,
vmin=0,
vmax=None,
cmap=None,
bitspersample=None,
photometric="RGB",
interpolation=None,
dpi=96,
figure=None,
subplot=111,
maxdim=32768,
**kwargs
):
"""Plot n-dimensional images using matplotlib.pyplot.
Return figure, subplot and plot axis.
Requires pyplot already imported C{from matplotlib import pyplot}.
Parameters
----------
bitspersample : int or None
Number of bits per channel in integer RGB images.
photometric : {'MINISWHITE', 'MINISBLACK', 'RGB', or 'PALETTE'}
The color space of the image data.
title : str
Window and subplot title.
figure : matplotlib.figure.Figure (optional).
Matplotlib to use for plotting.
subplot : int
A matplotlib.pyplot.subplot axis.
maxdim : int
maximum image width and length.
kwargs : optional
Arguments for matplotlib.pyplot.imshow.
"""
isrgb = photometric in ("RGB",) # 'PALETTE', 'YCBCR'
if data.dtype.kind == "b":
isrgb = False
if isrgb and not (
data.shape[-1] in (3, 4) or (data.ndim > 2 and data.shape[-3] in (3, 4))
):
isrgb = False
photometric = "MINISBLACK"
data = data.squeeze()
if photometric in ("MINISWHITE", "MINISBLACK", None):
data = reshape_nd(data, 2)
else:
data = reshape_nd(data, 3)
dims = data.ndim
if dims < 2:
raise ValueError("not an image")
elif dims == 2:
dims = 0
isrgb = False
else:
if isrgb and data.shape[-3] in (3, 4):
data = numpy.swapaxes(data, -3, -2)
data = numpy.swapaxes(data, -2, -1)
elif not isrgb and (
data.shape[-1] < data.shape[-2] // 8
and data.shape[-1] < data.shape[-3] // 8
and data.shape[-1] < 5
):
data = numpy.swapaxes(data, -3, -1)
data = numpy.swapaxes(data, -2, -1)
isrgb = isrgb and data.shape[-1] in (3, 4)
dims -= 3 if isrgb else 2
if isrgb:
data = data[..., :maxdim, :maxdim, :maxdim]
else:
data = data[..., :maxdim, :maxdim]
if photometric == "PALETTE" and isrgb:
datamax = data.max()
if datamax > 255:
data = data >> 8 # possible precision loss
data = data.astype("B")
elif data.dtype.kind in "ui":
if not (isrgb and data.dtype.itemsize <= 1) or bitspersample is None:
try:
bitspersample = int(math.ceil(math.log(data.max(), 2)))
except Exception:
bitspersample = data.dtype.itemsize * 8
elif not isinstance(bitspersample, inttypes):
# bitspersample can be tuple, e.g. (5, 6, 5)
bitspersample = data.dtype.itemsize * 8
datamax = 2**bitspersample
if isrgb:
if bitspersample < 8:
data = data << (8 - bitspersample)
elif bitspersample > 8:
data = data >> (bitspersample - 8) # precision loss
data = data.astype("B")
elif data.dtype.kind == "f":
datamax = data.max()
if isrgb and datamax > 1.0:
if data.dtype.char == "d":
data = data.astype("f")
data /= datamax
else:
data = data / datamax
elif data.dtype.kind == "b":
datamax = 1
elif data.dtype.kind == "c":
data = numpy.absolute(data)
datamax = data.max()
if not isrgb:
if vmax is None:
vmax = datamax
if vmin is None:
if data.dtype.kind == "i":
dtmin = numpy.iinfo(data.dtype).min
vmin = numpy.min(data)
if vmin == dtmin:
vmin = numpy.min(data > dtmin)
if data.dtype.kind == "f":
dtmin = numpy.finfo(data.dtype).min
vmin = numpy.min(data)
if vmin == dtmin:
vmin = numpy.min(data > dtmin)
else:
vmin = 0
pyplot = sys.modules["matplotlib.pyplot"]
if figure is None:
pyplot.rc("font", family="sans-serif", weight="normal", size=8)
figure = pyplot.figure(
dpi=dpi, figsize=(10.3, 6.3), frameon=True, facecolor="1.0", edgecolor="w"
)
try:
figure.canvas.manager.window.title(title)
except Exception:
pass
size = len(title.splitlines()) if title else 1
pyplot.subplots_adjust(
bottom=0.03 * (dims + 2),
top=0.98 - size * 0.03,
left=0.1,
right=0.95,
hspace=0.05,
wspace=0.0,
)
subplot = pyplot.subplot(subplot)
if title:
try:
title = unicode(title, "Windows-1252")
except TypeError:
pass
pyplot.title(title, size=11)
if cmap is None:
if data.dtype.char == "?":
cmap = "gray"
elif data.dtype.kind in "buf" or vmin == 0:
cmap = "viridis"
else:
cmap = "coolwarm"
if photometric == "MINISWHITE":
cmap += "_r"
image = pyplot.imshow(
numpy.atleast_2d(data[(0,) * dims].squeeze()),
vmin=vmin,
vmax=vmax,
cmap=cmap,
interpolation=interpolation,
**kwargs
)
if not isrgb:
pyplot.colorbar() # panchor=(0.55, 0.5), fraction=0.05
def format_coord(x, y):
# callback function to format coordinate display in toolbar
x = int(x + 0.5)
y = int(y + 0.5)
try:
if dims:
return "%s @ %s [%4i, %4i]" % (curaxdat[1][y, x], current, y, x)
return "%s @ [%4i, %4i]" % (data[y, x], y, x)
except IndexError:
return ""
def none(event):
return ""
subplot.format_coord = format_coord
image.get_cursor_data = none
image.format_cursor_data = none
if dims:
current = list((0,) * dims)
curaxdat = [0, data[tuple(current)].squeeze()]
sliders = [
pyplot.Slider(
pyplot.axes([0.125, 0.03 * (axis + 1), 0.725, 0.025]),
"Dimension %i" % axis,
0,
data.shape[axis] - 1,
0,
facecolor="0.5",
valfmt="%%.0f [%i]" % data.shape[axis],
)
for axis in range(dims)
]
for slider in sliders:
slider.drawon = False
def set_image(current, sliders=sliders, data=data):
# change image and redraw canvas
curaxdat[1] = data[tuple(current)].squeeze()
image.set_data(curaxdat[1])
for ctrl, index in zip(sliders, current):
ctrl.eventson = False
ctrl.set_val(index)
ctrl.eventson = True
figure.canvas.draw()
def on_changed(index, axis, data=data, current=current):
# callback function for slider change event
index = int(round(index))
curaxdat[0] = axis
if index == current[axis]:
return
if index >= data.shape[axis]:
index = 0
elif index < 0:
index = data.shape[axis] - 1
current[axis] = index
set_image(current)
def on_keypressed(event, data=data, current=current):
# callback function for key press event
key = event.key
axis = curaxdat[0]
if str(key) in "0123456789":
on_changed(key, axis)
elif key == "right":
on_changed(current[axis] + 1, axis)
elif key == "left":
on_changed(current[axis] - 1, axis)
elif key == "up":
curaxdat[0] = 0 if axis == len(data.shape) - 1 else axis + 1
elif key == "down":
curaxdat[0] = len(data.shape) - 1 if axis == 0 else axis - 1
elif key == "end":
on_changed(data.shape[axis] - 1, axis)
elif key == "home":
on_changed(0, axis)
figure.canvas.mpl_connect("key_press_event", on_keypressed)
for axis, ctrl in enumerate(sliders):
ctrl.on_changed(lambda k, a=axis: on_changed(k, a))
return figure, subplot, image
def _app_show():
"""Block the GUI. For use as skimage plugin."""
pyplot = sys.modules["matplotlib.pyplot"]
pyplot.show()
def askopenfilename(**kwargs):
"""Return file name(s) from Tkinter's file open dialog."""
try:
from Tkinter import Tk
import tkFileDialog as filedialog
except ImportError:
from tkinter import Tk, filedialog
root = Tk()
root.withdraw()
root.update()
filenames = filedialog.askopenfilename(**kwargs)
root.destroy()
return filenames
def main(argv=None):
"""Command line usage main function."""
if float(sys.version[0:3]) < 2.7:
print("This script requires Python version 2.7 or better.")
print("This is Python version %s" % sys.version)
return 0
if argv is None:
argv = sys.argv
import optparse # TODO: use argparse
parser = optparse.OptionParser(
usage="usage: %prog [options] path",
description="Display image data in TIFF files.",
version="%%prog %s" % __version__,
)
opt = parser.add_option
opt("-p", "--page", dest="page", type="int", default=-1, help="display single page")
opt(
"-s",
"--series",
dest="series",
type="int",
default=-1,
help="display series of pages of same shape",
)
opt(
"--nomultifile",
dest="nomultifile",
action="store_true",
default=False,
help="do not read OME series from multiple files",
)
opt(
"--noplots",
dest="noplots",
type="int",
default=8,
help="maximum number of plots",
)
opt(
"--interpol",
dest="interpol",
metavar="INTERPOL",
default="bilinear",
help="image interpolation method",
)
opt("--dpi", dest="dpi", type="int", default=96, help="plot resolution")
opt(
"--vmin",
dest="vmin",
type="int",
default=None,
help="minimum value for colormapping",
)
opt(
"--vmax",
dest="vmax",
type="int",
default=None,
help="maximum value for colormapping",
)
opt(
"--debug",
dest="debug",
action="store_true",
default=False,
help="raise exception on failures",
)
opt(
"--doctest",
dest="doctest",
action="store_true",
default=False,
help="runs the docstring examples",
)
opt("-v", "--detail", dest="detail", type="int", default=2)
opt("-q", "--quiet", dest="quiet", action="store_true")
settings, path = parser.parse_args()
path = " ".join(path)
if settings.doctest:
import doctest
doctest.testmod(optionflags=doctest.ELLIPSIS)
return 0
if not path:
path = askopenfilename(
title="Select a TIFF file", filetypes=TIFF.FILEOPEN_FILTER
)
if not path:
parser.error("No file specified")
if any(i in path for i in "?*"):
path = glob.glob(path)
if not path:
print("no files match the pattern")
return 0
# TODO: handle image sequences
path = path[0]
if not settings.quiet:
print("\nReading file structure...", end=" ")
start = time.time()
try:
tif = TiffFile(path, multifile=not settings.nomultifile)
except Exception as e:
if settings.debug:
raise
else:
print("\n", e)
sys.exit(0)
if not settings.quiet:
print("%.3f ms" % ((time.time() - start) * 1e3))
if tif.is_ome:
settings.norgb = True
images = []
if settings.noplots > 0:
if not settings.quiet:
print("Reading image data... ", end=" ")
def notnone(x):
return next(i for i in x if i is not None)
start = time.time()
try:
if settings.page >= 0:
images = [(tif.asarray(key=settings.page), tif[settings.page], None)]
elif settings.series >= 0:
images = [
(
tif.asarray(series=settings.series),
notnone(tif.series[settings.series]._pages),
tif.series[settings.series],
)
]
else:
images = []
for i, s in enumerate(tif.series[: settings.noplots]):
try:
images.append(
(tif.asarray(series=i), notnone(s._pages), tif.series[i])
)
except ValueError as e:
images.append((None, notnone(s.pages), None))
if settings.debug:
raise
else:
print("\nSeries %i failed: %s... " % (i, e), end="")
if not settings.quiet:
print("%.3f ms" % ((time.time() - start) * 1e3))
except Exception as e:
if settings.debug:
raise
else:
print(e)
if not settings.quiet:
print()
print(TiffFile.__str__(tif, detail=int(settings.detail)))
print()
tif.close()
if images and settings.noplots > 0:
try:
import matplotlib
matplotlib.use("TkAgg")
from matplotlib import pyplot
except ImportError as e:
warnings.warn("failed to import matplotlib.\n%s" % e)
else:
for img, page, series in images:
if img is None:
continue
vmin, vmax = settings.vmin, settings.vmax
if "GDAL_NODATA" in page.tags:
try:
vmin = numpy.min(
img[img > float(page.tags["GDAL_NODATA"].value)]
)
except ValueError:
pass
if tif.is_stk:
try:
vmin = tif.stk_metadata["MinScale"]
vmax = tif.stk_metadata["MaxScale"]
except KeyError:
pass
else:
if vmax <= vmin:
vmin, vmax = settings.vmin, settings.vmax
if series:
title = "%s\n%s\n%s" % (str(tif), str(page), str(series))
else:
title = "%s\n %s" % (str(tif), str(page))
photometric = "MINISBLACK"
if page.photometric not in (3,):
photometric = TIFF.PHOTOMETRIC(page.photometric).name
imshow(
img,
title=title,
vmin=vmin,
vmax=vmax,
bitspersample=page.bitspersample,
photometric=photometric,
interpolation=settings.interpol,
dpi=settings.dpi,
)
pyplot.show()
if sys.version_info[0] == 2:
inttypes = int, long # noqa
def print_(*args, **kwargs):
"""Print function with flush support."""
flush = kwargs.pop("flush", False)
print(*args, **kwargs)
if flush:
sys.stdout.flush()
def bytes2str(b, encoding=None, errors=None):
"""Return string from bytes."""
return b
def str2bytes(s, encoding=None):
"""Return bytes from string."""
return s
def byte2int(b):
"""Return value of byte as int."""
return ord(b)
class FileNotFoundError(IOError):
pass
TiffFrame = TiffPage # noqa
else:
inttypes = int
basestring = str, bytes
unicode = str
print_ = print
def bytes2str(b, encoding=None, errors="strict"):
"""Return unicode string from encoded bytes."""
if encoding is not None:
return b.decode(encoding, errors)
try:
return b.decode("utf-8", errors)
except UnicodeDecodeError:
return b.decode("cp1252", errors)
def str2bytes(s, encoding="cp1252"):
"""Return bytes from unicode string."""
return s.encode(encoding)
def byte2int(b):
"""Return value of byte as int."""
return b
if __name__ == "__main__":
sys.exit(main())