s452684/Projekt_AI-Automatyczny_saper
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Projekt_AI-Automatyczny_saper/venv/Lib/site-packages/tifffile/tifffile.py
barmal4 4399265e76 network
2021-06-01 17:38:31 +02:00

16982 lines
581 KiB
Python
Raw Permalink Blame History

# tifffile.py
# Copyright (c) 2008-2021, Christoph Gohlke
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. 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.
#
# 3. Neither the name of the copyright holder nor the names of its
# 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 HOLDER 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 and write TIFF files.
Tifffile is a Python library to
(1) store numpy arrays in TIFF (Tagged Image File Format) files, and
(2) read image and metadata from TIFF-like files used in bioimaging.
Image and metadata can be read from TIFF, BigTIFF, OME-TIFF, STK, LSM, SGI,
NIHImage, ImageJ, MicroManager, FluoView, ScanImage, SEQ, GEL, SVS, SCN, SIS,
ZIF (Zoomable Image File Format), QPTIFF (QPI), NDPI, and GeoTIFF files.
Image data can be read as numpy arrays or zarr arrays/groups from strips,
tiles, pages (IFDs), SubIFDs, higher order series, and pyramidal levels.
Numpy arrays can be written to TIFF, BigTIFF, OME-TIFF, and ImageJ hyperstack
compatible files in multi-page, volumetric, pyramidal, memory-mappable, tiled,
predicted, or compressed form.
A subset of the TIFF specification is supported, mainly 8, 16, 32 and 64-bit
integer, 16, 32 and 64-bit float, grayscale and multi-sample images.
Specifically, CCITT and OJPEG compression, chroma subsampling without JPEG
compression, color space transformations, samples with differing types, or
IPTC and XMP metadata are not implemented.
TIFF, the Tagged Image File Format, was created by the Aldus Corporation and
Adobe Systems Incorporated. BigTIFF allows for files larger than 4 GB.
STK, LSM, FluoView, SGI, SEQ, GEL, QPTIFF, NDPI, SCN, ZIF, and OME-TIFF,
are custom extensions defined by Molecular Devices (Universal Imaging
Corporation), Carl Zeiss MicroImaging, Olympus, Silicon Graphics International,
Media Cybernetics, Molecular Dynamics, PerkinElmer, Hamamatsu, Leica,
ObjectivePathology, and the Open Microscopy Environment consortium,
respectively.
For command line usage run ``python -m tifffile --help``
:Author:
`Christoph Gohlke <https://www.lfd.uci.edu/~gohlke/>`_
:Organization:
Laboratory for Fluorescence Dynamics, University of California, Irvine
:License: BSD 3-Clause
:Version: 2021.4.8
Requirements
------------
This release has been tested with the following requirements and dependencies
(other versions may work):
* `CPython 3.7.9, 3.8.8, 3.9.2 64-bit <https://www.python.org>`_
* `Numpy 1.19.5 <https://pypi.org/project/numpy/>`_
* `Imagecodecs 2021.3.31 <https://pypi.org/project/imagecodecs/>`_
(required only for encoding or decoding LZW, JPEG, etc.)
* `Matplotlib 3.3.3 <https://pypi.org/project/matplotlib/>`_
(required only for plotting)
* `Lxml 4.6.3 <https://pypi.org/project/lxml/>`_
(required only for validating and printing XML)
* `Zarr 2.7.0 <https://pypi.org/project/zarr/>`_
(required only for opening zarr storage)
Revisions
---------
2021.4.8
Pass 4393 tests.
Fix reading OJPEG with wrong photometric or samplesperpixel tags (#75).
Fix fsspec ReferenceFileSystem v1 and JPEG compression.
Use TiffTagRegistry for NDPI_TAGS, EXIF_TAGS, GPS_TAGS, IOP_TAGS constants.
Make TIFF.GEO_KEYS an Enum (breaking).
2021.3.31
Use JPEG restart markers as tile offsets in NDPI.
Support version 1 and more codecs in fsspec ReferenceFileSystem (untested).
2021.3.17
Fix regression reading multi-file OME-TIFF with missing files (#72).
Fix fsspec ReferenceFileSystem with non-native byte order (#56).
2021.3.16
TIFF is no longer a defended trademark.
Add method to export fsspec ReferenceFileSystem from ZarrTiffStore (#56).
2021.3.5
Preliminary support for EER format (#68).
Do not warn about unknown compression (#68).
2021.3.4
Fix reading multi-file, multi-series OME-TIFF (#67).
Detect ScanImage 2021 files (#46).
Shape new version ScanImage series according to metadata (breaking).
Remove Description key from TiffFile.scanimage_metadata dict (breaking).
Also return ScanImage version from read_scanimage_metadata (breaking).
Fix docstrings.
2021.2.26
Squeeze axes of LSM series by default (breaking).
Add option to preserve single dimensions when reading from series (WIP).
Do not allow appending to OME-TIFF files.
Fix reading STK files without name attribute in metadata.
Make TIFF constants multi-thread safe and pickleable (#64).
Add detection of NDTiffStorage MajorVersion to read_micromanager_metadata.
Support ScanImage v4 files in read_scanimage_metadata.
2021.2.1
Fix multi-threaded access of ZarrTiffStores using same TiffFile instance.
Use fallback zlib and lzma codecs with imagecodecs lite builds.
Open Olympus and Panasonic RAW files for parsing, albeit not supported.
Support X2 and X4 differencing found in DNG.
Support reading JPEG_LOSSY compression found in DNG.
2021.1.14
Try ImageJ series if OME series fails (#54)
Add option to use pages as chunks in ZarrFileStore (experimental).
Fix reading from file objects with no readinto function.
2021.1.11
Fix test errors on PyPy.
Fix decoding bitorder with imagecodecs >= 2021.1.11.
2021.1.8
Decode float24 using imagecodecs >= 2021.1.8.
Consolidate reading of segments if possible.
2020.12.8
Fix corrupted ImageDescription in multi shaped series if buffer too small.
Fix libtiff warning that ImageDescription contains null byte in value.
Fix reading invalid files using JPEG compression with palette colorspace.
2020.12.4
Fix reading some JPEG compressed CFA images.
Make index of SubIFDs a tuple.
Pass through FileSequence.imread arguments in imread.
Do not apply regex flags to FileSequence axes patterns (breaking).
2020.11.26
Add option to pass axes metadata to ImageJ writer.
Pad incomplete tiles passed to TiffWriter.write (#38).
Split TiffTag constructor (breaking).
Change TiffTag.dtype to TIFF.DATATYPES (breaking).
Add TiffTag.overwrite method.
Add script to change ImageDescription in files.
Add TiffWriter.overwrite_description method (WIP).
2020.11.18
Support writing SEPARATED color space (#37).
Use imagecodecs.deflate codec if available.
Fix SCN and NDPI series with Z dimensions.
Add TiffReader alias for TiffFile.
TiffPage.is_volumetric returns True if ImageDepth > 1.
Zarr store getitem returns numpy arrays instead of bytes.
2020.10.1
Formally deprecate unused TiffFile parameters (scikit-image #4996).
2020.9.30
Allow to pass additional arguments to compression codecs.
Deprecate TiffWriter.save method (use TiffWriter.write).
Deprecate TiffWriter.save compress parameter (use compression).
Remove multifile parameter from TiffFile (breaking).
Pass all is_flag arguments from imread to TiffFile.
Do not byte-swap JPEG2000, WEBP, PNG, JPEGXR segments in TiffPage.decode.
2020.9.29
Fix reading files produced by ScanImage > 2015 (#29).
2020.9.28
Derive ZarrStore from MutableMapping.
Support zero shape ZarrTiffStore.
Fix ZarrFileStore with non-TIFF files.
Fix ZarrFileStore with missing files.
Cache one chunk in ZarrFileStore.
Keep track of already opened files in FileCache.
Change parse_filenames function to return zero-based indices.
Remove reopen parameter from asarray (breaking).
Rename FileSequence.fromfile to imread (breaking).
2020.9.22
Add experimental zarr storage interface (WIP).
Remove unused first dimension from TiffPage.shaped (breaking).
Move reading of STK planes to series interface (breaking).
Always use virtual frames for ScanImage files.
Use DimensionOrder to determine axes order in OmeXml.
Enable writing striped volumetric images.
Keep complete dataoffsets and databytecounts for TiffFrames.
Return full size tiles from Tiffpage.segments.
Rename TiffPage.is_sgi property to is_volumetric (breaking).
Rename TiffPageSeries.is_pyramid to is_pyramidal (breaking).
Fix TypeError when passing jpegtables to non-JPEG decode method (#25).
2020.9.3
Do not write contiguous series by default (breaking).
Allow to write to SubIFDs (WIP).
Fix writing F-contiguous numpy arrays (#24).
2020.8.25
Do not convert EPICS timeStamp to datetime object.
Read incompletely written Micro-Manager image file stack header (#23).
Remove tag 51123 values from TiffFile.micromanager_metadata (breaking).
2020.8.13
Use tifffile metadata over OME and ImageJ for TiffFile.series (breaking).
Fix writing iterable of pages with compression (#20).
Expand error checking of TiffWriter data, dtype, shape, and tile arguments.
2020.7.24
Parse nested OmeXml metadata argument (WIP).
Do not lazy load TiffFrame JPEGTables.
Fix conditionally skipping some tests.
2020.7.22
Do not auto-enable OME-TIFF if description is passed to TiffWriter.save.
Raise error writing empty bilevel or tiled images.
Allow to write tiled bilevel images.
Allow to write multi-page TIFF from iterable of single page images (WIP).
Add function to validate OME-XML.
Correct Philips slide width and length.
2020.7.17
Initial support for writing OME-TIFF (WIP).
Return samples as separate dimension in OME series (breaking).
Fix modulo dimensions for multiple OME series.
Fix some test errors on big endian systems (#18).
Fix BytesWarning.
Allow to pass TIFF.PREDICTOR values to TiffWriter.save.
2020.7.4
Deprecate support for Python 3.6 (NEP 29).
Move pyramidal subresolution series to TiffPageSeries.levels (breaking).
Add parser for SVS, SCN, NDPI, and QPI pyramidal series.
Read single-file OME-TIFF pyramids.
Read NDPI files > 4 GB (#15).
Include SubIFDs in generic series.
Preliminary support for writing packed integer arrays (#11, WIP).
Read more LSM info subrecords.
Fix missing ReferenceBlackWhite tag for YCbCr photometrics.
Fix reading lossless JPEG compressed DNG files.
2020.6.3
...
Refer to the CHANGES file for older revisions.
Notes
-----
The API is not stable yet and might change between revisions.
Tested on little-endian platforms only.
Python 32-bit versions are deprecated. Python <= 3.7 are no longer supported.
Tifffile relies on the `imagecodecs <https://pypi.org/project/imagecodecs/>`_
package for encoding and decoding LZW, JPEG, and other compressed image
segments.
Several TIFF-like formats do not strictly adhere to the TIFF6 specification,
some of which allow file or data sizes to exceed the 4 GB limit:
* *BigTIFF* is identified by version number 43 and uses different file
header, IFD, and tag structures with 64-bit offsets. It adds more data types.
Tifffile can read and write BigTIFF files.
* *ImageJ* hyperstacks store all image data, which may exceed 4 GB,
contiguously after the first IFD. Files > 4 GB contain one IFD only.
The size (shape and dtype) of the up to 6-dimensional image data can be
determined from the ImageDescription tag of the first IFD, which is Latin-1
encoded. Tifffile can read and write ImageJ hyperstacks.
* *OME-TIFF* stores up to 8-dimensional data in one or multiple TIFF of BigTIFF
files. The 8-bit UTF-8 encoded OME-XML metadata found in the ImageDescription
tag of the first IFD defines the position of TIFF IFDs in the high
dimensional data. Tifffile can read OME-TIFF files, except when the OME-XML
metadata are stored in a separate file. Tifffile can write numpy arrays
to single-file OME-TIFF.
* *LSM* stores all IFDs below 4 GB but wraps around 32-bit StripOffsets.
The StripOffsets of each series and position require separate unwrapping.
The StripByteCounts tag contains the number of bytes for the uncompressed
data. Tifffile can read large LSM files.
* *STK* (MetaMorph Stack) contains additional image planes stored contiguously
after the image data of the first page. The total number of planes
is equal to the counts of the UIC2tag. Tifffile can read STK files.
* *NDPI* uses some 64-bit offsets in the file header, IFD, and tag structures.
Tag values/offsets can be corrected using high bits stored after IFD
structures. Tifffile can read NDPI files > 4 GB. JPEG compressed segments
with dimensions >65530 or missing restart markers are not readable with
libjpeg. Tifffile works around this limitation by separately decoding the
MCUs between restart markers.
* *Philips* TIFF slides store wrong ImageWidth and ImageLength tag values for
tiled pages. The values can be corrected using the DICOM_PIXEL_SPACING
attributes of the XML formatted description of the first page. Tifffile can
read Philips slides.
* *ScanImage* optionally allows corrupt non-BigTIFF files > 2 GB. The values
of StripOffsets and StripByteCounts can be recovered using the constant
differences of the offsets of IFD and tag values throughout the file.
Tifffile can read such files if the image data are stored contiguously in
each page.
* *GeoTIFF* sparse files allow strip or tile offsets and byte counts to be 0.
Such segments are implicitly set to 0 or the NODATA value on reading.
Tifffile can read GeoTIFF sparse files.
Other libraries for reading scientific TIFF files from Python:
* `Python-bioformats <https://github.com/CellProfiler/python-bioformats>`_
* `Imread <https://github.com/luispedro/imread>`_
* `GDAL <https://github.com/OSGeo/gdal/tree/master/gdal/swig/python>`_
* `OpenSlide-python <https://github.com/openslide/openslide-python>`_
* `PyLibTiff <https://github.com/pearu/pylibtiff>`_
* `SimpleITK <https://github.com/SimpleITK/SimpleITK>`_
* `PyLSM <https://launchpad.net/pylsm>`_
* `PyMca.TiffIO.py <https://github.com/vasole/pymca>`_ (same as fabio.TiffIO)
* `BioImageXD.Readers <http://www.bioimagexd.net/>`_
* `CellCognition <https://cellcognition-project.org/>`_
* `pymimage <https://github.com/ardoi/pymimage>`_
* `pytiff <https://github.com/FZJ-INM1-BDA/pytiff>`_
* `ScanImageTiffReaderPython
<https://gitlab.com/vidriotech/scanimagetiffreader-python>`_
* `bigtiff <https://pypi.org/project/bigtiff>`_
* `Large Image <https://github.com/girder/large_image>`_
Some libraries are using tifffile to write OME-TIFF files:
* `Zeiss Apeer OME-TIFF library
<https://github.com/apeer-micro/apeer-ometiff-library>`_
* `Allen Institute for Cell Science imageio
<https://pypi.org/project/aicsimageio>`_
* `xtiff <https://github.com/BodenmillerGroup/xtiff>`_
Other tools for inspecting and manipulating TIFF files:
* `tifftools <https://github.com/DigitalSlideArchive/tifftools>`_
* `Tyf <https://github.com/Moustikitos/tyf>`_
References
----------
* TIFF 6.0 Specification and Supplements. Adobe Systems Incorporated.
https://www.adobe.io/open/standards/TIFF.html
* TIFF File Format FAQ. https://www.awaresystems.be/imaging/tiff/faq.html
* The BigTIFF File Format.
https://www.awaresystems.be/imaging/tiff/bigtiff.html
* MetaMorph Stack (STK) Image File Format.
http://mdc.custhelp.com/app/answers/detail/a_id/18862
* Image File Format Description LSM 5/7 Release 6.0 (ZEN 2010).
Carl Zeiss MicroImaging GmbH. BioSciences. May 10, 2011
* The OME-TIFF format.
https://docs.openmicroscopy.org/ome-model/latest/
* UltraQuant(r) Version 6.0 for Windows Start-Up Guide.
http://www.ultralum.com/images%20ultralum/pdf/UQStart%20Up%20Guide.pdf
* Micro-Manager File Formats.
https://micro-manager.org/wiki/Micro-Manager_File_Formats
* ScanImage BigTiff Specification - ScanImage 2019.
http://scanimage.vidriotechnologies.com/display/SI2019/
ScanImage+BigTiff+Specification
* ZIF, the Zoomable Image File format. http://zif.photo/
* GeoTIFF File Format https://gdal.org/drivers/raster/gtiff.html
* Cloud optimized GeoTIFF.
https://github.com/cogeotiff/cog-spec/blob/master/spec.md
* Tags for TIFF and Related Specifications. Digital Preservation.
https://www.loc.gov/preservation/digital/formats/content/tiff_tags.shtml
* 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
* The EER (Electron Event Representation) file format.
https://github.com/fei-company/EerReaderLib
Examples
--------
Write a numpy array to a single-page RGB TIFF file:
>>> data = numpy.random.randint(0, 255, (256, 256, 3), 'uint8')
>>> imwrite('temp.tif', data, photometric='rgb')
Read the image from the TIFF file as numpy array:
>>> image = imread('temp.tif')
>>> image.shape
(256, 256, 3)
Write a 3D numpy array to a multi-page, 16-bit grayscale TIFF file:
>>> data = numpy.random.randint(0, 2**12, (64, 301, 219), 'uint16')
>>> imwrite('temp.tif', data, photometric='minisblack')
Read the whole image stack from the TIFF file as numpy array:
>>> image_stack = imread('temp.tif')
>>> image_stack.shape
(64, 301, 219)
>>> image_stack.dtype
dtype('uint16')
Read the image from the first page in the TIFF file as numpy array:
>>> image = imread('temp.tif', key=0)
>>> image.shape
(301, 219)
Read images from a selected range of pages:
>>> image = imread('temp.tif', key=range(4, 40, 2))
>>> image.shape
(18, 301, 219)
Iterate over all pages in the TIFF file and successively read images:
>>> with TiffFile('temp.tif') as tif:
... for page in tif.pages:
... image = page.asarray()
Get information about the image stack in the TIFF file without reading
the image data:
>>> tif = TiffFile('temp.tif')
>>> len(tif.pages) # number of pages in the file
64
>>> page = tif.pages[0] # get shape and dtype of the image in the first page
>>> page.shape
(301, 219)
>>> page.dtype
dtype('uint16')
>>> page.axes
'YX'
>>> series = tif.series[0] # get shape and dtype of the first image series
>>> series.shape
(64, 301, 219)
>>> series.dtype
dtype('uint16')
>>> series.axes
'QYX'
>>> tif.close()
Inspect the "XResolution" tag from the first page in the TIFF file:
>>> with TiffFile('temp.tif') as tif:
... tag = tif.pages[0].tags['XResolution']
>>> tag.value
(1, 1)
>>> tag.name
'XResolution'
>>> tag.code
282
>>> tag.count
1
>>> tag.dtype
<DATATYPES.RATIONAL: 5>
Iterate over all tags in the TIFF file:
>>> with TiffFile('temp.tif') as tif:
... for page in tif.pages:
... for tag in page.tags:
... tag_name, tag_value = tag.name, tag.value
Overwrite the value of an existing tag, e.g. XResolution:
>>> with TiffFile('temp.tif', mode='r+b') as tif:
... _ = tif.pages[0].tags['XResolution'].overwrite(tif, (96000, 1000))
Write a floating-point ndarray and metadata using BigTIFF format, tiling,
compression, and planar storage:
>>> data = numpy.random.rand(2, 5, 3, 301, 219).astype('float32')
>>> imwrite('temp.tif', data, bigtiff=True, photometric='minisblack',
... compression='deflate', planarconfig='separate', tile=(32, 32),
... metadata={'axes': 'TZCYX'})
Write a volume with xyz voxel size 2.6755x2.6755x3.9474 micron^3 to an
ImageJ hyperstack formatted TIFF file:
>>> volume = numpy.random.randn(57, 256, 256).astype('float32')
>>> imwrite('temp.tif', volume, imagej=True, resolution=(1./2.6755, 1./2.6755),
... metadata={'spacing': 3.947368, 'unit': 'um', 'axes': 'ZYX'})
Read the volume and metadata from the ImageJ file:
>>> with TiffFile('temp.tif') as tif:
... volume = tif.asarray()
... axes = tif.series[0].axes
... imagej_metadata = tif.imagej_metadata
>>> volume.shape
(57, 256, 256)
>>> axes
'ZYX'
>>> imagej_metadata['slices']
57
Create an empty TIFF file and write to the memory-mapped numpy array:
>>> memmap_image = memmap('temp.tif', shape=(3, 256, 256), dtype='float32')
>>> memmap_image[1, 255, 255] = 1.0
>>> memmap_image.flush()
>>> del memmap_image
Memory-map image data of the first page in the TIFF file:
>>> memmap_image = memmap('temp.tif', page=0)
>>> memmap_image[1, 255, 255]
1.0
>>> del memmap_image
Write two numpy arrays to a multi-series TIFF file:
>>> series0 = numpy.random.randint(0, 255, (32, 32, 3), 'uint8')
>>> series1 = numpy.random.randint(0, 1023, (4, 256, 256), 'uint16')
>>> with TiffWriter('temp.tif') as tif:
... tif.write(series0, photometric='rgb')
... tif.write(series1, photometric='minisblack')
Read the second image series from the TIFF file:
>>> series1 = imread('temp.tif', series=1)
>>> series1.shape
(4, 256, 256)
Successively write the frames of one contiguous series to a TIFF file:
>>> data = numpy.random.randint(0, 255, (30, 301, 219), 'uint8')
>>> with TiffWriter('temp.tif') as tif:
... for frame in data:
... tif.write(frame, contiguous=True)
Append an image series to the existing TIFF file:
>>> data = numpy.random.randint(0, 255, (301, 219, 3), 'uint8')
>>> imwrite('temp.tif', data, append=True)
Create a TIFF file from a generator of tiles:
>>> data = numpy.random.randint(0, 2**12, (31, 33, 3), 'uint16')
>>> def tiles(data, tileshape):
... for y in range(0, data.shape[0], tileshape[0]):
... for x in range(0, data.shape[1], tileshape[1]):
... yield data[y : y + tileshape[0], x : x + tileshape[1]]
>>> imwrite('temp.tif', tiles(data, (16, 16)), tile=(16, 16),
... shape=data.shape, dtype=data.dtype)
Write two numpy arrays to a multi-series OME-TIFF file:
>>> series0 = numpy.random.randint(0, 255, (32, 32, 3), 'uint8')
>>> series1 = numpy.random.randint(0, 1023, (4, 256, 256), 'uint16')
>>> with TiffWriter('temp.ome.tif') as tif:
... tif.write(series0, photometric='rgb')
... tif.write(series1, photometric='minisblack',
... metadata={'axes': 'ZYX', 'SignificantBits': 10,
... 'Plane': {'PositionZ': [0.0, 1.0, 2.0, 3.0]}})
Write a tiled, multi-resolution, pyramidal, OME-TIFF file using
JPEG compression. Sub-resolution images are written to SubIFDs:
>>> data = numpy.arange(1024*1024*3, dtype='uint8').reshape((1024, 1024, 3))
>>> with TiffWriter('temp.ome.tif', bigtiff=True) as tif:
... options = dict(tile=(256, 256), compression='jpeg')
... tif.write(data, subifds=2, **options)
... # save pyramid levels to the two subifds
... # in production use resampling to generate sub-resolutions
... tif.write(data[::2, ::2], subfiletype=1, **options)
... tif.write(data[::4, ::4], subfiletype=1, **options)
Access the image levels in the pyramidal OME-TIFF file:
>>> baseimage = imread('temp.ome.tif')
>>> second_level = imread('temp.ome.tif', series=0, level=1)
>>> with TiffFile('temp.ome.tif') as tif:
... baseimage = tif.series[0].asarray()
... second_level = tif.series[0].levels[1].asarray()
Iterate over and decode single JPEG compressed tiles in the TIFF file:
>>> with TiffFile('temp.ome.tif') as tif:
... fh = tif.filehandle
... for page in tif.pages:
... for index, (offset, bytecount) in enumerate(
... zip(page.dataoffsets, page.databytecounts)
... ):
... fh.seek(offset)
... data = fh.read(bytecount)
... tile, indices, shape = page.decode(
... data, index, jpegtables=page.jpegtables
... )
Use zarr to access the tiled, pyramidal images in the TIFF file:
>>> import zarr
>>> store = imread('temp.ome.tif', aszarr=True)
>>> z = zarr.open(store, mode='r')
>>> z
<zarr.hierarchy.Group '/' read-only>
>>> z[0] # base layer
<zarr.core.Array '/0' (1024, 1024, 3) uint8 read-only>
>>> store.close()
Read images from a sequence of TIFF files as numpy array:
>>> imwrite('temp_C001T001.tif', numpy.random.rand(64, 64))
>>> imwrite('temp_C001T002.tif', numpy.random.rand(64, 64))
>>> image_sequence = imread(['temp_C001T001.tif', 'temp_C001T002.tif'])
>>> image_sequence.shape
(2, 64, 64)
Read an image stack from a series of TIFF files with a file name pattern
as numpy or zarr arrays:
>>> image_sequence = TiffSequence('temp_C001*.tif', pattern='axes')
>>> image_sequence.shape
(1, 2)
>>> image_sequence.axes
'CT'
>>> data = image_sequence.asarray()
>>> data.shape
(1, 2, 64, 64)
>>> with image_sequence.aszarr() as store:
... zarr.open(store, mode='r')
<zarr.core.Array (1, 2, 64, 64) float64 read-only>
>>> image_sequence.close()
"""
__version__ = '2021.4.8'
__all__ = (
'OmeXml',
'OmeXmlError',
'TIFF',
'TiffFile',
'TiffFileError',
'TiffFrame',
'TiffPage',
'TiffPageSeries',
'TiffReader',
'TiffSequence',
'TiffTag',
'TiffTags',
'TiffTagRegistry',
'TiffWriter',
'ZarrFileStore',
'ZarrStore',
'ZarrTiffStore',
'imread',
'imshow',
'imwrite',
'lsm2bin',
'memmap',
'read_micromanager_metadata',
'read_scanimage_metadata',
'tiffcomment',
# utility classes and functions used by oiffile, czifile, etc.
'FileCache',
'FileHandle',
'FileSequence',
'Timer',
'askopenfilename',
'astype',
'create_output',
'enumarg',
'enumstr',
'format_size',
'lazyattr',
'matlabstr2py',
'natural_sorted',
'nullfunc',
'parse_kwargs',
'pformat',
'product',
'repeat_nd',
'reshape_axes',
'reshape_nd',
'squeeze_axes',
'stripnull',
'transpose_axes',
'update_kwargs',
'xml2dict',
'_app_show',
# deprecated
'imsave',
)
import binascii
import collections
import datetime
import enum
import glob
import io
import json
import math
import os
import re
import struct
import sys
import threading
import time
import warnings
from collections.abc import Iterable, MutableMapping
from concurrent.futures import ThreadPoolExecutor
import numpy
try:
import imagecodecs
except Exception:
imagecodecs = None
# delay import of mmap, pprint, fractions, xml, lxml, matplotlib, tkinter,
# logging, subprocess, multiprocessing, tempfile, zipfile, fnmatch
def imread(files=None, aszarr=False, **kwargs):
"""Return image data from TIFF file(s) as numpy array or zarr storage.
Refer to the TiffFile and TiffSequence classes and their asarray
functions for documentation.
Parameters
----------
files : str, path-like, binary stream, or sequence
File name, seekable binary stream, glob pattern, or sequence of
file names.
aszarr : bool
If True, return file sequences, series, or single pages as
zarr storage instead of numpy array (experimental).
kwargs : dict
Parameters 'name', 'offset', 'size', and 'is_' flags are passed to
TiffFile or TiffSequence.imread.
The 'pattern', 'sort', 'container', and 'axesorder' parameters are
passed to TiffSequence().
Other parameters are passed to the asarray or aszarr functions.
The first image series in the file is returned if no arguments are
provided.
Returns
-------
numpy.ndarray or zarr storage
Image data from the specified pages.
Zarr storage instances must be closed after use.
See TiffPage.asarray for operations that are applied (or not)
to the raw data stored in the file.
"""
kwargs_file = parse_kwargs(
kwargs,
'name',
'offset',
'size',
# private
'_multifile',
'_useframes',
# deprecated, ignored
'fastij',
'movie',
'multifile',
'multifile_close',
# is_flags
*(key for key in kwargs if key[:3] == 'is_'),
)
kwargs_seq = parse_kwargs(
kwargs, 'pattern', 'sort', 'container', 'imread', 'axesorder'
)
if kwargs.get('pages', None) is not None:
if kwargs.get('key', None) is not None:
raise TypeError(
"the 'pages' and 'key' parameters cannot be used together"
)
warnings.warn(
"imread: the 'pages' parameter is deprecated", DeprecationWarning
)
kwargs['key'] = kwargs.pop('pages')
if kwargs_seq.get('container', None) is None:
if isinstance(files, str) and ('*' in files or '?' in files):
files = glob.glob(files)
if not files:
raise ValueError('no files found')
if (
not hasattr(files, 'seek')
and not isinstance(files, (str, os.PathLike))
and len(files) == 1
):
files = files[0]
if isinstance(files, (str, os.PathLike)) or hasattr(files, 'seek'):
with TiffFile(files, **kwargs_file) as tif:
if aszarr:
return tif.aszarr(**kwargs)
return tif.asarray(**kwargs)
with TiffSequence(files, **kwargs_seq) as imseq:
if aszarr:
return imseq.aszarr(**kwargs, **kwargs_file)
return imseq.asarray(**kwargs, **kwargs_file)
def imwrite(file, data=None, shape=None, dtype=None, **kwargs):
"""Write numpy array to TIFF file.
Refer to the TiffWriter class and its write function for documentation.
A BigTIFF file is created if the data's size is larger than 4 GB minus
32 MB (for metadata), and 'bigtiff' is not specified, and 'imagej' or
'truncate' are not enabled.
Parameters
----------
file : str, path-like, 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,
length, 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, datatype of an empty array to save to the file.
kwargs : dict
Parameters 'append', 'byteorder', 'bigtiff', 'imagej', and 'ome',
are passed to TiffWriter().
Other parameters are passed to TiffWriter.write().
Returns
-------
offset, bytecount : tuple or None
If the 'returnoffset' argument is True and the image data are written
contiguously, return offset and bytecount of image data in the file.
"""
tifargs = parse_kwargs(
kwargs, 'append', 'bigtiff', 'byteorder', 'imagej', 'ome'
)
if data is None:
dtype = numpy.dtype(dtype)
datasize = product(shape) * dtype.itemsize
byteorder = dtype.byteorder
else:
try:
datasize = data.nbytes
byteorder = data.dtype.byteorder
except Exception:
datasize = 0
byteorder = None
bigsize = kwargs.pop('bigsize', 2 ** 32 - 2 ** 25)
if (
'bigtiff' not in tifargs
and datasize > bigsize
and not tifargs.get('imagej', False)
and not tifargs.get('truncate', False)
and not kwargs.get('compression', False)
and not kwargs.get('compress', False) # TODO: remove deprecated
):
tifargs['bigtiff'] = True
if 'byteorder' not in tifargs:
tifargs['byteorder'] = byteorder
with TiffWriter(file, **tifargs) as tif:
result = tif.write(data, shape, dtype, **kwargs)
return result
def memmap(
filename,
shape=None,
dtype=None,
page=None,
series=0,
level=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 are overwritten or
appended to depending on the 'append' parameter.
Otherwise the image data of a specified page or series in an existing
file are memory-mapped. By default, the image data of the first
series are memory-mapped.
Call flush() to write any changes in the array to the file.
Raise ValueError if the image data in the file are not memory-mappable.
Parameters
----------
filename : str or path-like
Name of the TIFF file which stores the array.
shape : tuple
Shape of the empty array.
dtype : numpy.dtype
Datatype of the empty array.
page : int
Index of the page which image data to memory-map.
series, level : int
Index of the page series and pyramid level which image data to
memory-map.
mode : {'r+', 'r', 'c'}
The file open mode. Default is to open existing file for reading and
writing ('r+').
kwargs : dict
Additional parameters passed to imwrite() or TiffFile().
Returns
-------
numpy.memmap
Image data in TIFF file.
"""
if shape is not None and dtype is not None:
# create a new, empty array
kwargs.update(
data=None,
shape=shape,
dtype=dtype,
align=TIFF.ALLOCATIONGRANULARITY,
returnoffset=True,
)
result = imwrite(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:
"""Attribute whose value is computed on first access.
Lazyattrs are not thread-safe.
"""
# TODO: replace with functools.cached_property? requires Python >= 3.8
__slots__ = ('func', '__dict__')
def __init__(self, func):
"""Initialize instance from decorated function."""
self.func = func
self.__doc__ = func.__doc__
self.__module__ = func.__module__
self.__name__ = func.__name__
self.__qualname__ = func.__qualname__
# 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 exc:
raise RuntimeError(exc)
if value is NotImplemented:
return getattr(super(owner, instance), self.func.__name__)
setattr(instance, self.func.__name__, value)
return value
class TiffFileError(Exception):
"""Exception to indicate invalid TIFF structure."""
class TiffWriter:
"""Write numpy arrays to TIFF file.
TiffWriter's main purpose is saving nD numpy array's as TIFF, not to
create any possible TIFF format. Specifically, ExifIFD and GPSIFD tags.
TiffWriter instances must be closed using the 'close' method, which is
automatically called when using the 'with' context manager.
TiffWriter instances are not thread-safe.
"""
def __init__(
self,
file,
bigtiff=False,
byteorder=None,
append=False,
imagej=False,
ome=None,
):
"""Open 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, path-like, 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 OME-TIFF, LSM, STK, ImageJ, or FluoView.
imagej : bool
If True and not 'ome', 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 hyperstacks do not support BigTIFF or compression.
The ImageJ file format is undocumented.
When using compression, use ImageJ's Bio-Formats import function.
ome : bool
If True, write an OME-TIFF compatible file. If None (default),
the value is determined from the file name extension, the value of
the 'description' parameter in the first call of the write
function, and the value of 'imagej'.
Refer to the OME model for restrictions of this format.
"""
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 not tif.is_appendable:
raise ValueError(
'cannot append to file containing metadata'
)
byteorder = tif.byteorder
bigtiff = tif.is_bigtiff
self._ifdoffset = tif.pages.next_page_offset
finally:
fh.seek(pos)
except (OSError, FileNotFoundError):
append = False
if imagej and bigtiff:
warnings.warn(
'TiffWriter: writing nonconformant BigTIFF ImageJ', UserWarning
)
if byteorder in (None, '=', '|'):
byteorder = '<' if sys.byteorder == 'little' else '>'
elif byteorder not in ('<', '>'):
raise ValueError(f'invalid byteorder {byteorder}')
if byteorder == '<':
self.tiff = TIFF.BIG_LE if bigtiff else TIFF.CLASSIC_LE
else:
self.tiff = TIFF.BIG_BE if bigtiff else TIFF.CLASSIC_BE
self._truncate = False
self._metadata = None
self._colormap = None
self._tags = None
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._dataoffsetstag = None # strip or tile offset tag code
self._descriptiontag = None # TiffTag for updating comment
self._subifds = 0 # number of subifds
self._subifdslevel = -1 # index of current subifd level
self._subifdsoffsets = [] # offsets to offsets to subifds
self._nextifdoffsets = [] # offsets to offset to next ifd
self._ifdindex = 0 # index of current ifd
# normalized shape of data in consecutive pages
# (pages, separate_samples, depth, length, width, contig_samples)
self._storedshape = None
if append:
self._fh = FileHandle(file, mode='r+b', size=0)
self._fh.seek(0, os.SEEK_END)
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(self.tiff.offsetformat, 0))
self._ome = None if ome is None else bool(ome)
self._imagej = False if self._ome else bool(imagej)
if self._imagej:
self._ome = False
@property
def filehandle(self):
"""Return file handle."""
return self._fh
def write(
self,
data=None,
shape=None,
dtype=None,
photometric=None,
planarconfig=None,
extrasamples=None,
volumetric=False,
tile=None,
contiguous=False,
truncate=False,
align=None,
rowsperstrip=None,
bitspersample=None,
compression=None,
predictor=None,
subsampling=None,
colormap=None,
description=None,
datetime=None,
resolution=None,
subfiletype=0,
software=None,
subifds=None,
metadata={},
extratags=(),
returnoffset=False,
ijmetadata=None, # deprecated: use metadata
compress=None, # deprecated: use compression
):
"""Write numpy ndarray to a series of TIFF pages.
The ND image data are written to a series of TIFF pages/IFDs.
By default, metadata in JSON, ImageJ, or OME-XML format are written
to the ImageDescription tag of the first page to describe the series
such that the image data can later be read back as a ndarray of same
shape.
The data shape's last dimensions are assumed to be image depth,
length (height), 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 instead of 'data', an empty array
is saved. This option cannot be used with compression, predictors,
packed integers, bilevel images, or multiple tiles.
If 'shape', 'dtype', and 'tile' are specified, 'data' must be an
iterable of all tiles in the image.
If 'shape', 'dtype', and 'data' are specified but not 'tile', 'data'
must be an iterable of all single planes in the image.
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 volumetric mode) are flattened and saved as separate
pages.
If the data size is zero, a single page with shape (0, 0) is saved.
The SampleFormat tag is derived from the data type or dtype.
Parameters
----------
data : numpy.ndarray, iterable of numpy.ndarray, or None
Input image or iterable of tiles or images.
A copy of the image data is made if 'data' is not a C-contiguous
numpy array with the same byteorder as the TIFF file.
Iterables must yield C-contiguous numpy array of TIFF byteorder.
Iterable tiles must match 'dtype' and the shape specified in
'tile'. Incomplete tiles are zero-padded.
Iterable images must match 'dtype' and 'shape[1:]'.
shape : tuple or None
Shape of the empty or iterable data to save.
Use only if 'data' is None or an iterable of tiles or images.
dtype : numpy.dtype or None
Datatype of the empty or iterable data to save.
Use only if 'data' is None or an iterable of tiles or images.
photometric : {MINISBLACK, MINISWHITE, RGB, PALETTE, SEPARATED, CFA}
The color space of the image data according to TIFF.PHOTOMETRIC.
By default, this setting is inferred from the data shape and the
value of colormap.
For CFA images, the CFARepeatPatternDim, CFAPattern, and other
DNG or TIFF/EP tags must be specified in 'extratags' to produce a
valid file.
planarconfig : {CONTIG, SEPARATE}
Specifies if samples are stored interleaved 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 (or fourth) last dimension contains samples.
extrasamples : tuple of {UNSPECIFIED, ASSOCALPHA, UNASSALPHA}
Defines the interpretation of extra components in pixels.
UNSPECIFIED: no transparency information (default).
ASSOCALPHA: single, true transparency with pre-multiplied color.
UNASSALPHA: independent transparency masks.
volumetric : bool
If True, the SGI ImageDepth tag is used to save volumetric data
in one page. The volumetric format is not officially specified,
and few software can read it. OME and ImageJ formats are not
compatible with volumetric storage.
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 a tile depth is provided, the SGI ImageDepth and TileDepth
tags are used to save volumetric data.
Tiles cannot be used to write contiguous series, except if tile
matches the data shape.
contiguous : bool
If False (default), save data to a new series.
If True and the data and parameters are compatible with previous
saved ones (same shape, no compression, etc.), the image data
are stored contiguously after the previous one. In that case,
'photometric', 'planarconfig', and 'rowsperstrip' are ignored.
Metadata such as 'description', 'metadata', 'datetime', and
'extratags' are written to the first page of a contiguous series
only. Cannot be used with the OME or ImageJ formats.
truncate : bool
If True, only write the first page of a contiguous series if
possible (uncompressed, contiguous, not tiled).
Other TIFF readers will only be able to read part of the data.
Cannot be used with the OME or ImageJ formats.
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.
rowsperstrip : int
The number of rows per strip. By default, strips are ~64 KB if
compression is enabled, else rowsperstrip is set to the image
length.
bitspersample : int
Number of bits per sample. By default, this is the number of
bits of the data dtype. Different values for different samples
are not supported. Unsigned integer data are packed into bytes
as tightly as possible. Valid values are 1-8 for uint8, 9-16 for
uint16 and 17-32 for uint32. Cannot be used with compression,
contiguous series, or empty files.
compression : str, (str, int), (str, int, dict)
If None (default), data are written uncompressed.
If a str, one of TIFF.COMPESSORS, e.g. 'JPEG' or 'ZSTD'.
If a tuple, the first item is one of TIFF.COMPESSORS, the
second item is the compression level, and the third item is a dict
of arguments passed to the compression codec.
Compression cannot be used to write contiguous series.
Compressors may require certain data shapes, types or value ranges.
For example, JPEG requires grayscale or RGB(A), uint8 or 12-bit
uint16. JPEG compression is experimental. JPEG markers and TIFF
tags may not match.
predictor : bool or TIFF.PREDICTOR
If True, apply horizontal differencing or floating-point predictor
before compression. Predictors are disabled for 64-bit integers.
subsampling : {(1, 1), (2, 1), (2, 2), (4, 1)}
The horizontal and vertical subsampling factors used for the
chrominance components of images. The default is (2, 2).
Currently applies to JPEG compression of RGB images only.
Images are stored in YCbCr color space.
Segment widths must be a multiple of 8 times the horizontal factor.
Segment lengths and rowsperstrip must be a multiple of 8 times the
vertical factor.
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 or encoded bytes
The subject of the image. Must be 7-bit ASCII. Cannot be used with
the ImageJ or OME formats. Saved with the first page of a series
only.
datetime : datetime, str, or bool
Date and time of image creation in '%Y:%m:%d %H:%M:%S' format or
datetime object. Else if True, the current date and time is used.
Saved with the first page of a series 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'.
subfiletype : int
Bitfield to indicate the kind of data. Set bit 0 if the image
is a reduced-resolution version of another image. Set bit 1 if
the image is part of a multi-page image. Set bit 2 if the image
is transparency mask for another image (photometric must be
MASK, SamplesPerPixel and BitsPerSample must be 1).
software : str or bool
Name of the software used to create the file.
If None (default), 'tifffile.py'. Must be 7-bit ASCII.
Saved with the first page of a series only.
subifds : int
Number of child IFDs. If greater than 0, the following 'subifds'
number of series are written as child IFDs of the current
series. The number of IFDs written for each SubIFD level must match
the number of IFDs written for the current series. All pages
written to a certain SubIFD level of the current series must have
the same hash. SubIFDs cannot be used with truncated or ImageJ
files. SubIFDs in OME-TIFF files must be sub-resolutions of the
main IFDs.
metadata : dict
Additional metadata describing the image data, saved along with
shape information in JSON, OME-XML, or ImageJ formats in
ImageDescription or IJMetadata tags.
If None, do not write an ImageDescription tag with shape in JSON
format.
If ImageJ format, values for keys 'Info', 'Labels', 'Ranges',
'LUTs', 'Plot', 'ROI', and 'Overlays' are saved in IJMetadata and
IJMetadataByteCounts tags. Refer to the imagej_metadata_tag
function for valid values.
Refer to the OmeXml class for supported keys when writing OME-TIFF.
Strings must be 7-bit ASCII.
Saved with the first page of a series only.
extratags : sequence of tuples
Additional tags as [(code, dtype, count, value, writeonce)].
code : int
The TIFF tag Id.
dtype : int or str
Data type of items in 'value'. One of TIFF.DATATYPES.
count : int
Number of data values. Not used for string or bytes values.
value : sequence
'Count' values compatible with 'dtype'.
Bytes must contain count values of dtype packed as binary data.
writeonce : bool
If True, the tag is written to the first page of a series only.
returnoffset : bool
If True and the image data in the file are memory-mappable, return
the offset and number of bytes of the image data in the file.
Returns
-------
offset, bytecount : tuple or None
If 'returnoffset' is true and the image data in the file are
memory-mappable, return the offset and number of bytes of the
image data in the file.
"""
# TODO: refactor this function
fh = self._fh
byteorder = self.tiff.byteorder
if data is None:
# empty
dataiter = None
datashape = tuple(shape)
datadtype = numpy.dtype(dtype).newbyteorder(byteorder)
datadtypechar = datadtype.char
elif (
shape is not None
and dtype is not None
and hasattr(data, '__iter__')
):
# iterable pages or tiles
if hasattr(data, '__next__'):
dataiter = data
else:
dataiter = iter(data)
datashape = tuple(shape)
datadtype = numpy.dtype(dtype).newbyteorder(byteorder)
datadtypechar = datadtype.char
elif hasattr(data, '__next__'):
# generator
raise TypeError('generators require `shape` and `dtype`')
else:
# whole image data
# must be C-contiguous numpy array of TIFF byteorder
if hasattr(data, 'dtype'):
data = numpy.asarray(data, byteorder + data.dtype.char, 'C')
else:
datadtype = numpy.dtype(dtype).newbyteorder(byteorder)
data = numpy.asarray(data, datadtype, 'C')
if dtype is not None and dtype != data.dtype:
warnings.warn(
'TiffWriter: ignoring `dtype` argument', UserWarning
)
if shape is not None and shape != data.shape:
warnings.warn(
'TiffWriter: ignoring `shape` argument', UserWarning
)
dataiter = None
datashape = data.shape
datadtype = data.dtype
datadtypechar = data.dtype.char
returnoffset = returnoffset and datadtype.isnative
if compression is None and compress is not None:
# TODO: activate DeprecationWarning and update tests
# warnings.warn(
# "TiffWriter: the 'compress' parameter is deprecated",
# DeprecationWarning
# )
if isinstance(compress, (int, numpy.integer)) and compress > 0:
# ADOBE_DEFLATE
compression = 8, int(compress)
if not 0 < compress <= 9:
raise ValueError(f'invalid compression level {compress}')
else:
compression = compress
del compress
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
if datasize == 0:
data = None
compression = False
bitspersample = None
if metadata is not None:
truncate = True
elif compression in (None, 0, 1, 'NONE', 'none'):
compression = False
inputshape = datashape
packints = (
bitspersample is not None
and bitspersample != datadtype.itemsize * 8
)
# just append contiguous data if possible
if self._datashape is not None:
if (
not contiguous
or self._datashape[1:] != datashape
or self._datadtype != datadtype
or not numpy.array_equal(colormap, self._colormap)
):
# incompatible shape, dtype, or colormap
self._write_remaining_pages()
if self._imagej:
raise ValueError(
'ImageJ does not support non-contiguous series'
)
elif self._ome:
if self._subifdslevel < 0:
# add image to OME-XML
self._ome.addimage(
self._datadtype,
self._datashape[
0 if self._datashape[0] != 1 else 1 :
],
self._storedshape,
**self._metadata,
)
elif metadata is not None:
self._write_image_description()
# description might have been appended to file
fh.seek(0, os.SEEK_END)
if self._subifds:
if self._truncate or truncate:
raise ValueError(
'SubIFDs cannot be used with truncated series'
)
self._subifdslevel += 1
if self._subifdslevel == self._subifds:
# done with writing SubIFDs
self._nextifdoffsets = []
self._subifdsoffsets = []
self._subifdslevel = -1
self._subifds = 0
self._ifdindex = 0
elif subifds:
raise ValueError(
'SubIFDs in SubIFDs are not supported'
)
self._datashape = None
self._colormap = None
elif compression or packints or tile:
raise ValueError(
'contiguous cannot be used with compression, tiles, etc.'
)
else:
# consecutive mode
# write contiguous data, write IFDs/tags later
self._datashape = (self._datashape[0] + 1,) + datashape
offset = fh.tell()
if data is None:
fh.write_empty(datasize)
else:
fh.write_array(data)
if returnoffset:
return offset, datasize
return None
if self._ome is None:
if description is None:
self._ome = '.ome.tif' in fh.name
else:
self._ome = False
self._truncate = False if self._ome else bool(truncate)
if datasize == 0:
# write single placeholder TiffPage for arrays with size=0
datashape = (0, 0)
warnings.warn(
'TiffWriter: writing zero size array to nonconformant TIFF',
UserWarning,
)
# TODO: reconsider this
# raise ValueError('cannot save zero size array')
valueformat = f'{self.tiff.offsetsize}s'
tagnoformat = self.tiff.tagnoformat
offsetformat = self.tiff.offsetformat
offsetsize = self.tiff.offsetsize
tagsize = self.tiff.tagsize
MINISBLACK = TIFF.PHOTOMETRIC.MINISBLACK
MINISWHITE = TIFF.PHOTOMETRIC.MINISWHITE
RGB = TIFF.PHOTOMETRIC.RGB
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 predictor:
if not isinstance(predictor, bool):
predictor = bool(enumarg(TIFF.PREDICTOR, predictor))
if extrasamples is None:
extrasamples_ = None
else:
extrasamples_ = tuple(
enumarg(TIFF.EXTRASAMPLE, es) for es in sequence(extrasamples)
)
if compression:
if isinstance(compression, (tuple, list)):
if len(compression) == 2:
compressionargs = {'level': compression[1]}
else:
compressionargs = dict(compression[2])
if compression[1] is not None:
compressionargs['level'] = compression[1]
compression = compression[0]
else:
compressionargs = {}
if isinstance(compression, str):
compression = compression.upper()
if compression == 'ZLIB':
compression = 8 # ADOBE_DEFLATE
compressiontag = enumarg(TIFF.COMPRESSION, compression)
compression = True
else:
compression = False
compressiontag = 1
compressionargs = {}
predictor = False # TODO: support predictors without compression?
predictortag = 1
if predictor:
if compressiontag in (
7,
33003,
33005,
34712,
34892,
34933,
34934,
50001,
):
# disable predictor for JPEG, JPEG2000, WEBP, PNG, JPEGXR
predictor = False
elif datadtype.kind in 'iu':
if datadtype.itemsize > 4:
predictor = False # disable predictor for 64 bit
else:
predictortag = 2
predictor = TIFF.PREDICTORS[2]
elif datadtype.kind == 'f':
predictortag = 3
predictor = TIFF.PREDICTORS[3]
else:
raise ValueError(f'cannot apply predictor to {datadtype}')
if self._ome:
if description is not None:
warnings.warn(
'TiffWriter: not writing description to OME-TIFF',
UserWarning,
)
description = None
if not isinstance(self._ome, OmeXml):
self._ome = OmeXml(**metadata)
if volumetric or (tile and len(tile) > 2):
raise ValueError('OME-TIFF does not support ImageDepth')
volumetric = False
elif self._imagej:
# if tile is not None or predictor or compression:
# warnings.warn(
# 'ImageJ does not support tiles, predictors, compression'
# )
if description is not None:
warnings.warn(
'TiffWriter: not writing description to ImageJ file',
UserWarning,
)
description = None
if datadtypechar not in 'BHhf':
raise ValueError(
f'ImageJ does not support data type {datadtypechar!r}'
)
if volumetric or (tile and len(tile) > 2):
raise ValueError('ImageJ does not support ImageDepth')
volumetric = False
ijrgb = photometric == RGB if photometric else None
if datadtypechar not in 'B':
ijrgb = False
ijshape = imagej_shape(
datashape, ijrgb, metadata.get('axes', None)
)
if ijshape[-1] in (3, 4):
photometric = RGB
if datadtypechar not in 'B':
raise ValueError(
'ImageJ does not support '
f'data type {datadtypechar!r} for RGB'
)
elif photometric is None:
photometric = MINISBLACK
planarconfig = None
if planarconfig == SEPARATE:
raise ValueError('ImageJ does not support planar images')
planarconfig = CONTIG if ijrgb else None
# 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
if tile:
# verify tile shape
tile = tuple(int(i) for i in 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')
if volumetric and len(tile) == 2:
tile = (1,) + tile
volumetric = len(tile) == 3
else:
tile = ()
volumetric = bool(volumetric)
# normalize data shape to 5D or 6D, depending on volume:
# (pages, separate_samples, [depth,] length, width, contig_samples)
storedshape = reshape_nd(datashape, 3 if photometric == RGB else 2)
del datashape
shape = storedshape
ndim = len(storedshape)
samplesperpixel = 1
extrasamples = 0
if volumetric and ndim < 3:
volumetric = False
if colormap is not None:
photometric = PALETTE
planarconfig = None
if photometric is None:
photometric = MINISBLACK
if bilevel:
photometric = MINISWHITE
elif planarconfig == CONTIG:
if ndim > 2 and shape[-1] in (3, 4):
photometric = RGB
elif planarconfig == SEPARATE:
if volumetric 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
planarconfig = CONTIG
elif self._imagej or self._ome:
photometric = MINISBLACK
planarconfig = None
elif volumetric and ndim > 3 and shape[-4] in (3, 4):
# TODO: change this?
photometric = RGB
planarconfig = SEPARATE
elif ndim > 2 and shape[-3] in (3, 4):
# TODO: change this?
photometric = RGB
planarconfig = SEPARATE
photometricsamples = TIFF.PHOTOMETRIC_SAMPLES[photometric]
if planarconfig and len(shape) <= (3 if volumetric else 2):
# TODO: raise error?
planarconfig = None
if photometricsamples > 1:
photometric = MINISBLACK
if photometricsamples > 1:
if len(shape) < 3:
raise ValueError(f'not a {photometric!r} image')
if len(shape) < 4:
volumetric = False
if planarconfig is None:
if photometric == RGB:
samples_ = (photometricsamples, 4) # allow common alpha
else:
samples_ = (photometricsamples,)
if shape[-1] in samples_:
planarconfig = CONTIG
elif shape[-4 if volumetric else -3] in samples_:
planarconfig = SEPARATE
elif shape[-1] > shape[-4 if volumetric else -3]:
planarconfig = SEPARATE
else:
planarconfig = CONTIG
if planarconfig == CONTIG:
storedshape = (-1, 1) + shape[(-4 if volumetric else -3) :]
samplesperpixel = storedshape[-1]
else:
storedshape = (
(-1,) + shape[(-4 if volumetric else -3) :] + (1,)
)
samplesperpixel = storedshape[1]
if samplesperpixel > photometricsamples:
extrasamples = samplesperpixel - photometricsamples
elif photometric == TIFF.PHOTOMETRIC.CFA:
if len(shape) != 2:
raise ValueError('invalid CFA image')
volumetric = False
planarconfig = None
storedshape = (-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 volumetric else 2):
if planarconfig == CONTIG:
storedshape = (-1, 1) + shape[(-4 if volumetric else -3) :]
samplesperpixel = storedshape[-1]
else:
storedshape = (
(-1,) + shape[(-4 if volumetric else -3) :] + (1,)
)
samplesperpixel = storedshape[1]
extrasamples = samplesperpixel - 1
else:
planarconfig = None
while len(shape) > 2 and shape[-1] == 1:
shape = shape[:-1] # remove trailing 1s
if len(shape) < 3:
volumetric = False
if extrasamples_ is None:
storedshape = (
(-1, 1) + shape[(-3 if volumetric else -2) :] + (1,)
)
else:
storedshape = (-1, 1) + shape[(-4 if volumetric else -3) :]
samplesperpixel = storedshape[-1]
extrasamples = samplesperpixel - 1
if subfiletype & 0b100:
# FILETYPE_MASK
if not (
bilevel and samplesperpixel == 1 and photometric in (0, 1, 4)
):
raise ValueError('invalid SubfileType MASK')
photometric = TIFF.PHOTOMETRIC.MASK
packints = False
if bilevel:
if bitspersample is not None and bitspersample != 1:
raise ValueError('bitspersample must be 1 for bilevel')
bitspersample = 1
elif compressiontag == 7 and datadtype == 'uint16':
if bitspersample is not None and bitspersample != 12:
raise ValueError(
'bitspersample must be 12 for JPEG compressed uint16'
)
bitspersample = 12 # use 12-bit JPEG compression
elif bitspersample is None:
bitspersample = datadtype.itemsize * 8
elif (
datadtype.kind != 'u' or datadtype.itemsize > 4
) and bitspersample != datadtype.itemsize * 8:
raise ValueError('bitspersample does not match dtype')
elif not (
bitspersample > {1: 0, 2: 8, 4: 16}[datadtype.itemsize]
and bitspersample <= datadtype.itemsize * 8
):
raise ValueError('bitspersample out of range of dtype')
elif compression:
if bitspersample != datadtype.itemsize * 8:
raise ValueError(
'bitspersample cannot be used with compression'
)
elif bitspersample != datadtype.itemsize * 8:
packints = True
# normalize storedshape to 6D
if len(storedshape) not in (5, 6):
raise RuntimeError('len(storedshape) not in (5, 6)')
if len(storedshape) == 5:
storedshape = storedshape[:2] + (1,) + storedshape[2:]
if storedshape[0] == -1:
s0 = product(storedshape[1:])
s0 = 1 if s0 == 0 else product(inputshape) // s0
storedshape = (s0,) + storedshape[1:]
try:
data = data.reshape(storedshape)
except AttributeError:
pass # data is None or iterator
if photometric == PALETTE:
if (
samplesperpixel != 1
or extrasamples
or storedshape[1] != 1
or storedshape[-1] != 1
):
raise ValueError('invalid data shape for palette mode')
if photometric == RGB and samplesperpixel == 2:
raise ValueError('not a RGB image (samplesperpixel=2)')
tags = [] # list of (code, ifdentry, ifdvalue, writeonce)
if tile:
tagbytecounts = 325 # TileByteCounts
tagoffsets = 324 # TileOffsets
else:
tagbytecounts = 279 # StripByteCounts
tagoffsets = 273 # StripOffsets
self._dataoffsetstag = tagoffsets
def pack(fmt, *val):
if fmt[0] not in '<>':
fmt = byteorder + fmt
return struct.pack(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
if not isinstance(code, int):
code = TIFF.TAGS[code]
try:
datatype = dtype
dataformat = TIFF.DATA_FORMATS[datatype][-1]
except KeyError as exc:
try:
dataformat = dtype
if dataformat[0] in '<>':
dataformat = dataformat[1:]
datatype = TIFF.DATA_DTYPES[dataformat]
except (KeyError, TypeError):
raise ValueError(f'unknown dtype {dtype}') from exc
del dtype
rawcount = count
if datatype == 2:
# string
if isinstance(value, str):
# enforce 7-bit ASCII on Unicode strings
try:
value = value.encode('ascii')
except UnicodeEncodeError as exc:
raise ValueError(
'TIFF strings must be 7-bit ASCII'
) from exc
elif not isinstance(value, bytes):
raise ValueError('TIFF strings must be 7-bit ASCII')
if len(value) == 0 or value[-1] != b'\x00':
value += b'\x00'
count = len(value)
if code == 270:
self._descriptiontag = TiffTag(270, 2, count, None, 0, 0)
rawcount = value.find(b'\x00\x00')
if rawcount < 0:
rawcount = count
else:
# length of string without buffer
rawcount = max(offsetsize + 1, rawcount + 1)
rawcount = min(count, rawcount)
else:
rawcount = count
value = (value,)
elif isinstance(value, bytes):
# packed binary data
itemsize = struct.calcsize(dataformat)
if len(value) % itemsize:
raise ValueError('invalid packed binary data')
count = len(value) // itemsize
rawcount = count
if datatype in (5, 10): # rational
count *= 2
dataformat = dataformat[-1]
ifdentry = [
pack('HH', code, datatype),
pack(offsetformat, rawcount),
]
ifdvalue = None
if struct.calcsize(dataformat) * 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(dataformat, value)))
else:
ifdentry.append(
pack(valueformat, pack(f'{count}{dataformat}', *value))
)
else:
# use offset to value(s)
ifdentry.append(pack(offsetformat, 0))
if isinstance(value, bytes):
ifdvalue = value
elif isinstance(value, numpy.ndarray):
if value.size != count:
raise RuntimeError('value.size != count')
if value.dtype.char != dataformat:
raise RuntimeError('value.dtype.char != dtype')
ifdvalue = value.tobytes()
elif isinstance(value, (tuple, list)):
ifdvalue = pack(f'{count}{dataformat}', *value)
else:
ifdvalue = pack(dataformat, 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 is not None:
# ImageDescription: user provided description
addtag(270, 2, 0, description, writeonce=True)
# write shape and metadata to ImageDescription
self._metadata = {} if not metadata else metadata.copy()
if self._ome:
if len(self._ome.images) == 0:
description = '' # rewritten later at end of file
else:
description = None
elif self._imagej:
if ijmetadata is None:
ijmetadata = parse_kwargs(
self._metadata,
'Info',
'Labels',
'Ranges',
'LUTs',
'Plot',
'ROI',
'Overlays',
'info',
'labels',
'ranges',
'luts',
'plot',
'roi',
'overlays',
)
else:
# TODO: remove ijmetadata parameter and update tests
warnings.warn(
"TiffWriter: the 'ijmetadata' parameter is deprecated",
DeprecationWarning,
)
for t in imagej_metadata_tag(ijmetadata, byteorder):
addtag(*t)
description = imagej_description(
inputshape,
storedshape[-1] in (3, 4),
self._colormap is not None,
**self._metadata,
)
description += '\x00' * 64 # add buffer for in-place update
elif metadata or metadata == {}:
if self._truncate:
self._metadata.update(truncated=True)
description = json_description(inputshape, **self._metadata)
description += '\x00' * 16 # add buffer for in-place update
# elif metadata is None and self._truncate:
# raise ValueError('cannot truncate without writing metadata')
else:
description = None
if description is not None:
description = description.encode('ascii')
addtag(270, 2, 0, description, writeonce=True)
del description
if software is None:
software = 'tifffile.py'
if software:
addtag(305, 2, 0, software, writeonce=True)
if datetime:
if isinstance(datetime, str):
if len(datetime) != 19 or datetime[16] != ':':
raise ValueError('invalid datetime string')
else:
try:
datetime = datetime.strftime('%Y:%m:%d %H:%M:%S')
except AttributeError:
datetime = self._now().strftime('%Y:%m:%d %H:%M:%S')
addtag(306, 2, 0, datetime, writeonce=True)
addtag(259, 3, 1, compressiontag) # Compression
if compressiontag == 34887:
# LERC without additional compression
addtag(50674, 4, 2, (4, 0))
if predictor:
addtag(317, 3, 1, predictortag)
addtag(256, 4, 1, storedshape[-2]) # ImageWidth
addtag(257, 4, 1, storedshape[-3]) # ImageLength
if tile:
addtag(322, 4, 1, tile[-1]) # TileWidth
addtag(323, 4, 1, tile[-2]) # TileLength
if volumetric:
addtag(32997, 4, 1, storedshape[-4]) # ImageDepth
if tile:
addtag(32998, 4, 1, tile[0]) # TileDepth
if subfiletype:
addtag(254, 4, 1, subfiletype) # NewSubfileType
if (subifds or self._subifds) and self._subifdslevel < 0:
if self._subifds:
subifds = self._subifds
else:
try:
self._subifds = subifds = int(subifds)
except TypeError:
# allow TiffPage.subifds tuple
self._subifds = subifds = len(subifds)
addtag(330, 18 if offsetsize > 4 else 13, subifds, [0] * subifds)
if not bilevel and not datadtype.kind == 'u':
sampleformat = {'u': 1, 'i': 2, 'f': 3, 'c': 6}[datadtype.kind]
addtag(339, 3, samplesperpixel, (sampleformat,) * samplesperpixel)
if colormap is not None:
addtag(320, 3, colormap.size, colormap)
addtag(277, 3, 1, samplesperpixel)
if bilevel:
pass
elif planarconfig and samplesperpixel > 1:
addtag(284, 3, 1, planarconfig.value) # PlanarConfiguration
addtag( # BitsPerSample
258, 3, samplesperpixel, (bitspersample,) * samplesperpixel
)
else:
addtag(258, 3, 1, bitspersample)
if extrasamples:
if extrasamples_ is not None:
if extrasamples != len(extrasamples_):
raise ValueError('wrong number of extrasamples specified')
addtag(338, 3, extrasamples, extrasamples_)
elif photometric == RGB and extrasamples == 1:
# Unassociated alpha channel
addtag(338, 3, 1, 2)
else:
# Unspecified alpha channel
addtag(338, 3, extrasamples, (0,) * extrasamples)
if compressiontag == 7 and photometric == RGB and planarconfig == 1:
# JPEG compression with subsampling. Store as YCbCr
# TODO: use JPEGTables for multiple tiles or strips
if subsampling is None:
subsampling = (2, 2)
elif subsampling not in ((1, 1), (2, 1), (2, 2), (4, 1)):
raise ValueError('invalid subsampling factors')
maxsampling = max(subsampling) * 8
if tile and (tile[-1] % maxsampling or tile[-2] % maxsampling):
raise ValueError(f'tile shape not a multiple of {maxsampling}')
if extrasamples > 1:
raise ValueError('JPEG subsampling requires RGB(A) images')
addtag(530, 3, 2, subsampling) # YCbCrSubSampling
addtag(262, 3, 1, 6) # PhotometricInterpretation YCBCR
# ReferenceBlackWhite is required for YCBCR
addtag(532, 5, 6, (0, 1, 255, 1, 128, 1, 255, 1, 128, 1, 255, 1))
else:
if subsampling not in (None, (1, 1)):
log_warning('TiffWriter: cannot apply subsampling')
subsampling = None
maxsampling = 1
# PhotometricInterpretation
addtag(262, 3, 1, photometric.value)
# if compresstag == 7:
# addtag(530, 3, 2, (1, 1)) # YCbCrSubSampling
if resolution is not None:
addtag(282, 5, 1, rational(resolution[0])) # XResolution
addtag(283, 5, 1, rational(resolution[1])) # YResolution
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(296, 3, 1, unit) # ResolutionUnit
elif not self._imagej:
addtag(282, 5, 1, (1, 1)) # XResolution
addtag(283, 5, 1, (1, 1)) # YResolution
addtag(296, 3, 1, 1) # ResolutionUnit
def bytecount_format(
bytecounts, compression=compression, size=offsetsize
):
# return small bytecount format
if len(bytecounts) == 1:
return {4: 'I', 8: 'Q'}[size]
bytecount = bytecounts[0]
if compression:
bytecount = bytecount * 10
if bytecount < 2 ** 16:
return 'H'
if bytecount < 2 ** 32:
return 'I'
if size == 4:
return 'I'
return 'Q'
# can save data array contiguous
contiguous = not (compression or packints or bilevel)
if tile:
# one chunk per tile per plane
if len(tile) == 2:
tiles = (
(storedshape[3] + tile[0] - 1) // tile[0],
(storedshape[4] + tile[1] - 1) // tile[1],
)
contiguous = (
contiguous
and storedshape[3] == tile[0]
and storedshape[4] == tile[1]
)
else:
tiles = (
(storedshape[2] + tile[0] - 1) // tile[0],
(storedshape[3] + tile[1] - 1) // tile[1],
(storedshape[4] + tile[2] - 1) // tile[2],
)
contiguous = (
contiguous
and storedshape[2] == tile[0]
and storedshape[3] == tile[1]
and storedshape[4] == tile[2]
)
numtiles = product(tiles) * storedshape[1]
databytecounts = [
product(tile) * storedshape[-1] * datadtype.itemsize
] * numtiles
bytecountformat = bytecount_format(databytecounts)
addtag(tagbytecounts, bytecountformat, numtiles, databytecounts)
addtag(tagoffsets, offsetformat, numtiles, [0] * numtiles)
bytecountformat = bytecountformat * numtiles
if contiguous or dataiter is not None:
pass
else:
dataiter = iter_tiles(data, tile, tiles)
elif contiguous and rowsperstrip is None:
count = storedshape[1] * storedshape[2]
databytecounts = [
product(storedshape[3:]) * datadtype.itemsize
] * count
bytecountformat = bytecount_format(databytecounts)
addtag(tagbytecounts, bytecountformat, count, databytecounts)
addtag(tagoffsets, offsetformat, count, [0] * count)
addtag(278, 4, 1, storedshape[-3]) # RowsPerStrip
bytecountformat = bytecountformat * storedshape[1]
if contiguous or dataiter is not None:
pass
else:
dataiter = iter_images(data)
else:
# use rowsperstrip
rowsize = product(storedshape[-2:]) * datadtype.itemsize
if rowsperstrip is None:
# compress ~64 KB chunks by default
if compression:
rowsperstrip = 65536 // rowsize
else:
rowsperstrip = storedshape[-3]
if rowsperstrip < 1:
rowsperstrip = maxsampling
elif rowsperstrip > storedshape[-3]:
rowsperstrip = storedshape[-3]
elif subsampling and rowsperstrip % maxsampling:
rowsperstrip = (
math.ceil(rowsperstrip / maxsampling) * maxsampling
)
addtag(278, 4, 1, rowsperstrip) # RowsPerStrip
numstrips1 = (storedshape[-3] + rowsperstrip - 1) // rowsperstrip
numstrips = numstrips1 * storedshape[1] * storedshape[2]
# TODO: save bilevel data with rowsperstrip
stripsize = rowsperstrip * rowsize
databytecounts = [stripsize] * numstrips
stripsize -= rowsize * (
numstrips1 * rowsperstrip - storedshape[-3]
)
for i in range(numstrips1 - 1, numstrips, numstrips1):
databytecounts[i] = stripsize
bytecountformat = bytecount_format(databytecounts)
addtag(tagbytecounts, bytecountformat, numstrips, databytecounts)
addtag(tagoffsets, offsetformat, numstrips, [0] * numstrips)
bytecountformat = bytecountformat * numstrips
if contiguous or dataiter is not None:
pass
else:
dataiter = iter_images(data)
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])
# define compress function
if bilevel:
if compressiontag == 1:
def compress(data, level=None):
return numpy.packbits(data, axis=-2).tobytes()
elif compressiontag in (5, 32773):
# LZW, PackBits
def compress(
data,
compressor=TIFF.COMPESSORS[compressiontag],
kwargs=compressionargs,
):
data = numpy.packbits(data, axis=-2).tobytes()
return compressor(data, **kwargs)
else:
raise ValueError('cannot compress bilevel image')
elif compression:
compressor = TIFF.COMPESSORS[compressiontag]
if subsampling:
# JPEG with subsampling. Store RGB as YCbCr
def compress(
data,
compressor=compressor,
subsampling=subsampling,
kwargs=compressionargs,
):
return compressor(
data,
subsampling=subsampling,
colorspace=2,
outcolorspace=3,
**kwargs,
)
elif predictor:
def compress(
data,
predictor=predictor,
compressor=compressor,
kwargs=compressionargs,
):
data = predictor(data, axis=-2)
return compressor(data, **kwargs)
elif compressionargs:
def compress(
data, compressor=compressor, kwargs=compressionargs
):
return compressor(data, **kwargs)
else:
compress = compressor
elif packints:
def compress(data, bps=bitspersample):
return packints_encode(data, bps, axis=-2)
else:
compress = False
del compression
fhpos = fh.tell()
if (
not (offsetsize > 4 or self._imagej or compress)
and fhpos + datasize > 2 ** 32 - 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 storedshape[0]):
ifdpos = fhpos
if ifdpos % 2:
# location of IFD must begin on a word boundary
fh.write(b'\x00')
ifdpos += 1
if self._subifdslevel < 0:
# update pointer at ifdoffset
fh.seek(self._ifdoffset)
fh.write(pack(offsetformat, ifdpos))
fh.seek(ifdpos)
# create IFD in memory
if pageindex < 2:
subifdsoffsets = None
ifd = io.BytesIO()
ifd.write(pack(tagnoformat, len(tags)))
tagoffset = ifd.tell()
ifd.write(b''.join(t[1] for t in tags))
ifdoffset = ifd.tell()
ifd.write(pack(offsetformat, 0)) # offset to next IFD
# write tag values and patch offsets in ifdentries
for tagindex, tag in enumerate(tags):
offset = tagoffset + tagindex * tagsize + 4 + offsetsize
code = tag[0]
value = tag[2]
if value:
pos = ifd.tell()
if pos % 2:
# tag value is expected to begin on word boundary
ifd.write(b'\x00')
pos += 1
ifd.seek(offset)
ifd.write(pack(offsetformat, ifdpos + pos))
ifd.seek(pos)
ifd.write(value)
if code == tagoffsets:
dataoffsetsoffset = offset, pos
elif code == tagbytecounts:
databytecountsoffset = offset, pos
elif code == 270:
self._descriptiontag.offset = (
ifdpos + tagoffset + tagindex * tagsize
)
self._descriptiontag.valueoffset = ifdpos + pos
elif code == 330:
subifdsoffsets = offset, pos
elif code == tagoffsets:
dataoffsetsoffset = offset, None
elif code == tagbytecounts:
databytecountsoffset = offset, None
elif code == 270:
self._descriptiontag.offset = (
ifdpos + tagoffset + tagindex * tagsize
)
self._descriptiontag.valueoffset = (
self._descriptiontag.offset + offsetsize + 4
)
elif code == 330:
subifdsoffsets = offset, None
ifdsize = ifd.tell()
if ifdsize % 2:
ifd.write(b'\x00')
ifdsize += 1
# write IFD later when strip/tile bytecounts and offsets are known
fh.seek(ifdsize, os.SEEK_CUR)
# write image data
dataoffset = fh.tell()
if align is None:
align = 16
skip = (align - (dataoffset % align)) % align
fh.seek(skip, os.SEEK_CUR)
dataoffset += skip
if contiguous:
if data is None:
fh.write_empty(datasize)
elif dataiter is not None:
for pagedata in dataiter:
if pagedata.dtype != datadtype:
raise ValueError(
'dtype of iterable does not match dtype'
)
fh.write_array(pagedata.reshape(storedshape[1:]))
else:
fh.write_array(data)
elif tile:
if storedshape[-1] == 1:
tileshape = tile
else:
tileshape = tile + (storedshape[-1],)
tilesize = product(tileshape) * datadtype.itemsize
if data is None:
fh.write_empty(numtiles * tilesize)
elif compress:
isbytes = True
for tileindex in range(storedshape[1] * product(tiles)):
chunk = next(dataiter)
if chunk is None:
databytecounts[tileindex] = 0
continue
if isbytes and isinstance(chunk, bytes):
# pre-compressed
pass
else:
if chunk.nbytes != tilesize:
chunk = pad_tile(chunk, tileshape, datadtype)
isbytes = False
chunk = compress(chunk)
fh.write(chunk)
databytecounts[tileindex] = len(chunk)
else:
for tileindex in range(storedshape[1] * product(tiles)):
chunk = next(dataiter)
if chunk is None:
# databytecounts[tileindex] = 0 # not contiguous
fh.write_empty(tilesize)
continue
if chunk.nbytes != tilesize:
chunk = pad_tile(chunk, tileshape, datadtype)
fh.write_array(chunk)
elif compress:
# write one strip per rowsperstrip
numstrips = (
storedshape[-3] + rowsperstrip - 1
) // rowsperstrip
stripindex = 0
pagedata = next(dataiter).reshape(storedshape[1:])
if pagedata.dtype != datadtype:
raise ValueError('dtype of iterable does not match dtype')
for plane in pagedata:
for depth in plane:
for i in range(numstrips):
strip = depth[
i * rowsperstrip : (i + 1) * rowsperstrip
]
strip = compress(strip)
fh.write(strip)
databytecounts[stripindex] = len(strip)
stripindex += 1
else:
pagedata = next(dataiter).reshape(storedshape[1:])
if pagedata.dtype != datadtype:
raise ValueError('dtype of iterable does not match dtype')
fh.write_array(pagedata)
# update strip/tile offsets
offset, pos = dataoffsetsoffset
ifd.seek(offset)
if pos:
ifd.write(pack(offsetformat, ifdpos + pos))
ifd.seek(pos)
offset = dataoffset
for size in databytecounts:
ifd.write(pack(offsetformat, offset))
offset += size
else:
ifd.write(pack(offsetformat, dataoffset))
if compress:
# update strip/tile bytecounts
offset, pos = databytecountsoffset
ifd.seek(offset)
if pos:
ifd.write(pack(offsetformat, ifdpos + pos))
ifd.seek(pos)
ifd.write(pack(bytecountformat, *databytecounts))
if subifdsoffsets is not None:
# update and save pointer to SubIFDs tag values if necessary
offset, pos = subifdsoffsets
if pos is not None:
ifd.seek(offset)
ifd.write(pack(offsetformat, ifdpos + pos))
self._subifdsoffsets.append(ifdpos + pos)
else:
self._subifdsoffsets.append(ifdpos + offset)
fhpos = fh.tell()
fh.seek(ifdpos)
fh.write(ifd.getbuffer())
fh.flush()
if self._subifdslevel < 0:
self._ifdoffset = ifdpos + ifdoffset
else:
# update SubIFDs tag values
fh.seek(
self._subifdsoffsets[self._ifdindex]
+ self._subifdslevel * offsetsize
)
fh.write(pack(offsetformat, ifdpos))
# update SubIFD chain offsets
if self._subifdslevel == 0:
self._nextifdoffsets.append(ifdpos + ifdoffset)
else:
fh.seek(self._nextifdoffsets[self._ifdindex])
fh.write(pack(offsetformat, ifdpos))
self._nextifdoffsets[self._ifdindex] = ifdpos + ifdoffset
self._ifdindex += 1
self._ifdindex %= len(self._subifdsoffsets)
fh.seek(fhpos)
# remove tags that should be written only once
if pageindex == 0:
tags = [tag for tag in tags if not tag[-1]]
self._storedshape = storedshape
self._datashape = (1,) + inputshape
self._datadtype = datadtype
self._dataoffset = dataoffset
self._databytecounts = databytecounts
if contiguous:
# write remaining IFDs/tags later
self._tags = tags
# return offset and size of image data
if returnoffset:
return dataoffset, sum(databytecounts)
return None
def overwrite_description(self, description):
"""Overwrite the value of the last ImageDescription tag.
Can be used to write OME-XML after writing the image data.
Ends a contiguous series.
"""
if self._descriptiontag is None:
raise ValueError('no ImageDescription tag found')
self._write_remaining_pages()
self._descriptiontag.overwrite(self, description, erase=False)
self._descriptiontag = None
def _write_remaining_pages(self):
"""Write outstanding IFDs and tags to file."""
if not self._tags or self._truncate or self._datashape is None:
return
pageno = self._storedshape[0] * self._datashape[0] - 1
if pageno < 1:
self._tags = None
self._dataoffset = None
self._databytecounts = None
return
fh = self._fh
fhpos = fh.tell()
if fhpos % 2:
fh.write(b'\x00')
fhpos += 1
pack = struct.pack
offsetformat = self.tiff.offsetformat
offsetsize = self.tiff.offsetsize
tagnoformat = self.tiff.tagnoformat
tagsize = self.tiff.tagsize
dataoffset = self._dataoffset
pagedatasize = sum(self._databytecounts)
subifdsoffsets = None
# construct template IFD in memory
# must patch offsets to next IFD and data before writing to file
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):
offset = tagoffset + tagindex * tagsize + offsetsize + 4
code = tag[0]
value = tag[2]
if value:
pos = ifd.tell()
if pos % 2:
# tag value is expected to begin on word boundary
ifd.write(b'\x00')
pos += 1
ifd.seek(offset)
try:
ifd.write(pack(offsetformat, fhpos + pos))
except Exception: # struct.error
if self._imagej:
warnings.warn(
'TiffWriter: truncating ImageJ file', UserWarning
)
self._truncate = True
return
raise ValueError('data too large for non-BigTIFF file')
ifd.seek(pos)
ifd.write(value)
if code == self._dataoffsetstag:
# save strip/tile offsets for later updates
dataoffsetsoffset = offset, pos
elif code == 330:
# save subifds offsets for later updates
subifdsoffsets = offset, pos
elif code == self._dataoffsetstag:
dataoffsetsoffset = offset, None
elif code == 330:
subifdsoffsets = offset, None
ifdsize = ifd.tell()
if ifdsize % 2:
ifd.write(b'\x00')
ifdsize += 1
# check if all IFDs fit in file
if offsetsize < 8 and fhpos + ifdsize * pageno > 2 ** 32 - 32:
if self._imagej:
warnings.warn(
'TiffWriter: truncating ImageJ file', UserWarning
)
self._truncate = True
return
raise ValueError('data too large for non-BigTIFF file')
# assemble IFD chain in memory from IFD template
ifds = io.BytesIO(bytes(ifdsize * pageno))
ifdpos = fhpos
for _ in range(pageno):
# update strip/tile offsets in IFD
dataoffset += pagedatasize # offset to image data
offset, pos = dataoffsetsoffset
ifd.seek(offset)
if pos is not None:
ifd.write(pack(offsetformat, ifdpos + pos))
ifd.seek(pos)
offset = dataoffset
for size in self._databytecounts:
ifd.write(pack(offsetformat, offset))
offset += size
else:
ifd.write(pack(offsetformat, dataoffset))
if subifdsoffsets is not None:
offset, pos = subifdsoffsets
self._subifdsoffsets.append(
ifdpos + (pos if pos is not None else offset)
)
if self._subifdslevel < 0:
if subifdsoffsets is not None:
# update pointer to SubIFDs tag values if necessary
offset, pos = subifdsoffsets
if pos is not None:
ifd.seek(offset)
ifd.write(pack(offsetformat, ifdpos + pos))
# update pointer at ifdoffset to point to next IFD in file
ifdpos += ifdsize
ifd.seek(ifdoffset)
ifd.write(pack(offsetformat, ifdpos))
else:
# update SubIFDs tag values in file
fh.seek(
self._subifdsoffsets[self._ifdindex]
+ self._subifdslevel * offsetsize
)
fh.write(pack(offsetformat, ifdpos))
# update SubIFD chain
if self._subifdslevel == 0:
self._nextifdoffsets.append(ifdpos + ifdoffset)
else:
fh.seek(self._nextifdoffsets[self._ifdindex])
fh.write(pack(offsetformat, ifdpos))
self._nextifdoffsets[self._ifdindex] = ifdpos + ifdoffset
self._ifdindex += 1
self._ifdindex %= len(self._subifdsoffsets)
ifdpos += ifdsize
# write IFD entry
ifds.write(ifd.getbuffer())
# terminate IFD chain
ifdoffset += ifdsize * (pageno - 1)
ifds.seek(ifdoffset)
ifds.write(pack(offsetformat, 0))
# write IFD chain to file
fh.seek(fhpos)
fh.write(ifds.getbuffer())
if self._subifdslevel < 0:
# update file to point to new IFD chain
pos = fh.tell()
fh.seek(self._ifdoffset)
fh.write(pack(offsetformat, fhpos))
fh.flush()
fh.seek(pos)
self._ifdoffset = fhpos + ifdoffset
self._tags = None
self._dataoffset = None
self._databytecounts = None
# do not reset _storedshape, _datashape, _datadtype
def _write_image_description(self):
"""Write metadata to ImageDescription tag."""
if self._datashape is None or self._descriptiontag is None:
self._descriptiontag = None
return
if self._ome:
if self._subifdslevel < 0:
self._ome.addimage(
self._datadtype,
self._datashape[0 if self._datashape[0] != 1 else 1 :],
self._storedshape,
**self._metadata,
)
description = self._ome.tostring(declaration=True)
elif self._datashape[0] == 1:
# description already up-to-date
self._descriptiontag = None
return
# elif self._subifdslevel >= 0:
# # don't write metadata to SubIFDs
# return
elif self._imagej:
colormapped = self._colormap is not None
isrgb = self._storedshape[-1] in (3, 4)
description = imagej_description(
self._datashape, isrgb, colormapped, **self._metadata
)
else:
description = json_description(self._datashape, **self._metadata)
self._descriptiontag.overwrite(self, description, erase=False)
self._descriptiontag = None
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:
"""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.
TiffFile instances are not thread-safe.
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.
is_flag : bool
If True, file is of a certain format.
Flags are: bigtiff, uniform, shaped, ome, imagej, stk, lsm, fluoview,
nih, vista, micromanager, metaseries, mdgel, mediacy, tvips, fei,
sem, scn, svs, scanimage, andor, epics, ndpi, pilatus, qpi.
All attributes are read-only.
"""
def __init__(
self,
arg,
mode=None,
name=None,
offset=None,
size=None,
_multifile=True,
_useframes=None,
_master=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().
mode : str
File open mode in case 'arg' is a file name. Must be 'rb' or 'r+b'.
Default is 'rb'.
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.
kwargs : bool
'is_ome': If False, disable processing of OME-XML metadata.
"""
if kwargs:
for key in ('fastij', 'movie', 'multifile', 'multifile_close'):
if key in kwargs:
del kwargs[key]
warnings.warn(
f'TiffFile: the {key!r} argument is ignored',
DeprecationWarning,
)
if 'pages' in kwargs:
raise TypeError(
"the TiffFile 'pages' parameter is no longer supported."
"\n\nUse TiffFile.asarray(key=[...]) to read image data "
"from specific pages.\n"
)
for key, value in kwargs.items():
if key[:3] == 'is_' and key[3:] in TIFF.FILE_FLAGS:
if value is not None:
setattr(self, key, bool(value))
else:
raise TypeError(f'unexpected keyword argument: {key}')
if mode not in (None, 'rb', 'r+b'):
raise ValueError(f'invalid mode {mode!r}')
fh = FileHandle(arg, mode=mode, name=name, offset=offset, size=size)
self._fh = fh
self._multifile = bool(_multifile)
self._files = {fh.name: self} # cache of TiffFile instances
self._decoders = {} # cache of TiffPage.decode functions
self._master = self if _master is None else _master
try:
fh.seek(0)
header = fh.read(4)
try:
byteorder = {b'II': '<', b'MM': '>', b'EP': '<'}[header[:2]]
except KeyError:
raise TiffFileError('not a TIFF file')
version = struct.unpack(byteorder + 'H', header[2:4])[0]
if version == 43:
# BigTiff
offsetsize, zero = struct.unpack(byteorder + 'HH', fh.read(4))
if zero != 0 or offsetsize != 8:
raise TiffFileError('invalid BigTIFF file')
if byteorder == '>':
self.tiff = TIFF.BIG_BE
else:
self.tiff = TIFF.BIG_LE
elif version == 42:
# Classic TIFF
if byteorder == '>':
self.tiff = TIFF.CLASSIC_BE
elif kwargs.get('is_ndpi', False) or fh.name.endswith('ndpi'):
# NDPI uses 64 bit IFD offsets
self.tiff = TIFF.NDPI_LE
else:
self.tiff = TIFF.CLASSIC_LE
elif version == 0x55 or version == 0x4F52 or version == 0x5352:
# Panasonic or Olympus RAW
log_warning(f'RAW format 0x{version:04X} not supported')
if byteorder == '>':
self.tiff = TIFF.CLASSIC_BE
else:
self.tiff = TIFF.CLASSIC_LE
else:
raise TiffFileError(f'invalid TIFF version {version}')
# 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()
elif self.is_scanimage and not self.is_bigtiff:
# ScanImage <= 2015
try:
self.pages._load_virtual_frames()
except Exception as exc:
log_warning(
f'load_virtual_frames: {exc.__class__.__name__}: {exc}'
)
elif self.is_philips:
try:
self._philips_load_pages()
except Exception as exc:
log_warning(
f'philips_load_pages: {exc.__class__.__name__}: {exc}'
)
elif _useframes:
self.pages.useframes = True
except Exception:
fh.close()
raise
@property
def byteorder(self):
return self.tiff.byteorder
@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()
def asarray(
self,
key=None,
series=None,
level=None,
squeeze=None,
out=None,
maxworkers=None,
):
"""Return image data from selected TIFF page(s) as numpy array.
By default, the data from the first series is returned.
Parameters
----------
key : int, slice, or sequence of indices
Defines which pages to return as array.
If None (default), data from a series (default 0) is returned.
If not None, data from the specified pages in the whole file
(if 'series' is None) or a specified series are returned as a
stacked array.
Requesting an array from multiple pages that are not compatible
wrt. shape, dtype, compression etc. is undefined, i.e. may crash
or return incorrect values.
series : int or TiffPageSeries
Defines which series of pages to return as array.
level : int
Defines which pyramid level of a series to return as array.
squeeze : bool
If True, all length-1 dimensions (except X and Y) are squeezed
out from the array.
If False, single pages are returned as 5D array (TiffPage.shaped).
For series, the shape of the returned array also includes singlet
dimensions specified in some file formats. E.g. ImageJ series, and
most commonly also OME series, are returned in TZCYXS order.
If None (default), all but "shaped" series are squeezed.
out : numpy.ndarray, str, or file-like object
Buffer where image data are saved.
If None (default), a new array is 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.
maxworkers : int or None
Maximum number of threads to concurrently get data from multiple
pages or compressed segments.
If None (default), up to half the CPU cores are used.
If 1, multi-threading is disabled.
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 or JPEG compressed tiled slides.
If the bottleneck is I/O or pure Python code, using multiple
threads might be detrimental.
Returns
-------
numpy.ndarray
Image data from the specified pages.
See TiffPage.asarray for operations that are applied (or not)
to the raw data stored in the file.
"""
if not self.pages:
return numpy.array([])
if key is None and series is None:
series = 0
if series is None:
pages = self.pages
else:
try:
series = self.series[series]
except (KeyError, TypeError):
pass
if level is not None:
series = series.levels[level]
pages = series.pages
if key is None:
pass
elif series is None:
pages = self.pages._getlist(key)
elif isinstance(key, (int, numpy.integer)):
pages = [pages[key]]
elif isinstance(key, slice):
pages = pages[key]
elif isinstance(key, 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 key is None and series and series.offset:
typecode = self.byteorder + series.dtype.char
if (
pages[0].is_memmappable
and isinstance(out, str)
and out == 'memmap'
):
# direct mapping
shape = series.get_shape(squeeze)
result = self.filehandle.memmap_array(
typecode, shape, series.offset
)
else:
# read into output
shape = series.get_shape(squeeze)
if out is not None:
out = create_output(out, shape, series.dtype)
self.filehandle.seek(series.offset)
result = self.filehandle.read_array(
typecode, product(shape), out=out
)
elif len(pages) == 1:
result = pages[0].asarray(out=out, maxworkers=maxworkers)
else:
result = stack_pages(pages, out=out, maxworkers=maxworkers)
if result is None:
return None
if key is None:
shape = series.get_shape(squeeze)
try:
result.shape = shape
except ValueError:
try:
log_warning(
'TiffFile.asarray: '
f'failed to reshape {result.shape} to {shape}'
)
# try series of expected shapes
result.shape = (-1,) + shape
except ValueError:
# revert to generic shape
result.shape = (-1,) + pages[0].shape
elif len(pages) == 1:
if squeeze is None:
squeeze = True
result.shape = pages[0].shape if squeeze else pages[0].shaped
else:
if squeeze is None:
squeeze = True
result.shape = (-1,) + (
pages[0].shape if squeeze else pages[0].shaped
)
return result
def aszarr(self, key=None, series=None, level=None, **kwargs):
"""Return image data from selected TIFF page(s) as zarr storage."""
if not self.pages:
raise NotImplementedError('empty zarr arrays not supported')
if key is None and series is None:
return self.series[0].aszarr(level=level, **kwargs)
if series is None:
pages = self.pages
else:
try:
series = self.series[series]
except (KeyError, TypeError):
pass
if key is None:
return series.aszarr(level=level, **kwargs)
pages = series.pages
if isinstance(key, (int, numpy.integer)):
return pages[key].aszarr(**kwargs)
raise TypeError('key must be an integer index')
@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.index
series = []
for name in (
'shaped',
'lsm',
'ome',
'imagej',
'fluoview',
'stk',
'sis',
'svs',
'scn',
'qpi',
'ndpi',
'scanimage',
'mdgel', # adds second page to cache
'uniform',
):
if getattr(self, 'is_' + name, False):
series = getattr(self, '_series_' + name)()
if not series and name == 'ome' and self.is_imagej:
# try ImageJ series if OME series fails.
# clear pages cache since _series_ome() might leave some
# frames without keyframe
self.pages._clear()
continue
break
self.pages.useframes = useframes
self.pages.keyframe = keyframe
if not series:
series = self._series_generic()
# remove empty series, e.g. in MD Gel files
# series = [s for s in series if product(s.shape) > 0]
for i, s in enumerate(series):
s.index = i
return series
def _series_uniform(self):
"""Return all images in file as single series."""
page = self.pages[0]
validate = not (page.is_scanimage or page.is_nih)
pages = self.pages._getlist(validate=validate)
shape = (len(pages),) + page.shape
axes = 'I' + page.axes
dtype = page.dtype
if page.is_nih:
kind = 'NIHImage'
else:
kind = 'Uniform'
return [TiffPageSeries(pages, shape, dtype, axes, kind=kind)]
def _series_generic(self):
"""Return image series in file.
A series is a sequence of TiffPages with the same hash.
"""
pages = self.pages
pages._clear(False)
pages.useframes = False
if pages.cache:
pages._load()
series = []
keys = []
seriesdict = {}
def addpage(page):
# add page to seriesdict
if not page.shape: # or product(page.shape) == 0:
return
key = page.hash
if key in seriesdict:
for p in seriesdict[key]:
if p.offset == page.offset:
break # remove duplicate page
else:
seriesdict[key].append(page)
else:
keys.append(key)
seriesdict[key] = [page]
for page in pages:
addpage(page)
if page.subifds is not None:
for i, offset in enumerate(page.subifds):
if offset < 8:
continue
try:
self._fh.seek(offset)
subifd = TiffPage(self, (page.index, i))
except Exception as exc:
log_warning(
f'Generic series: {exc.__class__.__name__}: {exc}'
)
else:
addpage(subifd)
for key in keys:
pages = seriesdict[key]
page = pages[0]
shape = (len(pages),) + page.shape
axes = 'I' + page.axes
if 'S' not in axes:
shape += (1,)
axes += 'S'
series.append(
TiffPageSeries(pages, shape, page.dtype, axes, kind='Generic')
)
self.is_uniform = len(series) == 1
pyramidize_series(series)
return series
def _series_shaped(self):
"""Return image series in "shaped" file."""
def append(series, pages, axes, shape, reshape, name, truncated):
# append TiffPageSeries to series
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 exc:
log_warning(f'Shaped series: {exc.__class__.__name__}: {exc}')
series.append(
TiffPageSeries(
pages,
shape,
page.dtype,
axes,
name=name,
kind='Shaped',
truncated=truncated,
squeeze=False,
)
)
def detect_series(pages, series, issubifds=False):
lenpages = len(pages)
keyframe = axes = shape = reshape = name = None
index = 0
while True:
if index >= lenpages:
break
if issubifds:
keyframe = pages[0]
else:
# new keyframe; start of new series
pages.keyframe = index
keyframe = pages.keyframe
if not keyframe.is_shaped:
log_warning(
'Shaped series: invalid metadata or corrupted file'
)
return None
# read metadata
axes = None
shape = None
metadata = json_description_metadata(keyframe.is_shaped)
name = metadata.get('name', '')
reshape = metadata['shape']
truncated = None if keyframe.subifds is None else False
truncated = metadata.get('truncated', truncated)
if 'axes' in metadata:
axes = metadata['axes']
if len(axes) == len(reshape):
shape = reshape
else:
axes = ''
log_warning('Shaped series: axes do not match shape')
# skip pages if possible
spages = [keyframe]
size = product(reshape)
if size > 0:
npages, mod = divmod(size, product(keyframe.shape))
else:
npages = 1
mod = 0
if mod:
log_warning(
'Shaped series: series shape does not match page shape'
)
return None
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
and keyframe.subifds is None
):
truncated = False
else:
# must 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, spages, axes, shape, reshape, name, truncated)
index += npages
# create series from SubIFDs
if keyframe.subifds:
for i, offset in enumerate(keyframe.subifds):
if offset < 8:
continue
subifds = []
for j, page in enumerate(spages):
# if page.subifds is not None:
try:
self._fh.seek(page.subifds[i])
if j == 0:
subifd = TiffPage(self, (page.index, i))
keysubifd = subifd
else:
subifd = TiffFrame(
self,
(page.index, i),
keyframe=keysubifd,
)
except Exception as exc:
log_warning(
f'Generic series: {exc.__class__.__name__}'
f': {exc}'
)
return None
subifds.append(subifd)
if subifds:
series = detect_series(subifds, series, True)
if series is None:
return None
return series
self.pages.useframes = True
series = detect_series(self.pages, [])
if series is None:
return None
self.is_uniform = len(series) == 1
pyramidize_series(series, isreduced=True)
return series
def _series_imagej(self):
"""Return image series in ImageJ file."""
# ImageJ's dimension order is TZCYXS
# TODO: fix loading of color, composite, or palette images
pages = self.pages
pages.useframes = True
pages.keyframe = 0
page = pages[0]
meta = self.imagej_metadata
def is_virtual():
# ImageJ virtual hyperstacks 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 = meta.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:
isvirtual = is_virtual()
except ValueError:
log_warning('ImageJ series: invalid metadata or corrupted file')
return None
if isvirtual:
# no need to read other pages
pages = [page]
else:
pages = pages[:]
images = meta.get('images', len(pages))
frames = meta.get('frames', 1)
slices = meta.get('slices', 1)
channels = meta.get('channels', 1)
shape = (frames, slices, channels)
axes = 'TZC'
remain = images // product(shape)
if remain > 1:
log_warning("ImageJ series: detected extra dimension 'I'")
shape = (remain,) + shape
axes = 'I' + axes
if page.shaped[0] > 1:
# planar storage, S == C, saved by Bio-Formats
if page.shaped[0] != channels:
log_warning(
f'ImageJ series: number of channels {channels} '
f'do not match separate samples {page.shaped[0]}'
)
shape = shape[:-1] + page.shape
axes += page.axes[1:]
elif page.shaped[-1] == channels and channels > 1:
# keep contig storage, C = 1
shape = (frames, slices, 1) + page.shape
axes += page.axes
else:
shape += page.shape
axes += page.axes
if 'S' not in axes:
shape += (1,)
axes += 'S'
# assert axes.endswith('TZCYXS'), axes
truncated = (
isvirtual
and len(self.pages) == 1
and page.is_contiguous[1]
!= (product(shape) * page.bitspersample // 8)
)
self.is_uniform = True
return [
TiffPageSeries(
pages,
shape,
page.dtype,
axes,
kind='ImageJ',
truncated=truncated,
)
]
def _series_scanimage(self):
"""Return image series in ScanImage file."""
pages = self.pages._getlist(validate=False)
page = pages[0]
dtype = page.dtype
shape = None
framedata = self.scanimage_metadata.get('FrameData', {})
if 'SI.hChannels.channelSave' in framedata:
try:
channels = framedata['SI.hChannels.channelSave']
try:
# channelSave is a list
channels = len(channels)
except TypeError:
# channelSave is an int
channels = int(channels)
# slices = framedata.get(
# 'SI.hStackManager.actualNumSlices',
# framedata.get('SI.hStackManager.numSlices', None),
# )
# if slices is None:
# raise ValueError('unable to determine numSlices')
slices = None
try:
frames = int(framedata['SI.hStackManager.framesPerSlice'])
except Exception:
# framesPerSlice is inf
slices = 1
if len(pages) % channels:
raise ValueError('unable to determine framesPerSlice')
frames = len(pages) // channels
if slices is None:
slices = max(len(pages) // (frames * channels), 1)
shape = (slices, frames, channels) + page.shape
axes = 'ZTC' + page.axes
except Exception as exc:
log_warning(f'ScanImage series: {exc}')
# TODO: older versions of ScanImage store non-varying frame data in
# the ImageDescription tag. Candidates are scanimage.SI5.channelsSave,
# scanimage.SI5.stackNumSlices, scanimage.SI5.acqNumFrames
# scanimage.SI4., state.acq.numberOfFrames, state.acq.numberOfFrames...
if shape is None:
shape = (len(pages),) + page.shape
axes = 'I' + page.axes
return [TiffPageSeries(pages, shape, dtype, axes, kind='ScanImage')]
def _series_fluoview(self):
"""Return image series in FluoView file."""
pages = self.pages._getlist(validate=False)
mm = self.fluoview_metadata
mmhd = list(reversed(mm['Dimensions']))
axes = ''.join(TIFF.MM_DIMENSIONS.get(i[0].upper(), 'Q') for i in mmhd)
shape = tuple(int(i[1]) for i in mmhd)
self.is_uniform = True
return [
TiffPageSeries(
pages,
shape,
pages[0].dtype,
axes,
name=mm['ImageName'],
kind='FluoView',
)
]
def _series_mdgel(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
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]
self.is_uniform = False
return [
TiffPageSeries(
[page],
page.shape,
dtype,
page.axes,
transform=transform,
kind='MDGel',
)
]
def _series_ndpi(self):
"""Return pyramidal image series in NDPI file."""
series = self._series_generic()
for s in series:
s.kind = 'NDPI'
if s.axes[0] == 'I':
s.axes = 'Z' + s.axes[1:]
if s.is_pyramidal:
name = s.pages[0].tags.get(65427, None)
s.name = 'Baseline' if name is None else name.value
continue
mag = s.pages[0].tags.get(65421, None)
if mag is not None:
mag = mag.value
if mag == -1.0:
s.name = 'Macro'
elif mag == -2.0:
s.name = 'Map'
return series
def _series_sis(self):
"""Return image series in Olympus SIS file."""
pages = self.pages._getlist(validate=False)
page = pages[0]
lenpages = len(pages)
md = self.sis_metadata
if 'shape' in md and 'axes' in md:
shape = md['shape'] + page.shape
axes = md['axes'] + page.axes
else:
shape = (lenpages,) + page.shape
axes = 'I' + page.axes
self.is_uniform = True
return [TiffPageSeries(pages, shape, page.dtype, axes, kind='SIS')]
def _series_qpi(self):
"""Return image series in PerkinElmer QPI file."""
series = []
pages = self.pages
pages.cache = True
pages.useframes = False
pages.keyframe = 0
pages._load()
# Baseline
# TODO: get name from ImageDescription XML
ifds = []
index = 0
axes = 'C' + pages[0].axes
dtype = pages[0].dtype
pshape = pages[0].shape
while index < len(pages):
page = pages[index]
if page.shape != pshape:
break
ifds.append(page)
index += 1
shape = (len(ifds),) + pshape
series.append(
TiffPageSeries(
ifds, shape, dtype, axes, name='Baseline', kind='QPI'
)
)
if index < len(pages):
# Thumbnail
page = pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Thumbnail',
kind='QPI',
)
)
index += 1
if pages[0].is_tiled:
# Resolutions
while index < len(pages):
pshape = (pshape[0] // 2, pshape[1] // 2) + pshape[2:]
ifds = []
while index < len(pages):
page = pages[index]
if page.shape != pshape:
break
ifds.append(page)
index += 1
if len(ifds) != len(series[0].pages):
break
shape = (len(ifds),) + pshape
series[0].levels.append(
TiffPageSeries(
ifds, shape, dtype, axes, name='Resolution', kind='QPI'
)
)
if series[0].is_pyramidal and index < len(pages):
# Macro
page = pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Macro',
kind='QPI',
)
)
index += 1
# Label
if index < len(pages):
page = pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Label',
kind='QPI',
)
)
self.is_uniform = False
return series
def _series_svs(self):
"""Return image series in Aperio SVS file."""
if not self.pages[0].is_tiled:
return None
series = []
self.is_uniform = False
self.pages.cache = True
self.pages.useframes = False
self.pages.keyframe = 0
self.pages._load()
# Baseline
index = 0
page = self.pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Baseline',
kind='SVS',
)
)
# Thumbnail
index += 1
if index == len(self.pages):
return series
page = self.pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Thumbnail',
kind='SVS',
)
)
# Resolutions
# TODO: resolutions not by two
index += 1
while index < len(self.pages):
page = self.pages[index]
if not page.is_tiled:
break
series[0].levels.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name='Resolution',
kind='SVS',
)
)
index += 1
# Label, Macro
for name in ('Label', 'Macro'):
if index == len(self.pages):
break
page = self.pages[index]
series.append(
TiffPageSeries(
[page],
page.shape,
page.dtype,
page.axes,
name=name,
kind='SVS',
)
)
index += 1
return series
def _series_scn(self):
"""Return pyramidal image series in Leica SCN file."""
# TODO: support collections
from xml.etree import ElementTree as etree # delayed import
scnxml = self.pages[0].description
root = etree.fromstring(scnxml)
series = []
self.is_uniform = False
self.pages.cache = True
self.pages.useframes = False
self.pages.keyframe = 0
self.pages._load()
for collection in root:
if not collection.tag.endswith('collection'):
continue
for image in collection:
if not image.tag.endswith('image'):
continue
name = image.attrib.get('name', 'Unknown')
for pixels in image:
if not pixels.tag.endswith('pixels'):
continue
resolutions = {}
for dimension in pixels:
if not dimension.tag.endswith('dimension'):
continue
if int(image.attrib.get('sizeZ', 1)) > 1:
raise NotImplementedError(
'SCN series: Z-Stacks not supported'
)
sizex = int(dimension.attrib['sizeX'])
sizey = int(dimension.attrib['sizeY'])
c = int(dimension.attrib.get('c', 0))
z = int(dimension.attrib.get('z', 0))
r = int(dimension.attrib.get('r', 0))
ifd = int(dimension.attrib['ifd'])
if r in resolutions:
level = resolutions[r]
if c > level['channels']:
level['channels'] = c
if z > level['sizez']:
level['sizez'] = z
level['ifds'][(c, z)] = ifd
else:
resolutions[r] = {
'size': [sizey, sizex],
'channels': c,
'sizez': z,
'ifds': {(c, z): ifd},
}
if not resolutions:
continue
levels = []
for r, level in sorted(resolutions.items()):
shape = (level['channels'] + 1, level['sizez'] + 1)
axes = 'CZ'
ifds = [None] * product(shape)
for (c, z), ifd in sorted(level['ifds'].items()):
ifds[c * shape[1] + z] = self.pages[ifd]
axes += ifds[0].axes
shape += ifds[0].shape
dtype = ifds[0].dtype
levels.append(
TiffPageSeries(
ifds,
shape,
dtype,
axes,
parent=self,
name=name,
kind='SCN',
)
)
levels[0].levels.extend(levels[1:])
series.append(levels[0])
return series
def _series_ome(self):
"""Return image series in OME-TIFF file(s)."""
# xml.etree found to be faster than lxml
from xml.etree import ElementTree as etree # delayed import
omexml = self.pages[0].description
try:
root = etree.fromstring(omexml)
except etree.ParseError as exc:
# TODO: test badly encoded OME-XML
log_warning(f'OME series: {exc.__class__.__name__}: {exc}')
try:
omexml = omexml.decode(errors='ignore').encode()
root = etree.fromstring(omexml)
except Exception:
return None
self.pages.cache = True
self.pages.useframes = True
self.pages.keyframe = 0
self.pages._load(keyframe=None)
root_uuid = root.attrib.get('UUID', None)
self._files = {root_uuid: self}
dirname = self._fh.dirname
moduloref = []
modulo = {}
series = []
for element in root:
if element.tag.endswith('BinaryOnly'):
# TODO: load OME-XML from master or companion file
log_warning('OME series: 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
modulo[annot.attrib['ID']] = mod = {}
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')
]
mod[axis] = (newaxis, labels)
if not element.tag.endswith('Image'):
continue
for annot in element:
if annot.tag.endswith('AnnotationRef'):
annotationref = annot.attrib['ID']
break
else:
annotationref = None
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 = [int(attr['Size' + ax]) for ax in axes]
ifds = []
spp = 1 # samples per pixel
first = True
for data in pixels:
if data.tag.endswith('Channel'):
attr = data.attrib
if first:
first = False
spp = int(attr.get('SamplesPerPixel', spp))
if spp > 1:
# correct channel dimension for spp
shape = [
shape[i] // spp if ax == 'C' else shape[i]
for i, ax in enumerate(axes)
]
elif int(attr.get('SamplesPerPixel', 1)) != spp:
raise ValueError(
'OME series: cannot handle differing '
'SamplesPerPixel'
)
continue
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 = int(numpy.ravel_multi_index(idx, shape[:-2]))
except ValueError:
# ImageJ produces invalid ome-xml when cropping
log_warning('OME series: invalid TiffData index')
continue
for uuid in data:
if not uuid.tag.endswith('UUID'):
continue
if root_uuid is None and uuid.text is not None:
# no global UUID, use this file
root_uuid = uuid.text
self._files[root_uuid] = self._files[None]
elif 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), _master=self
)
tif.pages.cache = True
tif.pages.useframes = True
tif.pages.keyframe = 0
tif.pages._load(keyframe=None)
except (OSError, FileNotFoundError, ValueError):
log_warning(
f'OME series: failed to read {fname!r}'
)
# assume that size is same as in previous file
# if no NumPlanes or PlaneCount are given
size = num if num else size # noqa: undefined
ifds.extend([None] * (size + idx - len(ifds)))
break
self._files[uuid.text] = tif
tif.close()
pages = self._files[uuid.text].pages
try:
size = num if num else len(pages)
ifds.extend([None] * (size + idx - len(ifds)))
for i in range(size):
ifds[idx + i] = pages[ifd + i]
except IndexError:
log_warning('OME series: index out of range')
# only process first UUID
break
else:
# no uuid found
pages = self.pages
try:
size = num if num else len(pages)
ifds.extend([None] * (size + idx - len(ifds)))
for i in range(size):
ifds[idx + i] = pages[ifd + i]
except IndexError:
log_warning('OME series: index out of range')
if not ifds or all(i is None for i in ifds):
# skip images without data
continue
# find a keyframe
keyframe = None
for ifd in ifds:
# try find a TiffPage
if ifd and ifd == ifd.keyframe:
keyframe = ifd
break
if keyframe is None:
# reload a TiffPage from file
for i, keyframe in enumerate(ifds):
if keyframe:
isclosed = keyframe.parent.filehandle.closed
if isclosed:
keyframe.parent.filehandle.open()
keyframe.parent.pages.keyframe = keyframe.index
keyframe = keyframe.parent.pages[keyframe.index]
ifds[i] = keyframe
if isclosed:
keyframe.parent.filehandle.close()
break
# does the series spawn multiple files
multifile = False
for ifd in ifds:
if ifd and ifd.parent != keyframe.parent:
multifile = True
break
if spp > 1:
if keyframe.planarconfig == 1:
shape += [spp]
axes += 'S'
else:
shape = shape[:-2] + [spp] + shape[-2:]
axes = axes[:-2] + 'S' + axes[-2:]
if 'S' not in shape:
shape += [1]
axes += 'S'
# there might be more pages in the file than referenced in XML
# e.g. Nikon-cell011.ome.tif
size = max(product(shape) // keyframe.size, 1)
if size != len(ifds):
log_warning(
'OME series: expected %s frames, got %s',
size,
len(ifds),
)
ifds = ifds[:size]
# FIXME: this implementation assumes the last dimensions are
# stored in TIFF pages. Apparently that is not always the case.
# E.g. TCX (20000, 2, 500) is stored in 2 pages of (20000, 500)
# in 'Image 7.ome_h00.tiff'.
# For now, verify that shapes of keyframe and series match.
# If not, skip series.
squeezed = squeeze_axes(shape, axes)[0]
if keyframe.shape != tuple(squeezed[-len(keyframe.shape) :]):
log_warning(
'OME series: cannot handle discontiguous storage '
'%s != %s',
keyframe.shape,
tuple(squeezed[-len(keyframe.shape) :]),
)
del ifds
continue
# set keyframe on all IFDs
keyframes = {keyframe.parent.filehandle.name: keyframe}
for i, page in enumerate(ifds):
if page is None:
continue
fh = page.parent.filehandle
if fh.name not in keyframes:
if page.keyframe != page:
# reload TiffPage from file
isclosed = fh.closed
if isclosed:
fh.open()
page.parent.pages.keyframe = page.index
page = page.parent.pages[page.index]
ifds[i] = page
if isclosed:
fh.close()
keyframes[fh.name] = page
if page.keyframe != page:
page.keyframe = keyframes[fh.name]
moduloref.append(annotationref)
series.append(
TiffPageSeries(
ifds,
shape,
keyframe.dtype,
axes,
parent=self,
name=name,
multifile=multifile,
kind='OME',
)
)
del ifds
for serie, annotationref in zip(series, moduloref):
if annotationref not in modulo:
continue
shape = list(serie.get_shape(False))
axes = serie.get_axes(False)
for axis, (newaxis, labels) in modulo[annotationref].items():
i = axes.index(axis)
size = len(labels)
if shape[i] == size:
axes = axes.replace(axis, newaxis, 1)
else:
shape[i] //= size
shape.insert(i + 1, size)
axes = axes.replace(axis, axis + newaxis, 1)
serie.set_shape_axes(shape, axes)
# pyramids
for serie in series:
keyframe = serie.keyframe
if keyframe.subifds is None:
continue
if len(self._files) > 1:
# TODO: support multi-file pyramids; must re-open/close
log_warning('OME series: cannot read multi-file pyramids')
break
for level in range(len(keyframe.subifds)):
keyframe = None
ifds = []
for page in serie.pages:
if page is None:
ifds.append(None)
continue
page.parent.filehandle.seek(page.subifds[level])
if page.keyframe == page:
ifd = keyframe = TiffPage(self, (page.index, level))
elif keyframe is None:
raise RuntimeError('no keyframe')
else:
ifd = TiffFrame(self, page.index, keyframe=keyframe)
ifds.append(ifd)
# fix shape
shape = []
for i, ax in enumerate(serie.axes):
if ax == 'X':
shape.append(keyframe.imagewidth)
elif ax == 'Y':
shape.append(keyframe.imagelength)
else:
shape.append(serie.shape[i])
# add series
serie.levels.append(
TiffPageSeries(
ifds,
tuple(shape),
keyframe.dtype,
serie.axes,
parent=self,
name=f'level {level + 1}',
kind='OME',
)
)
self.is_uniform = len(series) == 1 and len(series[0].levels) == 1
return series
def _series_stk(self):
"""Return series in STK file."""
page = self.pages[0]
meta = self.stk_metadata
planes = meta['NumberPlanes']
name = meta.get('Name', '')
if planes == 1:
shape = (1,) + page.shape
axes = 'I' + page.axes
elif numpy.all(meta['ZDistance'] != 0):
shape = (planes,) + page.shape
axes = 'Z' + page.axes
elif numpy.all(numpy.diff(meta['TimeCreated']) != 0):
shape = (planes,) + page.shape
axes = 'T' + page.axes
else:
# TODO: determine other/combinations of dimensions
shape = (planes,) + page.shape
axes = 'I' + page.axes
self.is_uniform = True
series = TiffPageSeries(
[page],
shape,
page.dtype,
axes,
name=name,
truncated=planes > 1,
kind='STK',
)
return [series]
def _series_lsm(self):
"""Return main and thumbnail series in LSM file."""
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) > 0:
axes += 'P'
if lsmi.get('DimensionM', 0) > 0:
axes += 'M'
axes = axes[::-1]
shape = tuple(int(lsmi[TIFF.CZ_LSMINFO_DIMENSIONS[i]]) for i in axes)
name = lsmi.get('Name', '')
pages = self.pages._getlist(slice(0, None, 2), validate=False)
dtype = pages[0].dtype
series = [
TiffPageSeries(pages, shape, dtype, axes, name=name, kind='LSM')
]
page = self.pages[1]
if page.is_reduced:
pages = self.pages._getlist(slice(1, None, 2), validate=False)
dtype = page.dtype
cp = 1
i = 0
while cp < len(pages) and i < len(shape) - 2:
cp *= shape[i]
i += 1
shape = shape[:i] + page.shape
axes = axes[:i] + 'SYX'
series.append(
TiffPageSeries(
pages, shape, dtype, axes, name=name, kind='LSMreduced'
)
)
self.is_uniform = False
return series
def _lsm_load_pages(self):
"""Load and fix all pages from LSM file."""
# cache all pages to preserve corrected values
pages = self.pages
pages.cache = True
pages.useframes = True
# use first and second page as keyframes
pages.keyframe = 1
pages.keyframe = 0
# load remaining pages as frames
pages._load(keyframe=None)
# fix offsets and bytecounts first
# TODO: fix multiple conversions between lists and tuples
self._lsm_fix_strip_offsets()
self._lsm_fix_strip_bytecounts()
# assign keyframes for data and thumbnail series
keyframe = pages[0]
for page in pages[::2]:
page.keyframe = keyframe
keyframe = pages[1]
for page in pages[1::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)
if mod != 0:
raise RuntimeError('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[int(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
)
bytecounts = list(bytecounts)
for j in range(len(bytecounts) - 1):
bytecounts[j] = offsets[j + 1] - offsets[j]
bytecounts[-1] = lastoffset - offsets[-1]
page.databytecounts = tuple(bytecounts)
def _philips_load_pages(self):
"""Load and fix all pages from Philips slide file.
The imagewidth and imagelength values of all tiled pages are corrected
using the DICOM_PIXEL_SPACING attributes of the XML formatted
description of the first page.
"""
from xml.etree import ElementTree as etree # delayed import
pages = self.pages
pages.cache = True
pages.useframes = False
pages._load()
npages = len(pages)
root = etree.fromstring(pages[0].description)
imagewidth = pages[0].imagewidth
imagelength = pages[0].imagelength
sizes = None
for elem in root.iter():
if (
elem.tag != 'Attribute'
or elem.attrib['Name'] != 'DICOM_PIXEL_SPACING'
):
continue
w, h = (float(v) for v in elem.text.replace('"', '').split())
if sizes is None:
imagelength *= h
imagewidth *= w
sizes = []
else:
sizes.append(
(
int(math.ceil(imagelength / h)),
int(math.ceil(imagewidth / w)),
)
)
i = 0
for imagelength, imagewidth in sizes:
while i < npages and pages[i].tilewidth == 0:
# Label, Macro
i += 1
continue
if i == npages:
break
page = pages[i]
page.imagewidth = imagewidth
page.imagelength = imagelength
if page.shaped[-1] > 1:
page.shape = (imagelength, imagewidth, page.shape[-1])
elif page.shaped[0] > 1:
page.shape = (page.shape[0], imagelength, imagewidth)
else:
page.shape = (imagelength, imagewidth)
page.shaped = (
page.shaped[:2] + (imagelength, imagewidth) + page.shaped[-1:]
)
i += 1
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(
f'{self.__class__.__name__!r} object has no attribute {name!r}'
)
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 TiffFile.
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 '{}'",
format_size(self._fh.size),
''
if byteorder_isnative(self.byteorder)
else {'<': 'little-endian', '>': 'big-endian'}[self.byteorder],
]
if self.is_bigtiff:
info.append('BigTiff')
info.append(' '.join(f.lower() for f in self.flags))
if len(self.pages) > 1:
info.append(f'{len(self.pages)} Pages')
if len(self.series) > 1:
info.append(f'{len(self.series)} Series')
if len(self._files) > 1:
info.append(f'{len(self._files)} Files')
info = ' '.join(info)
info = info.replace(' ', ' ').replace(' ', ' ')
info = info.format(
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:
for p in self.pages:
if p is None:
continue
info.append(TiffPage.__str__(p, detail=detail, width=width))
for s in p.pages:
info.append(
TiffPage.__str__(s, detail=detail, width=width)
)
elif self.series:
info.extend(
TiffPage.__str__(s.pages[0], detail=detail, width=width)
for s in self.series
if s.pages[0] is not None
)
elif self.pages and self.pages[0]:
info.append(
TiffPage.__str__(self.pages[0], detail=detail, width=width)
)
if detail >= 2:
for name in sorted(self.flags):
if hasattr(self, name + '_metadata'):
m = getattr(self, name + '_metadata')
if m:
info.append(
'{}_METADATA\n{}'.format(
name.upper(),
pformat(m, width=width, height=detail * 24),
)
)
return '\n\n'.join(info).replace('\n\n\n', '\n\n')
@lazyattr
def flags(self):
"""Return set of file flags, a potentially expensive operation."""
return {
name.lower()
for name in sorted(TIFF.FILE_FLAGS)
if getattr(self, 'is_' + name)
}
@property
def is_bigtiff(self):
"""Return if file has BigTIFF format."""
return self.tiff.version == 43
@lazyattr
def is_mdgel(self):
"""Return if file has MD Gel format."""
# side effect: add second page, if exists, to cache
try:
ismdgel = (
self.pages[0].is_mdgel
or self.pages.get(1, cache=True).is_mdgel
)
if ismdgel:
self.is_uniform = False
return ismdgel
except IndexError:
return False
@lazyattr
def is_uniform(self):
"""Return if file contains a uniform series of pages."""
# the hashes of IFDs 0, 7, and -1 are the same
pages = self.pages
page = pages[0]
if page.subifds:
return False
if page.is_scanimage or page.is_nih:
return True
try:
useframes = pages.useframes
pages.useframes = False
h = page.hash
for i in (1, 7, -1):
if pages[i].aspage().hash != h:
return False
except IndexError:
return False
finally:
pages.useframes = useframes
return True
@property
def is_appendable(self):
"""Return if pages can be appended to file without corrupting."""
# TODO: check other formats
return not (
self.is_ome
or self.is_lsm
or self.is_stk
or self.is_imagej
or self.is_fluoview
or self.is_micromanager
)
@lazyattr
def shaped_metadata(self):
"""Return tifffile metadata from JSON descriptions as dicts."""
if not self.is_shaped:
return None
return tuple(
json_description_metadata(s.pages[0].is_shaped)
for s in self.series
if s.kind.lower() == 'shaped'
)
@property
def ome_metadata(self):
"""Return OME XML."""
if not self.is_ome:
return None
# return xml2dict(self.pages[0].description)['OME']
return self.pages[0].description
@property
def scn_metadata(self):
"""Return Leica SCN XML."""
if not self.is_scn:
return None
return self.pages[0].description
@property
def philips_metadata(self):
"""Return Philips DP XML."""
if not self.is_philips:
return None
return self.pages[0].description
@property
def lsm_metadata(self):
"""Return LSM metadata from CZ_LSMINFO tag as dict."""
if not self.is_lsm:
return None
return self.pages[0].tags[34412].value # CZ_LSMINFO
@lazyattr
def stk_metadata(self):
"""Return STK metadata from UIC tags as dict."""
if not self.is_stk:
return None
page = self.pages[0]
result = {}
result['NumberPlanes'] = page.tags[33629].count # UIC2tag
if page.description:
result['PlaneDescriptions'] = page.description.split('\x00')
# result['plane_descriptions'] = stk_description_metadata(
# page.image_description)
tag = page.tags.get(33628) # UIC1tag
if tag is not None:
result.update(tag.value)
tag = page.tags.get(33630) # UIC3tag
if tag is not None:
result.update(tag.value) # wavelengths
tag = page.tags.get(33631) # UIC4tag
if tag is not None:
result.update(tag.value) # override UIC1 tags
uic2tag = page.tags[33629].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 exc:
log_warning(f'STK metadata: {exc.__class__.__name__}: {exc}')
return result
@lazyattr
def imagej_metadata(self):
"""Return consolidated ImageJ metadata as dict."""
if not self.is_imagej:
return None
page = self.pages[0]
result = imagej_description_metadata(page.is_imagej)
tag = page.tags.get(50839) # IJMetadata
if tag is not None:
try:
result.update(tag.value)
except Exception:
pass
return result
@lazyattr
def fluoview_metadata(self):
"""Return consolidated FluoView metadata as dict."""
if not self.is_fluoview:
return None
result = {}
page = self.pages[0]
result.update(page.tags[34361].value) # MM_Header
# TODO: read stamps from all pages
result['Stamp'] = page.tags[34362].value # MM_Stamp
# 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 exc:
# log_warning(
# 'FluoView metadata: failed to parse image description '
# f'({exc})'
# )
return result
@property
def nih_metadata(self):
"""Return NIH Image metadata from NIHImageHeader tag as dict."""
if not self.is_nih:
return None
return self.pages[0].tags[43314].value # NIHImageHeader
@property
def fei_metadata(self):
"""Return FEI metadata from SFEG or HELIOS tags as dict."""
if not self.is_fei:
return None
tags = self.pages[0].tags
tag = tags.get(34680, tags.get(34682)) # FEI_SFEG or FEI_HELIOS
return None if tag is None else tag.value
@property
def sem_metadata(self):
"""Return SEM metadata from CZ_SEM tag as dict."""
if not self.is_sem:
return None
return self.pages[0].tags[34118].value
@property
def sis_metadata(self):
"""Return Olympus SIS metadata from SIS and INI tags as dict."""
if not self.is_sis:
return None
tags = self.pages[0].tags
result = {}
try:
result.update(tags[33471].value) # OlympusINI
except Exception:
pass
try:
result.update(tags[33560].value) # OlympusSIS
except Exception:
pass
return result
@lazyattr
def mdgel_metadata(self):
"""Return consolidated metadata from MD GEL tags as dict."""
for page in self.pages[:2]:
if 33445 in page.tags: # MDFileTag
tags = page.tags
break
else:
return None
result = {}
for code in range(33445, 33453):
if code not in tags:
continue
name = TIFF.TAGS[code]
result[name[2:]] = tags[code].value
return result
@property
def andor_metadata(self):
"""Return Andor tags as dict."""
return self.pages[0].andor_tags
@property
def epics_metadata(self):
"""Return EPICS areaDetector tags as dict."""
return self.pages[0].epics_tags
@property
def tvips_metadata(self):
"""Return TVIPS tag as dict."""
if not self.is_tvips:
return None
return self.pages[0].tags[37706].value
@lazyattr
def metaseries_metadata(self):
"""Return MetaSeries metadata from image description as dict."""
if not self.is_metaseries:
return None
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 None
return pilatus_description_metadata(self.pages[0].description)
@lazyattr
def micromanager_metadata(self):
"""Return MicroManager non-TIFF settings from file as dict."""
if not self.is_micromanager:
return None
# from file header
return read_micromanager_metadata(self._fh)
@lazyattr
def scanimage_metadata(self):
"""Return ScanImage non-varying frame and ROI metadata as dict.
The returned dict may be empty or contain 'FrameData', 'RoiGroups',
and 'version' keys.
The varying frame data can be found in the ImageDescription tags.
"""
if not self.is_scanimage:
return None
result = {}
try:
framedata, roidata, version = read_scanimage_metadata(self._fh)
result['version'] = version
result['FrameData'] = framedata
result.update(roidata)
except ValueError:
pass
return result
@property
def geotiff_metadata(self):
"""Return GeoTIFF metadata from first page as dict."""
if not self.is_geotiff:
return None
return self.pages[0].geotiff_tags
@property
def eer_metadata(self):
"""Return EER metadata from first page as XML."""
if not self.is_eer:
return None
return self.pages[0].tags[65001].value.decode()
class TiffPages:
"""Sequence of TIFF image file directories (IFD chain).
Instances of TiffPages have a state (cache, keyframe, etc.) and are not
thread-safe.
"""
def __init__(self, parent, index=None):
"""Initialize instance and read first TiffPage from file.
If parent is a TiffFile, the file position must be at an offset to an
offset to a TiffPage. If parent is a TiffPage, page offsets are read
from the SubIFDs tag.
"""
self.parent = None
self.pages = [] # cache of TiffPages, TiffFrames, or their offsets
self._indexed = False # True if offsets to all pages were read
self._cached = False # True if all pages were read into cache
self._tiffpage = TiffPage # class used for reading pages
self._keyframe = None # page that is currently used as keyframe
self._cache = False # do not cache frames or pages (if not keyframe)
self._nextpageoffset = None
self._index = (index,) if isinstance(index, int) else index
if isinstance(parent, TiffFile):
# read offset to first page from current file position
self.parent = parent
fh = parent.filehandle
self._nextpageoffset = fh.tell()
offset = struct.unpack(
parent.tiff.offsetformat, fh.read(parent.tiff.offsetsize)
)[0]
if offset == 0:
log_warning('TiffPages: file contains no pages')
self._indexed = True
return
elif 330 in parent.tags:
# use offsets from SubIFDs tag
self.parent = parent.parent
fh = self.parent.filehandle
offsets = parent.tags[330].value
offset = offsets[0]
if offset == 0:
log_warning('TiffPages: TiffPage contains invalid SubIFDs')
self._indexed = True
return
else:
self._indexed = True
return
if offset >= fh.size:
log_warning(f'TiffPages: invalid page offset {offset!r}')
self._indexed = True
return
pageindex = 0 if self._index is None else self._index + (0,)
# read and cache first page
fh.seek(offset)
page = TiffPage(self.parent, index=pageindex)
self.pages.append(page)
self._keyframe = page
if self._nextpageoffset is None:
# offsets from SubIFDs tag
self.pages.extend(offsets[1:])
self._indexed = True
self._cached = True
@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 current keyframe."""
return self._keyframe
@keyframe.setter
def keyframe(self, index):
"""Set current keyframe. Load TiffPage from file if necessary."""
index = int(index)
if index < 0:
index %= len(self)
if self._keyframe.index == index:
return
if index == 0:
self._keyframe = self.pages[0]
return
if self._indexed or index < len(self.pages):
page = self.pages[index]
if isinstance(page, TiffPage):
self._keyframe = page
return
if isinstance(page, TiffFrame):
# remove existing TiffFrame
self.pages[index] = page.offset
# load TiffPage from file
tiffpage = self._tiffpage
self._tiffpage = TiffPage
try:
self._keyframe = self._getitem(index)
finally:
self._tiffpage = tiffpage
# always cache keyframes
self.pages[index] = self._keyframe
@property
def next_page_offset(self):
"""Return offset where offset to a new page can be stored."""
if not self._indexed:
self._seek(-1)
return self._nextpageoffset
def get(self, key, default=None, validate=False, cache=None, aspage=True):
"""Return specified page from cache or file."""
try:
return self._getitem(
key, validate=validate, cache=cache, aspage=aspage
)
except IndexError:
if default is None:
raise
return default
def _load(self, keyframe=True):
"""Read all remaining pages from file."""
if self._cached:
return
pages = self.pages
if not pages:
return
if not self._indexed:
self._seek(-1)
if not self._cache:
return
fh = self.parent.filehandle
if keyframe is not None:
keyframe = self._keyframe
for i, page in enumerate(pages):
if isinstance(page, (int, numpy.integer)):
pageindex = i if self._index is None else self._index + (i,)
fh.seek(page)
page = self._tiffpage(
self.parent, index=pageindex, keyframe=keyframe
)
pages[i] = page
self._cached = True
def _load_virtual_frames(self):
"""Calculate virtual TiffFrames."""
pages = self.pages
try:
if len(pages) > 1:
raise ValueError('pages already loaded')
page = pages[0]
if not page.is_contiguous:
raise ValueError('data not contiguous')
self._seek(4)
delta = pages[2] - pages[1]
if pages[3] - pages[2] != delta or pages[4] - pages[3] != delta:
raise ValueError('page offsets not equidistant')
page1 = self._getitem(1, validate=page.hash)
offsetoffset = page1.dataoffsets[0] - page1.offset
if offsetoffset < 0 or offsetoffset > delta:
raise ValueError('page offsets not equidistant')
pages = [page, page1]
filesize = self.parent.filehandle.size - delta
for index, offset in enumerate(
range(page1.offset + delta, filesize, delta)
):
pageindex = index + 2
d = pageindex * delta
offsets = tuple(i + d for i in page.dataoffsets)
offset = offset if offset < 2 ** 31 - 1 else None
if self._index is not None:
pageindex = self._index + (pageindex,)
pages.append(
TiffFrame(
parent=page.parent,
index=pageindex,
offset=offset,
offsets=offsets,
bytecounts=page.databytecounts,
keyframe=page,
)
)
self.pages = pages
self._cache = True
self._cached = True
self._indexed = True
except Exception as exc:
if self.parent.filehandle.size >= 2147483648:
log_warning(f'TiffPages: failed to load virtual frames: {exc}')
def _clear(self, fully=True):
"""Delete all but first page from cache. Set keyframe to first page."""
pages = self.pages
if not pages:
return
self._keyframe = pages[0]
if fully:
# delete all but first TiffPage/TiffFrame
for i, page in enumerate(pages[1:]):
if not isinstance(page, int) and page.offset is not None:
pages[i + 1] = page.offset
elif TiffFrame is not TiffPage:
# delete only TiffFrames
for i, page in enumerate(pages):
if isinstance(page, TiffFrame) and page.offset is not None:
pages[i] = page.offset
self._cached = False
def _seek(self, index, maxpages=None):
"""Seek file to offset of page specified by index."""
pages = self.pages
lenpages = len(pages)
if lenpages == 0:
raise IndexError('index out of range')
fh = self.parent.filehandle
if fh.closed:
raise ValueError('seek of closed file')
if self._indexed or 0 <= index < lenpages:
page = pages[index]
offset = page if isinstance(page, int) else page.offset
fh.seek(offset)
return
tiff = self.parent.tiff
offsetformat = tiff.offsetformat
offsetsize = tiff.offsetsize
tagnoformat = tiff.tagnoformat
tagnosize = tiff.tagnosize
tagsize = tiff.tagsize
unpack = struct.unpack
page = pages[-1]
offset = page if isinstance(page, int) else page.offset
if maxpages is None:
maxpages = 2 ** 22
while lenpages < 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 TiffFileError(f'suspicious number of tags {tagno!r}')
except Exception:
log_warning(
'TiffPages: corrupted tag list of page '
f'{lenpages} @ {offset}'
)
del pages[-1]
lenpages -= 1
self._indexed = 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._indexed = True
break
if offset >= fh.size:
log_warning(f'TiffPages: invalid page offset {offset!r}')
self._indexed = True
break
pages.append(offset)
lenpages += 1
if 0 <= index < lenpages:
break
# detect some circular references
if lenpages == 100:
for p in pages[:-1]:
if offset == (p if isinstance(p, int) else p.offset):
raise TiffFileError('invalid circular IFD reference')
if index >= lenpages:
raise IndexError('index out of range')
page = pages[index]
fh.seek(page if isinstance(page, int) else page.offset)
def _getlist(self, key=None, useframes=True, validate=True):
"""Return specified pages as list of TiffPages or TiffFrames.
The first item is a TiffPage, and is used as a keyframe for
following TiffFrames.
"""
getitem = self._getitem
_useframes = self.useframes
if key is None:
key = iter(range(len(self)))
elif isinstance(key, Iterable):
key = iter(key)
elif isinstance(key, slice):
start, stop, _ = key.indices(2 ** 31 - 1)
if not self._indexed and max(stop, start) > len(self.pages):
self._seek(-1)
key = iter(range(*key.indices(len(self.pages))))
elif isinstance(key, (int, numpy.integer)):
# return single TiffPage
self.useframes = False
if key == 0:
return [self.pages[key]]
try:
return [getitem(key)]
finally:
self.useframes = _useframes
else:
raise TypeError('key must be an integer, slice, or iterable')
# use first page as keyframe
keyframe = self._keyframe
self.keyframe = next(key)
if validate:
validate = self._keyframe.hash
if useframes:
self.useframes = True
try:
pages = [getitem(i, validate) for i in key]
pages.insert(0, self._keyframe)
finally:
# restore state
self._keyframe = keyframe
if useframes:
self.useframes = _useframes
return pages
def _getitem(self, key, validate=False, cache=None, aspage=None):
"""Return specified page from cache or file."""
key = int(key)
pages = self.pages
if key < 0:
key %= len(self)
elif self._indexed and key >= len(pages):
raise IndexError(f'index {key} out of range({len(pages)})')
tiffpage = TiffPage if aspage else self._tiffpage
if key < len(pages):
page = pages[key]
if self._cache and not aspage:
if not isinstance(page, (int, numpy.integer)):
if validate and validate != page.hash:
raise RuntimeError('page hash mismatch')
return page
elif isinstance(page, (TiffPage, tiffpage)):
if validate and validate != page.hash:
raise RuntimeError('page hash mismatch')
return page
pageindex = key if self._index is None else self._index + (key,)
self._seek(key)
page = tiffpage(self.parent, index=pageindex, keyframe=self._keyframe)
if validate and validate != page.hash:
raise RuntimeError('page hash mismatch')
if self._cache or cache:
pages[key] = page
return page
def __getitem__(self, key):
"""Return specified page(s)."""
pages = self.pages
getitem = self._getitem
if isinstance(key, (int, numpy.integer)):
if key == 0:
return pages[key]
return getitem(key)
if isinstance(key, slice):
start, stop, _ = key.indices(2 ** 31 - 1)
if not self._indexed and max(stop, start) > len(pages):
self._seek(-1)
return [getitem(i) for i in range(*key.indices(len(pages)))]
if isinstance(key, Iterable):
return [getitem(k) for k in key]
raise TypeError('key must be an integer, slice, or iterable')
def __iter__(self):
"""Return iterator over all pages."""
i = 0
while True:
try:
yield self._getitem(i)
i += 1
except IndexError:
break
if self._cache:
self._cached = True
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._indexed:
self._seek(-1)
return len(self.pages)
class TiffPage:
"""TIFF image file directory (IFD).
Attributes
----------
index : int
Index of the page in file.
dtype : numpy.dtype or None
Data type (native byte order) of the image in IFD.
shape : tuple of int
Dimensions of the image in IFD, as returned by asarray.
axes : str
Axes label codes for each dimension in shape:
'S' sample,
'X' width,
'Y' length,
'Z' depth,
tags : TiffTags
Multidict like interface to tags in IFD.
colormap : numpy.ndarray
Color look up table, if exists.
shaped : tuple of int
Normalized 5-dimensional shape of the image in IFD:
0 : separate samplesperpixel or 1.
1 : imagedepth Z or 1.
2 : imagelength Y.
3 : imagewidth X.
4 : contig samplesperpixel or 1.
All attributes are read-only.
"""
# default properties; will be updated from tags
subfiletype = 0
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 = ()
subifds = None
jpegtables = None
jpegheader = None # NDPI only
colormap = None
software = ''
description = ''
description1 = ''
nodata = 0
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.shaped = ()
self.dtype = None
self._dtype = None
self.axes = ''
self.tags = tags = TiffTags()
self.dataoffsets = ()
self.databytecounts = ()
tiff = parent.tiff
# read TIFF IFD structure and its tags from file
fh = parent.filehandle
self.offset = fh.tell() # offset to this IFD
try:
tagno = struct.unpack(tiff.tagnoformat, fh.read(tiff.tagnosize))[0]
if tagno > 4096:
raise TiffFileError(
f'TiffPage {self.index}: suspicious number of tags'
)
except Exception:
raise TiffFileError(
f'TiffPage {self.index}: '
f'corrupted tag list at offset {self.offset}'
)
tagoffset = self.offset + tiff.tagnosize # fh.tell()
tagsize = tiff.tagsize
data = fh.read(tagsize * tagno)
if tiff.version == 42 and tiff.offsetsize == 8:
# patch offsets/values for 64-bit NDPI file
tagsize = 16
fh.seek(8, os.SEEK_CUR)
ext = fh.read(4 * tagno) # high bits
data = b''.join(
data[i * 12 : i * 12 + 12] + ext[i * 4 : i * 4 + 4]
for i in range(tagno)
)
tagindex = -tagsize
for _ in range(tagno):
tagindex += tagsize
tagdata = data[tagindex : tagindex + tagsize]
try:
tag = TiffTag.fromfile(parent, tagoffset + tagindex, tagdata)
except TiffFileError as exc:
log_warning(
f'TiffPage {self.index}: {exc.__class__.__name__}: {exc}'
)
continue
tags.add(tag)
if not tags:
return # found in FIBICS
for code, name in TIFF.TAG_ATTRIBUTES.items():
tag = tags.get(code)
if tag is not None:
if code in (270, 305) and not isinstance(tag.value, str):
# wrong string type for software or description
continue
setattr(self, name, tag.value)
tag = tags.get(270, index=1)
if tag:
self.description1 = tag.value
tag = tags.get(255) # SubfileType
if tag and self.subfiletype == 0:
if tag.value == 2:
self.subfiletype = 0b1 # reduced image
elif tag.value == 3:
self.subfiletype = 0b10 # multi-page
# consolidate private tags; remove them from self.tags
# if self.is_andor:
# self.andor_tags
# elif self.is_epics:
# self.epics_tags
# elif self.is_ndpi:
# self.ndpi_tags
# if self.is_sis and 34853 in tags:
# # TODO: can't change tag.name
# tags[34853].name = 'OlympusSIS2'
if self.compression == 6:
# OJPEG hack. See libtiff v4.2.0 tif_dirread.c#L4082
if 262 not in tags:
# PhotometricInterpretation missing
self.photometric = 6 # YCbCr
elif self.photometric == 2:
# RGB -> YCbCr
self.photometric = 6
if 258 not in tags:
# BitsPerSample missing
self.bitspersample = 8
if 277 not in tags:
# SamplesPerPixel missing
if self.photometric in (2, 6):
self.samplesperpixel = 3
elif self.photometric in (0, 1):
self.samplesperpixel = 3
elif self.is_lsm or (self.index != 0 and self.parent.is_lsm):
# correct non standard LSM bitspersample tags
tags[258]._fix_lsm_bitspersample(self)
if self.compression == 1 and self.predictor != 1:
# work around bug in LSM510 software
self.predictor = 1
elif self.is_vista or (self.index != 0 and self.parent.is_vista):
# ISS Vista writes wrong ImageDepth tag
self.imagedepth = 1
elif self.is_stk:
tag = tags.get(33628) # UIC1tag
if tag is not None and not tag.value:
# read UIC1tag now that plane count is known
fh.seek(tag.valueoffset)
tag.value = read_uic1tag(
fh,
tiff.byteorder,
tag.dtype,
tag.count,
None,
tags[33629].count, # UIC2tag
)
if 50839 in tags:
# decode IJMetadata tag
try:
tags[50839].value = imagej_metadata(
tags[50839].value,
tags[50838].value, # IJMetadataByteCounts
tiff.byteorder,
)
except Exception as exc:
log_warning(
f'TiffPage {self.index}: {exc.__class__.__name__}: {exc}'
)
# BitsPerSample
tag = tags.get(258)
if tag is not None:
if self.bitspersample != 1:
pass # bitspersample was set by ojpeg hack
elif 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]
# SampleFormat
tag = tags.get(339)
if tag is not None:
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 322 in tags: # TileWidth
self.rowsperstrip = None
elif 257 in tags: # ImageLength
if 278 not in tags or tags[278].count > 1: # RowsPerStrip
self.rowsperstrip = self.imagelength
self.rowsperstrip = min(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.photometric == 2 or samplesperpixel > 1: # PHOTOMETRIC.RGB
if self.planarconfig == 1:
self.shaped = (
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.shaped = (
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.shaped = (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 324 in tags: # TileOffsets
self.dataoffsets = tags[324].value
elif 273 in tags: # StripOffsets
self.dataoffsets = tags[273].value
if 325 in tags: # TileByteCounts
self.databytecounts = tags[325].value
elif 279 in tags: # StripByteCounts
self.databytecounts = tags[279].value
else:
self.databytecounts = (
product(self.shape) * (self.bitspersample // 8),
)
if self.compression != 1:
log_warning(
f'TiffPage {self.index}: ByteCounts tag is missing'
)
if imagelength and self.rowsperstrip and not self.is_lsm:
# fix incorrect number of strip bytecounts and offsets
maxstrips = (
int(
math.floor(imagelength + self.rowsperstrip - 1)
/ self.rowsperstrip
)
* self.imagedepth
)
if self.planarconfig == 2:
maxstrips *= self.samplesperpixel
if maxstrips != len(self.databytecounts):
log_warning(
f'TiffPage {self.index}: incorrect StripByteCounts count'
)
self.databytecounts = self.databytecounts[:maxstrips]
if maxstrips != len(self.dataoffsets):
log_warning(
f'TiffPage {self.index}: incorrect StripOffsets count'
)
self.dataoffsets = self.dataoffsets[:maxstrips]
tag = tags.get(42113) # GDAL_NODATA
if tag is not None:
try:
pytype = type(dtype.type(0).item())
self.nodata = pytype(tag.value)
except Exception:
pass
if 65426 in tags and self.is_ndpi:
# use NDPI JPEG McuStarts as tile offsets
mcustarts = tags[65426].value
if 65432 in tags:
# McuStartsHighBytes
high = tags[65432].value.astype('uint64')
high <<= 32
mcustarts = mcustarts.astype('uint64')
mcustarts += high
fh.seek(self.dataoffsets[0])
jpegheader = fh.read(mcustarts[0])
try:
(
self.tilelength,
self.tilewidth,
self.jpegheader,
) = ndpi_jpeg_tile(jpegheader)
except ValueError as exc:
log_warning(
f'TiffPage {self.index}: ndpi_jpeg_tile failed ({exc})'
)
else:
self.databytecounts = (
mcustarts[1:] - mcustarts[:-1]
).tolist() + [self.databytecounts[0] - int(mcustarts[-1])]
self.dataoffsets = (mcustarts + self.dataoffsets[0]).tolist()
@lazyattr
def decode(self):
"""Return decoded segment, its shape, and indices in image.
The decode function is implemeted as a closure.
Parameters
----------
data : bytes
Encoded bytes of a segment (aka strile, strip or tile)
or None for empty segments.
index : int
The index of the segment in the Offsets and Bytecount tag values.
jpegtables : bytes or None
For JPEG compressed segments only, the value of the JPEGTables tag
if any.
Returns
-------
segment : numpy.ndarray
Decoded segment or None for empty segments.
indices : tuple of int
The position of the segment in the image array of normalized shape:
(separate sample, depth, length, width, contig sample).
shape : tuple of int
The shape of the segment: (depth, length, width, contig samples).
The shape of strips depends on their linear index.
Raises ValueError or NotImplementedError if decoding is not supported.
"""
if self.hash in self.parent._master._decoders:
return self.parent._master._decoders[self.hash]
def cache(decode):
self.parent._master._decoders[self.hash] = decode
return decode
if self.dtype is None:
def decode(*args, **kwargs):
raise ValueError(
f'TiffPage {self.index}: data type not supported: '
f'SampleFormat {self.sampleformat}, '
f'{self.bitspersample}-bit'
)
return cache(decode)
if 0 in self.shaped:
def decode(*args, **kwargs):
raise ValueError(f'TiffPage {self.index}: empty image')
return cache(decode)
try:
if self.compression == 1:
decompress = None
else:
decompress = TIFF.DECOMPESSORS[self.compression]
except KeyError as exc:
def decode(*args, exc=str(exc)[1:-1], **kwargs):
raise ValueError(f'TiffPage {self.index}: {exc}')
return cache(decode)
try:
if self.predictor == 1:
unpredict = None
else:
unpredict = TIFF.UNPREDICTORS[self.predictor]
except KeyError as exc:
def decode(*args, exc=str(exc)[1:-1], **kwargs):
raise ValueError(f'TiffPage {self.index}: {exc}')
return cache(decode)
if self.tags.get(339) is not None:
tag = self.tags[339] # SampleFormat
if tag.count != 1 and any(i - tag.value[0] for i in tag.value):
def decode(*args, **kwargs):
raise ValueError(
f'TiffPage {self.index}: '
f'sample formats do not match {tag.value}'
)
return cache(decode)
if self.is_subsampled and (
self.compression not in (6, 7) or self.planarconfig == 2
):
def decode(*args, **kwargs):
raise NotImplementedError(
f'TiffPage {self.index}: chroma subsampling not supported'
)
return cache(decode)
# normalize segments shape to [depth, length, length, contig]
if self.is_tiled:
stshape = [self.tiledepth, self.tilelength, self.tilewidth, 1]
else:
stshape = [1, self.rowsperstrip, self.imagewidth, 1]
if self.planarconfig == 1:
stshape[-1] = self.samplesperpixel
stshape = tuple(stshape)
stdepth, stlength, stwidth, samples = stshape
imdepth, imlength, imwidth, samples = self.shaped[1:]
if self.is_tiled:
width = (imwidth + stwidth - 1) // stwidth
length = (imlength + stlength - 1) // stlength
depth = (imdepth + stdepth - 1) // stdepth
def indices(tileindex):
# return indices and shape of tile in image array
return (
(
tileindex // (width * length * depth),
(tileindex // (width * length)) % depth * stdepth,
(tileindex // width) % length * stlength,
tileindex % width * stwidth,
0,
),
stshape,
)
def reshape(data, indices, shape):
# return reshaped tile
if data is None:
return data
size = shape[0] * shape[1] * shape[2] * shape[3]
if data.size > size:
# decompression / unpacking might return too many bytes
data.shape = -1
data = data[:size]
if data.size == size:
# complete tile
# data might be non-contiguous; cannot reshape inplace
data = data.reshape(shape)
else:
# data fills remaining space
# found in some JPEG/PNG compressed tiles
try:
data = data.reshape(
(
min(imdepth - indices[1], shape[0]),
min(imlength - indices[2], shape[1]),
min(imwidth - indices[3], shape[2]),
samples,
)
)
except ValueError:
# incomplete tile; see gdal issue #1179
log_warning(
f'reshape: incomplete tile {data.shape} {shape}'
)
t = numpy.zeros(size, data.dtype)
size = min(data.size, size)
t[:size] = data[:size]
data = t.reshape(shape)
return data
def pad(data, shape, nodata=self.nodata):
# pad tile to shape
if data is None or data.shape == shape:
return data, shape
padwidth = [(0, i - j) for i, j in zip(shape, data.shape)]
data = numpy.pad(data, padwidth, constant_values=nodata)
return data, data.shape
else:
# strips
length = (imlength + stlength - 1) // stlength
def indices(stripindex):
# return indices and shape of strip in image array
indices = (
stripindex // (length * imdepth),
(stripindex // length) % imdepth * stdepth,
stripindex % length * stlength,
0,
0,
)
shape = (
stdepth,
min(stlength, imlength - indices[2]),
stwidth,
samples,
)
return indices, shape
def reshape(data, indices, shape):
# return reshaped strip
if data is None:
return data
size = shape[0] * shape[1] * shape[2] * shape[3]
if data.size > size:
# decompression / unpacking might return too many bytes
data.shape = -1
data = data[:size]
if data.size == size:
# expected size
data.shape = shape
else:
# should not happen, but try different length
data.shape = shape[0], -1, shape[2], shape[3]
# raise RuntimeError(
# f'invalid strip shape {data.shape} or size {size}'
# )
return data
def pad(data, shape, nodata=self.nodata):
# pad strip length to rowsperstrip
shape = (shape[0], stlength, shape[2], shape[3])
if data is None or data.shape == shape:
return data, shape
padwidth = [
(0, 0),
(0, stlength - data.shape[1]),
(0, 0),
(0, 0),
]
data = numpy.pad(data, padwidth, constant_values=nodata)
return data, data.shape
if self.compression in (6, 7, 34892):
# JPEG needs special handling
if self.fillorder == 2:
log_warning(
f'TiffPage {self.index}: disabling LSB2MSB for JPEG'
)
if unpredict:
log_warning(
f'TiffPage {self.index}: disabling predictor for JPEG'
)
colorspace, outcolorspace = jpeg_decode_colorspace(
self.photometric, self.planarconfig, self.extrasamples
)
def decode(
data,
segmentindex,
jpegtables=None,
jpegheader=None,
_fullsize=False,
bitspersample=self.bitspersample,
colorspace=colorspace,
outcolorspace=outcolorspace,
):
# return decoded segment, its shape, and indices in image
index, shape = indices(segmentindex)
if data is None:
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
data = imagecodecs.jpeg_decode(
data,
bitspersample=bitspersample,
tables=jpegtables,
header=jpegheader,
colorspace=colorspace,
outcolorspace=outcolorspace,
shape=shape[1:3],
)
data = reshape(data, index, shape)
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
return cache(decode)
if self.compression in (33003, 33005, 34712, 34933, 34934, 50001):
# JPEG2000, WEBP, PNG, JPEGXR
# presume codecs always return correct dtype, native byte order...
if self.fillorder == 2:
log_warning(
f'TiffPage {self.index}: disabling LSB2MSB for '
f'compression {self.compression}'
)
if unpredict:
log_warning(
f'TiffPage {self.index}: disabling predictor for '
f'compression {self.compression}'
)
def decode(data, segmentindex, jpegtables=None, _fullsize=False):
# return decoded segment, its shape, and indices in image
index, shape = indices(segmentindex)
if data is None:
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
data = decompress(data)
data = reshape(data, index, shape)
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
return cache(decode)
dtype = numpy.dtype(self.parent.byteorder + self._dtype.char)
if self.bitspersample in (8, 16, 32, 64, 128):
# regular data types
if (self.bitspersample * stwidth * samples) % 8:
raise ValueError(
f'TiffPage {self.index}: data and sample size mismatch'
)
if self.predictor == 3: # PREDICTOR.FLOATINGPOINT
# floating-point horizontal differencing decoder needs
# raw byte order
dtype = numpy.dtype(self._dtype.char)
def unpack(data):
# return numpy array from buffer
try:
# read only numpy array
return numpy.frombuffer(data, dtype)
except ValueError:
# e.g. LZW strips may be missing EOI
bps = self.bitspersample // 8
size = (len(data) // bps) * bps
return numpy.frombuffer(data[:size], dtype)
elif isinstance(self.bitspersample, tuple):
# e.g. RGB 565
def unpack(data):
# return numpy array from packed integers
return unpack_rgb(data, dtype, self.bitspersample)
elif self.bitspersample == 24 and dtype.char == 'f':
# float24
if unpredict is not None:
# floatpred_decode requires numpy.float24, which does not exist
raise NotImplementedError('unpredicting float24 not supported')
def unpack(data, byteorder=self.parent.byteorder):
# return numpy.float32 array from float24
return float24_decode(data, byteorder)
else:
# bilevel and packed integers
def unpack(data):
# return numpy array from packed integers
return packints_decode(
data, dtype, self.bitspersample, stwidth * samples
)
def decode(data, segmentindex, jpegtables=None, _fullsize=False):
# return decoded segment, its shape, and indices in image
index, shape = indices(segmentindex)
if data is None:
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
if self.fillorder == 2:
data = bitorder_decode(data)
if decompress is not None:
# TODO: calculate correct size for packed integers
size = shape[0] * shape[1] * shape[2] * shape[3]
data = decompress(data, out=size * dtype.itemsize)
data = unpack(data)
data = reshape(data, index, shape)
if unpredict is not None:
data = unpredict(data, axis=-2, out=data)
data = data.astype('=' + dtype.char)
if _fullsize:
data, shape = pad(data, shape)
return data, index, shape
return cache(decode)
def segments(
self, lock=None, maxworkers=None, func=None, sort=False, _fullsize=None
):
"""Return iterator over decoded segments in TiffPage.
See the decode function for return values.
"""
keyframe = self.keyframe # self or keyframe
fh = self.parent.filehandle
if lock is None:
lock = fh.lock
if _fullsize is None:
_fullsize = keyframe.is_tiled
decodeargs = {'_fullsize': bool(_fullsize)}
if keyframe.compression in (6, 7, 34892): # JPEG
decodeargs['jpegtables'] = self.jpegtables
decodeargs['jpegheader'] = keyframe.jpegheader
def decode(args, decodeargs=decodeargs, keyframe=keyframe, func=func):
result = keyframe.decode(*args, **decodeargs)
if func is not None:
return func(result)
return result
if maxworkers is None or maxworkers < 1:
maxworkers = keyframe.maxworkers
if maxworkers < 2:
for segment in fh.read_segments(
self.dataoffsets,
self.databytecounts,
lock=lock,
sort=sort,
flat=True,
):
yield decode(segment)
else:
# reduce memory overhead by processing chunks of up to
# ~64 MB of segments because ThreadPoolExecutor.map is not
# collecting iterables lazily
with ThreadPoolExecutor(maxworkers) as executor:
for segments in fh.read_segments(
self.dataoffsets,
self.databytecounts,
lock=lock,
sort=sort,
flat=False,
):
yield from executor.map(decode, segments)
def asarray(self, out=None, squeeze=True, lock=None, maxworkers=None):
"""Read image data from file and return as numpy array.
Raise ValueError if format is not supported.
Parameters
----------
out : numpy.ndarray, str, or file-like object
Buffer where image data are saved.
If None (default), a new array is 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 (default), all length-1 dimensions (except X and Y) are
squeezed out from the array.
If False, the shape of the returned array is the normalized
5-dimensional shape (TiffPage.shaped).
lock : {RLock, NullContext}
A reentrant lock used to synchronize seeks and reads from file.
If None (default), the lock of the parent's filehandle is used.
maxworkers : int or None
Maximum number of threads to concurrently decode strips ot tiles.
If None (default), up to half the CPU cores are used.
See remarks in TiffFile.asarray.
Returns
-------
numpy.ndarray
Numpy array of decompressed, unpredicted, and unpacked image data
read from Strip/Tile Offsets/ByteCounts, formatted according to
shape and dtype metadata found in tags and parameters.
Photometric conversion, pre-multiplied alpha, orientation, and
colorimetry corrections are not applied. Specifically, CMYK images
are not converted to RGB, MinIsWhite images are not inverted,
and color palettes are not applied. Exception are YCbCr JPEG
compressed images, which are converted to RGB.
"""
keyframe = self.keyframe # self or keyframe
if not keyframe.shaped or product(keyframe.shaped) == 0:
return None
fh = self.parent.filehandle
if lock is None:
lock = fh.lock
with lock:
closed = fh.closed
if closed:
fh.open()
if (
isinstance(out, str)
and out == 'memmap'
and keyframe.is_memmappable
):
# direct memory map array in file
with lock:
result = fh.memmap_array(
keyframe.parent.byteorder + keyframe._dtype.char,
keyframe.shaped,
offset=self.dataoffsets[0],
)
elif keyframe.is_contiguous:
# read contiguous bytes to array
if keyframe.is_subsampled:
raise NotImplementedError(
f'TiffPage {self.index}: chroma subsampling not supported'
)
if out is not None:
out = create_output(out, keyframe.shaped, keyframe._dtype)
with lock:
fh.seek(self.dataoffsets[0])
result = fh.read_array(
keyframe.parent.byteorder + keyframe._dtype.char,
product(keyframe.shaped),
out=out,
)
if keyframe.fillorder == 2:
bitorder_decode(result, out=result)
if keyframe.predictor != 1:
# predictors without compression
unpredict = TIFF.UNPREDICTORS[keyframe.predictor]
if keyframe.predictor == 1:
unpredict(result, axis=-2, out=result)
else:
# floatpred cannot decode in-place
out = unpredict(result, axis=-2, out=result)
result[:] = out
elif (
keyframe.jpegheader is not None
and keyframe is self
and self.imagewidth <= 65500
and self.imagelength <= 65500
):
# decode the whole NDPI JPEG strip
with lock:
fh.seek(self.tags[273].value[0]) # StripOffsets
data = fh.read(self.tags[279].value[0]) # StripByteCounts
decompress = TIFF.DECOMPESSORS[self.compression]
result = decompress(
data, bitspersample=self.bitspersample, out=out
)
del data
else:
# decode individual strips or tiles
result = create_output(out, keyframe.shaped, keyframe._dtype)
keyframe.decode # init TiffPage.decode function
def func(decoderesult, keyframe=keyframe, out=out):
# copy decoded segments to output array
segment, (s, d, l, w, _), shape = decoderesult
if segment is None:
segment = keyframe.nodata
else:
segment = segment[
: keyframe.imagedepth - d,
: keyframe.imagelength - l,
: keyframe.imagewidth - w,
]
result[
s, d : d + shape[0], l : l + shape[1], w : w + shape[2]
] = segment
# except IndexError:
# pass # corrupted files e.g. with too many strips
for _ in self.segments(
func=func,
lock=lock,
maxworkers=maxworkers,
sort=True,
_fullsize=False,
):
pass
result.shape = keyframe.shaped
if squeeze:
try:
result.shape = keyframe.shape
except ValueError:
log_warning(
f'TiffPage {self.index}: '
f'failed to reshape {result.shape} to {keyframe.shape}'
)
if closed:
# TODO: file should remain open if an exception occurred above
fh.close()
return result
def aszarr(self, **kwargs):
"""Return image data as zarr storage."""
return ZarrTiffStore(self, **kwargs)
def asrgb(
self,
uint8=False,
alpha=None,
colormap=None,
dmin=None,
dmax=None,
**kwargs,
):
"""Return image data as RGB(A).
Work in progress.
"""
data = self.asarray(**kwargs)
keyframe = self.keyframe # self or keyframe
if keyframe.photometric == TIFF.PHOTOMETRIC.PALETTE:
colormap = keyframe.colormap
if (
colormap.shape[1] < 2 ** keyframe.bitspersample
or keyframe.dtype.char not in 'BH'
):
raise ValueError(
f'TiffPage {self.index}: cannot apply colormap'
)
if uint8:
if colormap.max() > 255:
colormap >>= 8
colormap = colormap.astype('uint8')
if 'S' in keyframe.axes:
data = data[..., 0] if keyframe.planarconfig == 1 else data[0]
data = apply_colormap(data, colormap)
elif keyframe.photometric == TIFF.PHOTOMETRIC.RGB:
if keyframe.extrasamples:
if alpha is None:
alpha = TIFF.EXTRASAMPLE
for i, exs in enumerate(keyframe.extrasamples):
if exs in alpha:
if keyframe.planarconfig == 1:
data = data[..., [0, 1, 2, 3 + i]]
else:
data = data[:, [0, 1, 2, 3 + i]]
break
else:
if keyframe.planarconfig == 1:
data = data[..., :3]
else:
data = data[:, :3]
# TODO: convert to uint8?
elif keyframe.photometric == TIFF.PHOTOMETRIC.MINISBLACK:
raise NotImplementedError
elif keyframe.photometric == TIFF.PHOTOMETRIC.MINISWHITE:
raise NotImplementedError
elif keyframe.photometric == TIFF.PHOTOMETRIC.SEPARATED:
raise NotImplementedError
else:
raise NotImplementedError
return data
def _gettags(self, codes=None, lock=None):
"""Return list of (code, TiffTag)."""
return [
(tag.code, tag)
for tag in self.tags
if codes is None or tag.code in codes
]
def _nextifd(self):
"""Return offset to next IFD from file."""
fh = self.parent.filehandle
tiff = self.parent.tiff
fh.seek(self.offset)
tagno = struct.unpack(tiff.tagnoformat, fh.read(tiff.tagnosize))[0]
fh.seek(self.offset + tiff.tagnosize + tagno * tiff.tagsize)
return struct.unpack(tiff.offsetformat, fh.read(tiff.offsetsize))[0]
def aspage(self):
"""Return self."""
return self
@property
def keyframe(self):
"""Return keyframe, self."""
return self
@keyframe.setter
def keyframe(self, index):
"""Set keyframe, NOP."""
return
@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)
@property
def nbytes(self):
"""Return number of bytes in array."""
return product(self.shape) * self.dtype.itemsize
@lazyattr
def chunks(self):
"""Return shape of tiles or stripes."""
shape = []
if self.tiledepth > 1:
shape.append(self.tiledepth)
if self.is_tiled:
shape.extend((self.tilelength, self.tilewidth))
else:
shape.extend((self.rowsperstrip, self.imagewidth))
if self.planarconfig == 1 and self.samplesperpixel > 1:
shape.append(self.samplesperpixel)
return tuple(shape)
@lazyattr
def chunked(self):
"""Return shape of chunked image."""
shape = []
if self.planarconfig == 2 and self.samplesperpixel > 1:
shape.append(self.samplesperpixel)
if self.is_tiled:
if self.imagedepth > 1:
shape.append(
(self.imagedepth + self.tiledepth - 1) // self.tiledepth
)
shape.append(
(self.imagelength + self.tilelength - 1) // self.tilelength
)
shape.append(
(self.imagewidth + self.tilewidth - 1) // self.tilewidth
)
else:
if self.imagedepth > 1:
shape.append(self.imagedepth)
shape.append(
(self.imagelength + self.rowsperstrip - 1) // self.rowsperstrip
)
shape.append(1)
if self.planarconfig == 1 and self.samplesperpixel > 1:
shape.append(1)
return tuple(shape)
@lazyattr
def hash(self):
"""Return checksum to identify pages in same series.
Pages with the same hash can use the same decode function.
"""
return hash(
self.shaped
+ (
self.parent.byteorder,
self.tilewidth,
self.tilelength,
self.tiledepth,
self.sampleformat,
self.bitspersample,
self.rowsperstrip,
self.fillorder,
self.predictor,
self.extrasamples,
self.photometric,
self.planarconfig,
self.compression,
)
)
@lazyattr
def pages(self):
"""Return sequence of sub-pages, SubIFDs."""
if 330 not in self.tags:
return ()
return TiffPages(self, index=self.index)
@lazyattr
def maxworkers(self):
"""Return maximum number of threads for decoding segments.
Return 0 to disable multi-threading also for stacking pages.
"""
if self.is_contiguous or self.dtype is None:
return 0
if self.compression in (
6,
7,
33003,
33005,
34712,
34892,
34933,
34934,
50001,
):
# image codecs
return min(TIFF.MAXWORKERS, len(self.dataoffsets))
bytecount = product(self.chunks) * self.dtype.itemsize
if bytecount < 2048:
# disable multi-threading for small segments
return 0
if self.compression != 1 or self.fillorder != 1 or self.predictor != 1:
if self.compression == 5 and bytecount < 16384:
# disable multi-threading for small LZW compressed segments
return 0
if len(self.dataoffsets) < 4:
return 1
if self.compression != 1 or self.fillorder != 1 or self.predictor != 1:
if imagecodecs is not None:
return min(TIFF.MAXWORKERS, len(self.dataoffsets))
return 2 # optimum for large number of uncompressed tiles
@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 None
if 322 in self.tags: # TileWidth
if (
self.imagewidth != self.tilewidth
or self.imagelength % self.tilelength
or self.tilewidth % 16
or self.tilelength % 16
):
return None
if (
32997 in self.tags
and 32998 in self.tags # ImageDepth
and ( # TileDepth
self.imagelength != self.tilelength
or self.imagedepth % self.tiledepth
)
):
return None
offsets = self.dataoffsets
bytecounts = self.databytecounts
if len(offsets) == 1:
return offsets[0], bytecounts[0]
if self.is_stk or self.is_lsm:
return offsets[0], sum(bytecounts)
if all(
bytecounts[i] != 0 and offsets[i] + bytecounts[i] == offsets[i + 1]
for i in range(len(offsets) - 1)
):
return offsets[0], sum(bytecounts)
return None
@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_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)
# aligned?
and self.is_contiguous[0] % self.dtype.itemsize == 0
)
def __str__(self, detail=0, width=79):
"""Return string containing information about TiffPage."""
if self.keyframe != self:
return TiffFrame.__str__(self, detail, width)
attr = ''
for name in ('memmappable', 'final', 'contiguous'):
attr = getattr(self, 'is_' + name)
if attr:
attr = name.upper()
break
def tostr(name, skip=1):
obj = getattr(self, name)
try:
value = getattr(obj, 'name')
except AttributeError:
return ''
if obj != skip:
return value
return ''
info = ' '.join(
s.lower()
for s in (
'x'.join(str(i) for i in self.shape),
'{}{}'.format(
TIFF.SAMPLEFORMAT(self.sampleformat).name,
self.bitspersample,
),
' '.join(
i
for i in (
TIFF.PHOTOMETRIC(self.photometric).name,
'REDUCED' if self.is_reduced else '',
'MASK' if self.is_mask else '',
'TILED' if self.is_tiled else '',
tostr('compression'),
tostr('planarconfig'),
tostr('predictor'),
tostr('fillorder'),
)
+ tuple(f.upper() for f in self.flags)
+ (attr,)
if i
),
)
if s
)
info = f'TiffPage {self.index} @{self.offset} {info}'
if detail <= 0:
return info
info = [info, self.tags.__str__(detail + 1, width=width)]
if detail > 1:
for name in ('ndpi',):
name = name + '_tags'
attr = getattr(self, name, False)
if attr:
info.append(
'{}\n{}'.format(
name.upper(),
pformat(attr, width=width, height=detail * 8),
)
)
if detail > 3:
try:
info.append(
'DATA\n{}'.format(
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 {
name.lower()
for name in sorted(TIFF.FILE_FLAGS)
if getattr(self, 'is_' + name)
}
@lazyattr
def andor_tags(self):
"""Return consolidated metadata from Andor tags as dict."""
if not self.is_andor:
return None
result = {'Id': self.tags[4864].value} # AndorId
for tag in self.tags: # list(self.tags.values()):
code = tag.code
if not 4864 < code < 5031:
continue
name = tag.name
name = name[5:] if len(name) > 5 else name
result[name] = tag.value
# del self.tags[code]
return result
@lazyattr
def epics_tags(self):
"""Return consolidated metadata from EPICS areaDetector tags as dict.
Use epics_datetime() to get a datetime object from the epicsTSSec and
epicsTSNsec tags.
"""
if not self.is_epics:
return None
result = {}
for tag in self.tags: # list(self.tags.values()):
code = tag.code
if not 65000 <= code < 65500:
continue
value = tag.value
if code == 65000:
# not a POSIX timestamp
# https://github.com/bluesky/area-detector-handlers/issues/20
result['timeStamp'] = 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 self.tags[code]
return result
@lazyattr
def ndpi_tags(self):
"""Return consolidated metadata from Hamamatsu NDPI as dict."""
# TODO: parse 65449 ini style comments
if not self.is_ndpi:
return None
tags = self.tags
result = {}
for name in ('Make', 'Model', 'Software'):
result[name] = tags[name].value
for code, name in TIFF.NDPI_TAGS.items():
if code in tags:
result[name] = tags[code].value
# del tags[code]
if 'McuStarts' in result:
mcustarts = result['McuStarts']
if 'McuStartsHighBytes' in result:
high = result['McuStartsHighBytes'].astype('uint64')
high <<= 32
mcustarts = mcustarts.astype('uint64')
mcustarts += high
del result['McuStartsHighBytes']
result['McuStarts'] = mcustarts
return result
@lazyattr
def geotiff_tags(self):
"""Return consolidated metadata from GeoTIFF tags as dict."""
if not self.is_geotiff:
return None
tags = self.tags
gkd = tags[34735].value # GeoKeyDirectoryTag
if gkd[0] != 1:
log_warning('GeoTIFF tags: 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]):
try:
keyid, tagid, count, offset = gkd[
4 + index * 4 : index * 4 + 8
]
except Exception as exc:
log_warning(f'GeoTIFF tags: {exc}')
continue
if tagid == 0:
value = offset
else:
try:
value = tags[tagid].value[offset : offset + count]
except KeyError:
log_warning(f'GeoTIFF tags: {tagid} not found')
continue
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
try:
key = geokeys(keyid).name
except ValueError:
key = keyid
result[key] = value
tag = tags.get(33920) # IntergraphMatrixTag
if tag is not None:
value = numpy.array(tag.value)
if len(value) == 16:
value = value.reshape((4, 4)).tolist()
result['IntergraphMatrix'] = value
tag = tags.get(33550) # ModelPixelScaleTag
if tag is not None:
result['ModelPixelScale'] = numpy.array(tag.value).tolist()
tag = tags.get(33922) # ModelTiepointTag
if tag is not None:
value = numpy.array(tag.value).reshape((-1, 6)).squeeze().tolist()
result['ModelTiepoint'] = value
tag = tags.get(34264) # ModelTransformationTag
if tag is not None:
value = numpy.array(tag.value).reshape((4, 4)).tolist()
result['ModelTransformation'] = value
# if 33550 in tags and 33922 in tags:
# sx, sy, sz = tags[33550].value # ModelPixelScaleTag
# tiepoints = tags[33922].value # ModelTiepointTag
# 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
tag = tags.get(50844) # RPCCoefficientTag
if tag is not None:
rpcc = tag.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_reduced(self):
"""Page is reduced image of another image."""
return self.subfiletype & 0b1
@property
def is_multipage(self):
"""Page is part of multi-page image."""
return self.subfiletype & 0b10
@property
def is_mask(self):
"""Page is transparency mask for another image."""
return self.subfiletype & 0b100
@property
def is_mrc(self):
"""Page is part of Mixed Raster Content."""
return self.subfiletype & 0b1000
@property
def is_tiled(self):
"""Page contains tiled image."""
return self.tilewidth > 0 # return 322 in self.tags # TileWidth
@property
def is_subsampled(self):
"""Page contains chroma subsampled image."""
tag = self.tags.get(530) # YCbCrSubSampling
if tag is not None:
return tag.value != (1, 1)
return (
self.compression == 7
and self.planarconfig == 1
and self.photometric in (2, 6)
)
@lazyattr
def is_imagej(self):
"""Return ImageJ description if exists, else None."""
for description in (self.description, self.description1):
if not description:
return None
if description[:7] == 'ImageJ=':
return description
return None
@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 None
if description[:1] == '{' and '"shape":' in description:
return description
if description[:6] == 'shape=':
return description
return None
@property
def is_mdgel(self):
"""Page contains MDFileTag tag."""
return 33445 in self.tags # MDFileTag
@property
def is_mediacy(self):
"""Page contains Media Cybernetics Id tag."""
tag = self.tags.get(50288) # MC_Id
return tag is not None and tag.value[:7] == b'MC TIFF'
@property
def is_stk(self):
"""Page contains UIC2Tag tag."""
return 33629 in self.tags
@property
def is_lsm(self):
"""Page contains CZ_LSMINFO tag."""
return 34412 in self.tags
@property
def is_fluoview(self):
"""Page contains FluoView MM_STAMP tag."""
return 34362 in self.tags
@property
def is_nih(self):
"""Page contains NIHImageHeader tag."""
return 43314 in self.tags
@property
def is_volumetric(self):
"""Page contains SGI ImageDepth tag with value > 1."""
return self.imagedepth > 1
@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 != 0 or self.software != 'MetaSeries':
return False
d = self.description
return d.startswith('<MetaData>') and d.endswith('</MetaData>')
@property
def is_ome(self):
"""Page contains OME-XML in ImageDescription tag."""
if self.index != 0 or not self.description:
return False
return self.description[-4:] == 'OME>' # and [:13] == '<?xml version'
@property
def is_scn(self):
"""Page contains Leica SCN XML in ImageDescription tag."""
if self.index != 0 or not self.description:
return False
return self.description[-6:] == '</scn>'
@property
def is_micromanager(self):
"""Page contains MicroManagerMetadata tag."""
return 51123 in self.tags
@property
def is_andor(self):
"""Page contains Andor Technology tags 4864-5030."""
return 4864 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 37706 in self.tags
@property
def is_fei(self):
"""Page contains FEI_SFEG or FEI_HELIOS tags."""
return 34680 in self.tags or 34682 in self.tags
@property
def is_sem(self):
"""Page contains CZ_SEM tag."""
return 34118 in self.tags
@property
def is_svs(self):
"""Page contains Aperio metadata."""
return self.description[:7] == 'Aperio '
@property
def is_scanimage(self):
"""Page contains ScanImage metadata."""
return (
self.software[:3] == 'SI.'
or self.description[:6] == 'state.'
or 'scanimage.SI' in self.description[-256:]
)
@property
def is_qpi(self):
"""Page contains PerkinElmer tissue images metadata."""
# The ImageDescription tag contains XML with a top-level
# <PerkinElmer-QPI-ImageDescription> element
return self.software[:15] == 'PerkinElmer-QPI'
@property
def is_geotiff(self):
"""Page contains GeoTIFF metadata."""
return 34735 in self.tags # GeoKeyDirectoryTag
@property
def is_tiffep(self):
"""Page contains TIFF/EP metadata."""
return 37398 in self.tags # TIFF/EPStandardID
@property
def is_sis(self):
"""Page contains Olympus SIS metadata."""
return 33560 in self.tags or 33471 in self.tags
@property
def is_ndpi(self):
"""Page contains NDPI metadata."""
return 65420 in self.tags and 271 in self.tags
@property
def is_philips(self):
"""Page contains Philips DP metadata."""
return (
self.software[:10] == 'Philips DP'
and self.description[-13:] == '</DataObject>'
)
@property
def is_eer(self):
"""Page contains EER metadata."""
return (
self.parent.is_bigtiff
and self.compression in (65000, 65001)
and 65001 in self.tags
)
class TiffFrame:
"""Lightweight TIFF image file directory (IFD).
Only a limited number of tag values are read from file.
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 image
data from file, not for introspection of metadata.
"""
__slots__ = (
'index',
'parent',
'offset',
'dataoffsets',
'databytecounts',
'subifds',
'jpegtables',
'_keyframe',
)
is_mdgel = False
pages = ()
# tags = {}
def __init__(
self,
parent,
index,
offset=None,
keyframe=None,
offsets=None,
bytecounts=None,
):
"""Initialize TiffFrame from file or values.
The file handle position must be at the offset to a valid IFD.
"""
self._keyframe = None
self.parent = parent
self.index = index
self.offset = offset
self.subifds = None
self.jpegtables = None
self.dataoffsets = ()
self.databytecounts = ()
if offsets is not None:
# initialize "virtual frame" from offsets and bytecounts
self.dataoffsets = offsets
self.databytecounts = bytecounts
self._keyframe = keyframe
return
if offset is None:
self.offset = parent.filehandle.tell()
else:
parent.filehandle.seek(offset)
if keyframe is None:
tags = {273, 279, 324, 325, 330, 347}
elif keyframe.is_contiguous:
# use databytecounts from keyframe
tags = {256, 273, 324, 330}
self.databytecounts = keyframe.databytecounts
else:
tags = {256, 273, 279, 324, 325, 330, 347}
for code, tag in self._gettags(tags):
if code == 273 or code == 324:
self.dataoffsets = tag.value
elif code == 279 or code == 325:
self.databytecounts = tag.value
elif code == 330:
self.subifds = tag.value
elif code == 347:
self.jpegtables = tag.value
elif code == 256 and keyframe.imagewidth != tag.value:
raise RuntimeError(
f'TiffFrame {self.index} incompatible keyframe'
)
if not self.dataoffsets:
log_warning(f'TiffFrame {self.index}: missing required tags')
self.keyframe = keyframe
def _gettags(self, codes=None, lock=None):
"""Return list of (code, TiffTag) from file."""
fh = self.parent.filehandle
tiff = self.parent.tiff
unpack = struct.unpack
lock = NullContext() if lock is None else lock
tags = []
with lock:
fh.seek(self.offset)
try:
tagno = unpack(tiff.tagnoformat, fh.read(tiff.tagnosize))[0]
if tagno > 4096:
raise TiffFileError(
f'TiffFrame {self.index}: suspicious number of tags'
)
except Exception:
raise TiffFileError(
f'TiffFrame {self.index}: '
f'corrupted page list at offset {self.offset}'
)
tagoffset = self.offset + tiff.tagnosize # fh.tell()
tagsize = tiff.tagsize
tagindex = -tagsize
codeformat = tiff.tagformat1[:2]
tagbytes = fh.read(tagsize * tagno)
for _ in range(tagno):
tagindex += tagsize
code = unpack(codeformat, tagbytes[tagindex : tagindex + 2])[0]
if codes and code not in codes:
continue
try:
tag = TiffTag.fromfile(
self.parent,
tagoffset + tagindex,
tagbytes[tagindex : tagindex + tagsize],
)
except TiffFileError as exc:
log_warning(
f'TiffFrame {self.index}: '
f'{exc.__class__.__name__}: {exc}'
)
continue
tags.append((code, tag))
return tags
def _nextifd(self):
"""Return offset to next IFD from file."""
return TiffPage._nextifd(self)
def aspage(self):
"""Return TiffPage from file."""
if self.offset is None:
raise ValueError(
f'TiffFrame {self.index}: cannot return virtual frame as page'
)
self.parent.filehandle.seek(self.offset)
return TiffPage(self.parent, index=self.index)
def asarray(self, *args, **kwargs):
"""Read image data from file and return as numpy array."""
return TiffPage.asarray(self, *args, **kwargs)
def aszarr(self, **kwargs):
"""Return image data as zarr storage."""
return TiffPage.aszarr(self, **kwargs)
def asrgb(self, *args, **kwargs):
"""Read image data from file and return RGB image as numpy array."""
return TiffPage.asrgb(self, *args, **kwargs)
def segments(self, *args, **kwargs):
"""Return iterator over decoded segments in TiffFrame."""
return TiffPage.segments(self, *args, **kwargs)
@property
def keyframe(self):
"""Return keyframe."""
return self._keyframe
@keyframe.setter
def keyframe(self, keyframe):
"""Set keyframe."""
if self._keyframe == keyframe:
return
if self._keyframe is not None:
raise RuntimeError(
f'TiffFrame {self.index}: cannot reset keyframe'
)
if len(self.dataoffsets) != len(keyframe.dataoffsets):
raise RuntimeError(
f'TiffFrame {self.index}: incompatible keyframe'
)
if keyframe.is_contiguous:
self.databytecounts = keyframe.databytecounts
self._keyframe = keyframe
@property
def is_contiguous(self):
"""Return offset and size of contiguous data, else None."""
# if self._keyframe is None:
# raise RuntimeError(f'TiffFrame {self.index}: keyframe not set')
if self._keyframe.is_contiguous:
return self.dataoffsets[0], self._keyframe.is_contiguous[1]
return None
@property
def is_memmappable(self):
"""Return if page's image data in file can be memory-mapped."""
# if self._keyframe is None:
# raise RuntimeError(f'TiffFrame {self.index}: keyframe not set')
return self._keyframe.is_memmappable
@property
def hash(self):
"""Return checksum to identify pages in same series."""
# if self._keyframe is None:
# raise RuntimeError(f'TiffFrame {self.index}: keyframe not set')
return self._keyframe.hash
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(
f'{self.__class__.__name__!r} object has no attribute {name!r}'
)
def __str__(self, detail=0, width=79):
"""Return string containing information about TiffFrame."""
if self._keyframe is None:
info = ''
kf = None
else:
info = ' '.join(
s
for s in (
'x'.join(str(i) for i in self.shape),
str(self.dtype),
)
)
kf = TiffPage.__str__(self._keyframe, width=width - 11)
if detail > 3:
of = pformat(self.dataoffsets, width=width - 9, height=detail - 3)
bc = pformat(
self.databytecounts, width=width - 13, height=detail - 3
)
info = f'\n Keyframe {kf}\n Offsets {of}\n Bytecounts {bc}'
return f'TiffFrame {self.index} @{self.offset} {info}'
class TiffTag:
"""TIFF tag structure.
Attributes
----------
name : string
Name of tag, TIFF.TAGS[code].
code : int
Decimal code of tag.
dtype : int
Datatype of tag data. One of TIFF.DATATYPES.
count : int
Number of values.
value : various types
Tag data as Python object.
valueoffset : int
Location of value in file.
offset : int
Location of tag structure in file.
All attributes are read-only.
"""
__slots__ = ('offset', 'code', 'dtype', 'count', 'value', 'valueoffset')
def __init__(self, code, dtype, count, value, offset, valueoffset):
"""Initialize TiffTag instance from values."""
self.code = code
self.dtype = TIFF.DATATYPES(dtype)
self.count = count
self.value = value
self.offset = offset
self.valueoffset = valueoffset
@classmethod
def fromfile(cls, parent, offset=None, header=None):
"""Return TiffTag instance read from file."""
fh = parent.filehandle
tiff = parent.tiff
unpack = struct.unpack
if header is None:
if offset is None:
offset = fh.tell()
else:
fh.seek(offset)
header = fh.read(tiff.tagsize)
elif offset is None:
offset = fh.tell()
valueoffset = offset + tiff.offsetsize + 4
code, dtype = unpack(tiff.tagformat1, header[:4])
count, value = unpack(tiff.tagformat2, header[4:])
try:
dataformat = TIFF.DATA_FORMATS[dtype]
except KeyError:
raise TiffFileError(f'unknown tag data type {dtype!r}')
fmt = '{}{}{}'.format(
tiff.byteorder, count * int(dataformat[0]), dataformat[1]
)
size = struct.calcsize(fmt)
if size > tiff.tagoffsetthreshold or code in TIFF.TAG_READERS:
valueoffset = unpack(tiff.offsetformat, value)[0]
if valueoffset < 8 or valueoffset > fh.size - size:
raise TiffFileError('invalid tag value offset')
# if valueoffset % 2:
# log_warning('TiffTag: value does not begin on word boundary')
fh.seek(valueoffset)
if code in TIFF.TAG_READERS:
readfunc = TIFF.TAG_READERS[code]
value = readfunc(
fh, tiff.byteorder, dtype, count, tiff.offsetsize
)
elif dtype == 7 or (count > 1 and dtype == 1):
value = read_bytes(
fh, tiff.byteorder, dtype, count, tiff.offsetsize
)
# elif code in TIFF.TAGS or dtype == 2:
else:
value = unpack(fmt, fh.read(size))
# else:
# value = read_numpy(
# fh, tiff.byteorder, dtype, count, tiff.offsetsize
# )
elif dtype in (1, 7):
# BYTES, UNDEFINED
value = value[:size]
elif (
tiff.version == 42
and tiff.offsetsize == 8
and count == 1
and dtype in (4, 13)
and value[4:] != b'\x00\x00\x00\x00'
):
# NDPI LONG or IFD
# dtype = 16 if dtype == 4 else 18
# dataformat = '1Q'
value = unpack('<Q', value)
else:
value = unpack(fmt, value[:size])
process = (
code not in TIFF.TAG_READERS
and code not in TIFF.TAG_TUPLE
and dtype != 7 # UNDEFINED
)
if process and dtype == 2 and isinstance(value[0], bytes):
# TIFF ASCII fields can contain multiple strings,
# each terminated with a NUL
value = value[0]
try:
value = bytes2str(stripnull(value, first=False).strip())
except UnicodeDecodeError:
log_warning(f'TiffTag {code}: coercing invalid ASCII to bytes')
# dtype = 1
# dataformat = '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 exc:
if code not in (259, 317): # ignore compression/predictor
log_warning(f'TiffTag {code}: {exc}')
if process:
if len(value) == 1:
value = value[0]
return cls(code, dtype, count, value, offset, valueoffset)
@property
def name(self):
"""Return name of tag from TIFF.TAGS registry."""
return TIFF.TAGS.get(self.code, str(self.code))
@property
def dataformat(self):
"""Return data type as Python struct format."""
return TIFF.DATA_FORMATS[self.dtype]
@property
def valuebytecount(self):
"""Return size of value in file."""
return self.count * struct.calcsize(TIFF.DATA_FORMATS[self.dtype])
def overwrite(self, tifffile, value, dtype=None, erase=True):
"""Write new tag value to file and return new TiffTag instance.
The value must be compatible with the struct.pack formats in
TIFF.DATA_FORMATS.
The new packed value is appended to the file if it is longer than the
old value. The old value is zeroed. The file position is left where it
was.
"""
if self.offset < 8 or self.valueoffset < 8:
raise ValueError('cannot rewrite tag at offset < 8')
fh = tifffile.filehandle
tiff = tifffile.tiff
if tiff.version == 42 and tiff.offsetsize == 8:
# TODO: support patching NDPI files
raise NotImplementedError('cannot patch NDPI files')
if value is None:
value = b''
if dtype is None:
dtype = self.dtype
try:
dataformat = TIFF.DATA_FORMATS[dtype]
except KeyError as exc:
try:
dataformat = dtype[-1:]
if dataformat[0] in '<>':
dataformat = dataformat[1:]
dtype = TIFF.DATA_DTYPES[dataformat]
except (KeyError, TypeError):
raise ValueError(f'unknown dtype {dtype}') from exc
if dtype == 2:
# strings
if isinstance(value, str):
# enforce 7-bit ASCII on Unicode strings
try:
value = value.encode('ascii')
except UnicodeEncodeError as exc:
raise ValueError(
'TIFF strings must be 7-bit ASCII'
) from exc
elif not isinstance(value, bytes):
raise ValueError('TIFF strings must be 7-bit ASCII')
if len(value) == 0 or value[-1] != b'\x00':
value += b'\x00'
count = len(value)
value = (value,)
elif isinstance(value, bytes):
# pre-packed binary data
dtsize = struct.calcsize(dataformat)
if len(value) % dtsize:
raise ValueError('invalid packed binary data')
count = len(value) // dtsize
value = (value,)
else:
try:
count = len(value)
except TypeError:
value = (value,)
count = 1
if dtype in (5, 10):
if count < 2 or count % 2:
raise ValueError('invalid RATIONAL value')
count //= 2 # rational
packedvalue = struct.pack(
'{}{}{}'.format(
tiff.byteorder, count * int(dataformat[0]), dataformat[1]
),
*value,
)
newsize = len(packedvalue)
oldsize = self.count * struct.calcsize(TIFF.DATA_FORMATS[self.dtype])
valueoffset = self.valueoffset
pos = fh.tell()
try:
if dtype != self.dtype:
# rewrite data type
fh.seek(self.offset + 2)
fh.write(struct.pack(tiff.byteorder + 'H', dtype))
if oldsize <= tiff.tagoffsetthreshold:
if newsize <= tiff.tagoffsetthreshold:
# inline -> inline: overwrite
fh.seek(self.offset + 4)
fh.write(struct.pack(tiff.tagformat2, count, packedvalue))
else:
# inline -> separate: append to file
fh.seek(0, os.SEEK_END)
valueoffset = fh.tell()
if valueoffset % 2:
# value offset must begin on a word boundary
fh.write(b'\x00')
valueoffset += 1
fh.write(packedvalue)
fh.seek(self.offset + 4)
fh.write(
struct.pack(
tiff.tagformat2,
count,
struct.pack(tiff.offsetformat, valueoffset),
)
)
elif newsize <= tiff.tagoffsetthreshold:
# separate -> inline: erase old value
valueoffset = self.offset + 4 + tiff.offsetsize
fh.seek(self.offset + 4)
fh.write(struct.pack(tiff.tagformat2, count, packedvalue))
if erase:
fh.seek(self.valueoffset)
fh.write(b'\x00' * oldsize)
elif newsize <= oldsize or self.valueoffset + oldsize == fh.size:
# separate -> separate smaller: overwrite, erase remaining
fh.seek(self.offset + 4)
fh.write(struct.pack(tiff.offsetformat, count))
fh.seek(self.valueoffset)
fh.write(packedvalue)
if erase and oldsize - newsize > 0:
fh.write(b'\x00' * (oldsize - newsize))
else:
# separate -> separate larger: erase old value, append to file
if erase:
fh.seek(self.valueoffset)
fh.write(b'\x00' * oldsize)
fh.seek(0, os.SEEK_END)
valueoffset = fh.tell()
if valueoffset % 2:
# value offset must begin on a word boundary
fh.write(b'\x00')
valueoffset += 1
fh.write(packedvalue)
fh.seek(self.offset + 4)
fh.write(
struct.pack(
tiff.tagformat2,
count,
struct.pack(tiff.offsetformat, valueoffset),
)
)
finally:
fh.seek(pos) # must restore file position
return TiffTag(
self.code, dtype, count, value, self.offset, valueoffset
)
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 or self.count != 2:
return
# TODO: test this case; need example file
log_warning(f'TiffTag {self.code}: correcting LSM bitspersample tag')
value = struct.pack('<HH', *self.value)
self.valueoffset = struct.unpack('<I', value)[0]
parent.filehandle.seek(self.valueoffset)
self.value = struct.unpack('<HH', parent.filehandle.read(4))
def __str__(self, detail=0, width=79):
"""Return string containing information about TiffTag."""
height = 1 if detail <= 0 else 8 * detail
dtype = self.dtype.name
if self.count > 1:
dtype += f'[{self.count}]'
name = '|'.join(TIFF.TAGS.getall(self.code, ()))
if name:
name = f'{self.code} {name} @{self.offset}'
else:
name = f'{self.code} @{self.offset}'
line = f'TiffTag {name} {dtype} @{self.valueoffset} '
line = line[:width]
try:
if self.count == 1:
value = enumstr(self.value)
else:
value = pformat(tuple(enumstr(v) for v in self.value))
except Exception:
value = pformat(self.value, width=width, height=height)
if detail <= 0:
line += value
line = line[:width]
else:
line += '\n' + value
return line
class TiffTags:
"""Multidict like interface to TiffTag instances in TiffPage.
Differences to a regular dict:
* values are instances of TiffTag.
* keys are TiffTag.code (int).
* multiple values can be stored per key.
* can be indexed with TiffTag.name (str), although slower than by key.
* iter() returns values instead of keys.
* values() and items() contain all values sorted by offset stored in file.
* len() returns the number of all values.
* get() takes an optional index argument.
* some functions are not implemented, e.g. update, setdefault, pop.
"""
__slots__ = ('_dict', '_list')
def __init__(self):
"""Initialize empty instance."""
self._dict = {}
self._list = [self._dict]
def add(self, tag):
"""Add a tag."""
code = tag.code
for d in self._list:
if code not in d:
d[code] = tag
break
else:
self._list.append({code: tag})
def keys(self):
"""Return new view of all codes."""
return self._dict.keys()
def values(self):
"""Return all tags in order they are stored in file."""
tags = (t for d in self._list for t in d.values())
return sorted(tags, key=lambda t: t.offset)
def items(self):
"""Return all (code, tag) pairs in order tags are stored in file."""
items = (i for d in self._list for i in d.items())
return sorted(items, key=lambda i: i[1].offset)
def get(self, key, default=None, index=None):
"""Return tag of code or name if exists, else default."""
if index is None:
if key in self._dict:
return self._dict[key]
if not isinstance(key, str):
return default
index = 0
try:
tags = self._list[index]
except IndexError:
return default
if key in tags:
return tags[key]
if not isinstance(key, str):
return default
for tag in tags.values():
if tag.name == key:
return tag
return default
def getall(self, key, default=None):
"""Return list of all tags of code or name if exists, else default."""
result = []
for tags in self._list:
if key in tags:
result.append(tags[key])
else:
break
if result:
return result
if not isinstance(key, str):
return default
for tags in self._list:
for tag in tags.values():
if tag.name == key:
result.append(tag)
break
if not result:
break
return result if result else default
def __getitem__(self, key):
"""Return first tag of code or name. Raise KeyError if not found."""
if key in self._dict:
return self._dict[key]
if not isinstance(key, str):
raise KeyError(key)
for tag in self._dict.values():
if tag.name == key:
return tag
raise KeyError(key)
def __setitem__(self, code, tag):
"""Add a tag."""
self.add(tag)
def __delitem__(self, key):
"""Delete all tags of code or name."""
found = False
for tags in self._list:
if key in tags:
found = True
del tags[key]
else:
break
if found:
return None
if not isinstance(key, str):
raise KeyError(key)
for tags in self._list:
for tag in tags.values():
if tag.name == key:
del tags[tag.code]
found = True
break
else:
break
if not found:
raise KeyError(key)
return None
def __contains__(self, item):
"""Return if tag is in map."""
if item in self._dict:
return True
if not isinstance(item, str):
return False
for tag in self._dict.values():
if tag.name == item:
return True
return False
def __iter__(self):
"""Return iterator over all tags."""
return iter(self.values())
def __len__(self):
"""Return number of tags."""
size = 0
for d in self._list:
size += len(d)
return size
def __str__(self, detail=0, width=79):
"""Return string with information about TiffTags."""
info = []
tlines = []
vlines = []
for tag in self:
value = tag.__str__(width=width + 1)
tlines.append(value[:width].strip())
if detail > 0 and len(value) > width:
if detail < 2 and tag.code in (273, 279, 324, 325):
value = pformat(tag.value, width=width, height=detail * 4)
else:
value = pformat(tag.value, width=width, height=detail * 12)
vlines.append(f'{tag.name}\n{value}')
info.append('\n'.join(tlines))
if detail > 0 and vlines:
info.append('\n')
info.append('\n\n'.join(vlines))
return '\n'.join(info)
class TiffTagRegistry:
"""Registry of TIFF tag codes and names.
The registry allows to look up tag codes and names by indexing with names
and codes respectively.
One tag code may be registered with several names, e.g. 34853 is used for
GPSTag or OlympusSIS2.
Different tag codes may be registered with the same name, e.g. 37387 and
41483 are both named FlashEnergy.
"""
__slots__ = ('_dict', '_list')
def __init__(self, arg):
self._dict = {}
self._list = [self._dict]
self.update(arg)
def update(self, arg):
"""Add codes and names from sequence or dict to registry."""
if isinstance(arg, TiffTagRegistry):
self._list.extend(arg._list)
return
if isinstance(arg, dict):
arg = arg.items()
for code, name in arg:
self.add(code, name)
def add(self, code, name):
"""Add code and name to registry."""
for d in self._list:
if code in d and d[code] == name:
break
if code not in d and name not in d:
d[code] = name
d[name] = code
break
else:
self._list.append({code: name, name: code})
def items(self):
"""Return all registry items as (code, name)."""
items = (
i for d in self._list for i in d.items() if isinstance(i[0], int)
)
return sorted(items, key=lambda i: i[0])
def get(self, key, default=None):
"""Return first code/name if exists, else default."""
for d in self._list:
if key in d:
return d[key]
return default
def getall(self, key, default=None):
"""Return list of all codes/names if exists, else default."""
result = [d[key] for d in self._list if key in d]
return result if result else default
def __getitem__(self, key):
"""Return first code/name. Raise KeyError if not found."""
for d in self._list:
if key in d:
return d[key]
raise KeyError(key)
def __delitem__(self, key):
"""Delete all tags of code or name."""
found = False
for d in self._list:
if key in d:
found = True
value = d[key]
del d[key]
del d[value]
if not found:
raise KeyError(key)
def __contains__(self, item):
"""Return if code or name is in registry."""
for d in self._list:
if item in d:
return True
return False
def __iter__(self):
"""Return iterator over all items in registry."""
return iter(self.items())
def __len__(self):
"""Return number of registered tags."""
size = 0
for d in self._list:
size += len(d)
return size // 2
def __str__(self):
"""Return string with information about TiffTags."""
return 'TiffTagRegistry(((\n {}\n))'.format(
',\n '.join(f'({code}, {name!r})' for code, name in self.items())
)
class TiffPageSeries:
"""Series of TIFF pages with compatible shape and data type.
Attributes
----------
pages : list of TiffPage
Sequence of TiffPages in series.
dtype : numpy.dtype
Data type (native byte order) of the image array in series.
shape : tuple
Dimensions of the image array in series.
axes : str
Labels of axes in shape. See TIFF.AXES_LABELS.
offset : int or None
Position of image data in file if memory-mappable, else None.
levels : list of TiffPageSeries
Pyramid levels. levels[0] is 'self'.
"""
def __init__(
self,
pages,
shape=None,
dtype=None,
axes=None,
parent=None,
name=None,
transform=None,
kind=None,
truncated=False,
multifile=False,
squeeze=True,
):
"""Initialize instance."""
self.index = 0
self._pages = pages # might contain only first of contiguous pages
self.levels = [self]
if shape is None:
shape = pages[0].shape
if axes is None:
axes = pages[0].axes
if dtype is None:
dtype = pages[0].dtype
self.set_shape_axes(shape, axes, squeeze)
self.dtype = numpy.dtype(dtype)
self.kind = kind if kind else ''
self.name = name if name else ''
self.transform = transform
self.keyframe = next(p.keyframe for p in pages if p is not None)
self.is_multifile = bool(multifile)
if parent:
self.parent = parent
elif pages:
self.parent = self.keyframe.parent
else:
self.parent = None
if not truncated and len(pages) == 1:
s = product(pages[0].shape)
if s > 0:
self._len = int(product(self.shape) // s)
else:
self._len = len(pages)
else:
self._len = len(pages)
def set_shape_axes(self, shape, axes, squeeze=True):
"""Set shape and axes."""
shape = tuple(shape)
axes = ''.join(axes)
# expanded shape according to metadata
self._shape_expanded = shape
self._axes_expanded = axes
# squeezed shape and axes
self._shape_squeezed, self._axes_squeezed = squeeze_axes(shape, axes)
# default shape and axes returned by asarray
self.shape = self._shape_squeezed if squeeze else self._shape_expanded
self.axes = self._axes_squeezed if squeeze else self._axes_expanded
def get_shape(self, squeeze=None):
"""Return default, squeezed, or expanded shape."""
if squeeze is None:
return self.shape
return self._shape_squeezed if squeeze else self._shape_expanded
def get_axes(self, squeeze=None):
"""Return default, squeezed, or expanded axes."""
if squeeze is None:
return self.axes
return self._axes_squeezed if squeeze else self._axes_expanded
def asarray(self, level=None, **kwargs):
"""Return image data from series of TIFF pages as numpy array."""
if level is not None:
return self.levels[level].asarray(**kwargs)
if self.parent:
result = self.parent.asarray(series=self, **kwargs)
if self.transform is not None:
result = self.transform(result)
return result
return None
def aszarr(self, level=None, **kwargs):
"""Return image data from series of TIFF pages as zarr storage."""
if self.parent:
return ZarrTiffStore(self, level=level, **kwargs)
return None
@lazyattr
def offset(self):
"""Return offset to series data in file, if any."""
if not self._pages:
return None
pos = 0
for page in self._pages:
if page is None:
return None
if not page.is_final:
return None
if not pos:
pos = page.is_contiguous[0] + page.is_contiguous[1]
continue
if pos != page.is_contiguous[0]:
return None
pos += page.is_contiguous[1]
page = self._pages[0]
offset = page.is_contiguous[0]
if (page.is_imagej or page.is_shaped or page.is_stk) and len(
self._pages
) == 1:
# truncated files
return offset
if pos == offset + product(self.shape) * self.dtype.itemsize:
return offset
return None
@property
def is_pyramidal(self):
"""Return if series contains several levels."""
return len(self.levels) > 1
@property
def ndim(self):
"""Return number of array dimensions."""
return len(self.shape)
@property
def size(self):
"""Return number of elements in array."""
return int(product(self.shape))
@property
def pages(self):
"""Return sequence of all pages in series."""
# a workaround to keep the old interface working
return self
def _getitem(self, key):
"""Return specified page of series from cache or file."""
key = int(key)
if key < 0:
key %= self._len
if len(self._pages) == 1 and 0 < key < self._len:
index = self._pages[0].index
return self.parent.pages._getitem(index + key)
return self._pages[key]
def __getitem__(self, key):
"""Return specified page(s)."""
getitem = self._getitem
if isinstance(key, (int, numpy.integer)):
return getitem(key)
if isinstance(key, slice):
return [getitem(i) for i in range(*key.indices(self._len))]
if isinstance(key, Iterable):
return [getitem(k) for k in key]
raise TypeError('key must be an integer, slice, or iterable')
def __iter__(self):
"""Return iterator over pages in series."""
if len(self._pages) == self._len:
yield from self._pages
else:
pages = self.parent.pages
index = self._pages[0].index
for i in range(self._len):
yield pages[index + i]
def __len__(self):
"""Return number of pages in series."""
return self._len
def __str__(self):
"""Return string with information about TiffPageSeries."""
s = ' '.join(
s
for s in (
snipstr(f'{self.name!r}', 20) if self.name else '',
'x'.join(str(i) for i in self.shape),
str(self.dtype),
self.axes,
self.kind,
(f'{len(self.levels)} Levels') if self.is_pyramidal else '',
f'{len(self)} Pages',
(f'@{self.offset}') if self.offset else '',
)
if s
)
return f'TiffPageSeries {self.index} {s}'
class ZarrStore(MutableMapping):
"""Zarr storage base class.
ZarrStore instances must be closed using the 'close' method, which is
automatically called when using the 'with' context manager.
https://zarr.readthedocs.io/en/stable/spec/v2.html
https://forum.image.sc/t/multiscale-arrays-v0-1/37930
"""
def __init__(self, fillvalue=None, chunkmode=None):
"""Initialize ZarrStore."""
self._store = {}
self._fillvalue = 0 if fillvalue is None else fillvalue
if chunkmode is None:
self._chunkmode = TIFF.CHUNKMODE(0)
else:
self._chunkmode = enumarg(TIFF.CHUNKMODE, chunkmode)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def __del__(self):
self.close()
def close(self):
"""Close ZarrStore."""
def flush(self):
"""Flush ZarrStore."""
raise PermissionError('ZarrStore is read-only')
def clear(self):
"""Clear ZarrStore."""
raise PermissionError('ZarrStore is read-only')
def keys(self):
"""Return keys in ZarrStore."""
return self._store.keys()
def items(self):
"""Return items in ZarrStore."""
return self._store.items()
def values(self):
"""Return values in ZarrStore."""
return self._store.values()
def __iter__(self):
return iter(self._store.keys())
def __len__(self):
return len(self._store)
def __delitem__(self, key):
raise PermissionError('ZarrStore is read-only')
def __contains__(self, key):
return key in self._store
def __setitem__(self, key, value):
raise PermissionError('ZarrStore is read-only')
def __getitem__(self, key):
if key in self._store:
return self._store[key]
return self._getitem(key)
def _getitem(self, key):
"""Return chunk from file."""
raise NotImplementedError
@property
def is_multiscales(self):
"""Return if ZarrStore is multiscales."""
return b'multiscales' in self._store['.zattrs']
@staticmethod
def _empty_chunk(shape, dtype, fillvalue):
"""Return empty chunk."""
if fillvalue is None or fillvalue == 0:
return bytes(product(shape) * dtype.itemsize)
chunk = numpy.empty(shape, dtype)
chunk[:] = fillvalue
return chunk # .tobytes()
@staticmethod
def _dtype(dtype):
"""Return dtype as string with native byte order."""
if dtype.itemsize == 1:
byteorder = '|'
else:
byteorder = {'big': '>', 'little': '<'}[sys.byteorder]
return byteorder + dtype.str[1:]
@staticmethod
def _json(obj):
"""Serialize obj to a JSON formatted string."""
return json.dumps(
obj,
indent=1,
sort_keys=True,
ensure_ascii=True,
separators=(',', ': '),
).encode('ascii')
@staticmethod
def _value(value, dtype):
"""Return value which is serializable to JSON."""
if value is None:
return value
if dtype.kind == 'b':
return bool(value)
if dtype.kind in 'ui':
return int(value)
if dtype.kind == 'f':
if numpy.isnan(value):
return 'NaN'
if numpy.isposinf(value):
return 'Infinity'
if numpy.isneginf(value):
return '-Infinity'
return float(value)
if dtype.kind in 'c':
value = numpy.array(value, dtype)
return (
ZarrStore._value(value.real, dtype.type().real.dtype),
ZarrStore._value(value.imag, dtype.type().imag.dtype),
)
return value
class ZarrTiffStore(ZarrStore):
"""Zarr storage interface to image data in TiffPage or TiffPageSeries.
ZarrTiffStore instances are using a TiffFile instance for reading and
decoding chunks. Therefore ZarrTiffStore instances cannot be pickled.
"""
def __init__(
self,
arg,
level=None,
chunkmode=None,
fillvalue=None,
lock=None,
squeeze=None,
_openfiles=None,
):
"""Initialize Zarr storage from TiffPage or TiffPageSeries."""
super().__init__(fillvalue=fillvalue, chunkmode=chunkmode)
if self._chunkmode not in (0, 2):
raise NotImplementedError(f'{self._chunkmode!r} not implemented')
self._squeeze = None if squeeze is None else bool(squeeze)
self._transform = getattr(arg, 'transform', None)
self._data = getattr(arg, 'levels', [TiffPageSeries([arg])])
if level is not None:
self._data = [self._data[level]]
if lock is None:
fh = self._data[0].keyframe.parent._master.filehandle
fh.lock = True
lock = fh.lock
self._filecache = FileCache(size=_openfiles, lock=lock)
if len(self._data) > 1:
# multiscales
self._store['.zgroup'] = ZarrStore._json({'zarr_format': 2})
self._store['.zattrs'] = ZarrStore._json(
{
'multiscales': [
{
'datasets': [
{'path': str(i)}
for i in range(len(self._data))
],
'metadata': {},
'name': arg.name,
# 'type': 'gaussian',
'version': '0.1',
}
]
}
)
for level, series in enumerate(self._data):
series.keyframe.decode # cache decode function
shape = series.get_shape(squeeze)
dtype = series.dtype
if fillvalue is None:
self._fillvalue = fillvalue = series.keyframe.nodata
if self._chunkmode:
chunks = series.keyframe.shape
else:
chunks = series.keyframe.chunks
self._store[f'{level}/.zarray'] = ZarrStore._json(
{
'zarr_format': 2,
'shape': shape,
'chunks': ZarrTiffStore._chunks(chunks, shape),
'dtype': ZarrStore._dtype(dtype),
'compressor': None,
'fill_value': ZarrStore._value(fillvalue, dtype),
'order': 'C',
'filters': None,
}
)
else:
series = self._data[0]
series.keyframe.decode # cache decode function
shape = series.get_shape(squeeze)
dtype = series.dtype
if fillvalue is None:
self._fillvalue = fillvalue = series.keyframe.nodata
if self._chunkmode:
chunks = series.keyframe.shape
else:
chunks = series.keyframe.chunks
self._store['.zattrs'] = ZarrStore._json({})
self._store['.zarray'] = ZarrStore._json(
{
'zarr_format': 2,
'shape': shape,
'chunks': ZarrTiffStore._chunks(chunks, shape),
'dtype': ZarrStore._dtype(dtype),
'compressor': None,
'fill_value': ZarrStore._value(fillvalue, dtype),
'order': 'C',
'filters': None,
}
)
def close(self):
"""Close ZarrTiffStore."""
if hasattr(self, '_filecache'):
self._filecache.clear()
def write_fsspec(self, arg, url, compressors=None, version=None):
"""Write fsspec ReferenceFileSystem as JSON to file.
Url is the remote location of the TIFF file without the file name(s).
Raise ValueError if TIFF store can not be represented as
ReferenceFileSystem due to features that are not supported by zarr
or numcodecs:
* compressors, e.g. CCITT
* filters, e.g. predictors, bitorder reversal, packed integers
* dtypes, e.g. float24
* JPEGTables in multi-page files
* incomplete chunks, e.g. if imagelength % rowsperstrip != 0
Files containing incomplete tiles may fail at runtime.
https://github.com/intake/fsspec-reference-maker
"""
compressors = {
1: None,
8: 'zlib',
32946: 'zlib',
34925: 'lzma',
50000: 'zstd',
5: 'imagecodecs_lzw',
7: 'imagecodecs_jpeg',
32773: 'imagecodecs_packbits',
33003: 'imagecodecs_jpeg2k',
33005: 'imagecodecs_jpeg2k',
34712: 'imagecodecs_jpeg2k',
34887: 'imagecodecs_lerc',
34892: 'imagecodecs_jpeg', # DNG lossy
34933: 'imagecodecs_png',
34934: 'imagecodecs_jpegxr',
50001: 'imagecodecs_webp',
**({} if compressors is None else compressors),
}
for series in self._data:
errormsg = ' not supported by the fsspec ReferenceFileSystem'
keyframe = series.keyframe
if keyframe.compression not in compressors:
raise ValueError(f'{keyframe.compression!r} is' + errormsg)
if keyframe.predictor != 1:
raise ValueError(f'{keyframe.predictor!r} is' + errormsg)
if keyframe.fillorder != 1:
raise ValueError(f'{keyframe.fillorder!r} is' + errormsg)
if keyframe.sampleformat not in (1, 2, 3, 6):
raise ValueError(f'{keyframe.sampleformat!r} is' + errormsg)
if keyframe.bitspersample not in (
8,
16,
32,
64,
128,
) and keyframe.compression not in (
7,
34892,
): # JPEG
raise ValueError(
f'BitsPerSample {keyframe.bitspersample} is' + errormsg
)
if (
not self._chunkmode
and not keyframe.is_tiled
and keyframe.imagelength % keyframe.rowsperstrip
):
raise ValueError('incomplete chunks are' + errormsg)
if self._chunkmode and not keyframe.is_final:
raise ValueError(f'{self._chunkmode!r} is' + errormsg)
if keyframe.jpegtables is not None and len(series.pages) > 1:
raise ValueError(
'JPEGTables in multi-page files are' + errormsg
)
if url is None:
url = ''
elif url and url[-1] != '/':
url += '/'
byteorder = '<' if sys.byteorder == 'big' else '>'
if (
self._data[0].keyframe.parent.byteorder != byteorder
or self._data[0].keyframe.dtype.itemsize == 1
):
byteorder = None
refs = dict()
if version == 1:
refs['version'] = 1
refs['templates'] = {}
refs['gen'] = []
templates = {}
if self._data[0].is_multifile:
i = 0
for page in self._data[0].pages:
if page is None:
continue
fname = keyframe.parent.filehandle.name
if fname in templates:
continue
key = f'u{i}'
templates[fname] = '{{%s}}' % key
refs['templates'][key] = url + fname
i += 1
else:
fname = self._data[0].keyframe.parent.filehandle.name
key = 'u'
templates[fname] = '{{%s}}' % key
refs['templates'][key] = url + fname
refs['refs'] = refzarr = dict()
else:
refzarr = refs
for key, value in self._store.items():
if '.zarray' in key:
level = int(key.split('/')[0]) if '/' in key else 0
keyframe = self._data[level].keyframe
value = json.loads(value)
codec_id = compressors[keyframe.compression]
if codec_id == 'imagecodecs_jpeg':
# TODO: handle JPEG colorspaces
tables = keyframe.jpegtables
if tables is not None:
import base64
tables = base64.b64encode(tables).decode()
header = keyframe.jpegheader
if header is not None:
import base64
header = base64.b64encode(header).decode()
colorspace_jpeg, colorspace_data = jpeg_decode_colorspace(
keyframe.photometric,
keyframe.planarconfig,
keyframe.extrasamples,
)
value['compressor'] = {
'id': codec_id,
'tables': tables,
'header': header,
'bitspersample': keyframe.bitspersample,
'colorspace_jpeg': colorspace_jpeg,
'colorspace_data': colorspace_data,
}
elif codec_id is not None:
value['compressor'] = {'id': codec_id}
if byteorder is not None:
value['dtype'] = byteorder + value['dtype'][1:]
value = ZarrTiffStore._json(value)
refzarr[key] = value.decode()
if hasattr(arg, 'write'):
fh = arg
else:
fh = open(arg, 'w')
if version == 1:
fh.write(json.dumps(refs, indent=1).rsplit('}"', 1)[0] + '}"')
indent = ' '
else:
fh.write(json.dumps(refs, indent=1)[:-2])
indent = ' '
for key, value in self._store.items():
if '.zarray' in key:
value = json.loads(value)
shape = value['shape']
chunks = value['chunks']
level = (key.split('/')[0] + '/') if '/' in key else ''
for chunkindex in ZarrTiffStore._ndindex(shape, chunks):
key = level + chunkindex
keyframe, page, _, offset, bytecount = self._parse_key(key)
if page and self._chunkmode and offset is None:
offset = page.dataoffsets[0]
bytecount = keyframe.nbytes
if offset and bytecount:
fname = keyframe.parent.filehandle.name
if version == 1:
fname = templates[fname]
else:
fname = f'{url}{fname}'
fh.write(
f',\n{indent}"{key}": '
f'["{fname}", {offset}, {bytecount}]'
)
if version == 1:
fh.write('\n }')
fh.write('\n}')
if not hasattr(arg, 'write'):
fh.close()
def _getitem(self, key):
"""Return chunk from file."""
keyframe, page, chunkindex, offset, bytecount = self._parse_key(key)
if self._chunkmode:
chunks = keyframe.shape
else:
chunks = keyframe.chunks
if page is None or offset == 0 or bytecount == 0:
chunk = ZarrStore._empty_chunk(
chunks, keyframe.dtype, self._fillvalue
)
if self._transform is not None:
chunk = self._transform(chunk)
return chunk
if self._chunkmode and offset is None:
chunk = page.asarray(lock=self._filecache.lock) # maxworkers=1 ?
if self._transform is not None:
chunk = self._transform(chunk)
return chunk
chunk = self._filecache.read(page.parent.filehandle, offset, bytecount)
decodeargs = {'_fullsize': True}
if page.jpegtables is not None:
decodeargs['jpegtables'] = page.jpegtables
if keyframe.jpegheader is not None:
decodeargs['jpegheader'] = keyframe.jpegheader
chunk = keyframe.decode(chunk, chunkindex, **decodeargs)[0]
if self._transform is not None:
chunk = self._transform(chunk)
if chunk.size != product(chunks):
raise RuntimeError
return chunk # .tobytes()
def _parse_key(self, key):
"""Return keyframe, page, index, offset, and bytecount from key."""
if len(self._data) > 1:
# multiscales
level, key = key.split('/')
series = self._data[int(level)]
else:
series = self._data[0]
keyframe = series.keyframe
pageindex, chunkindex = self._indices(key, series)
if pageindex > 0 and len(series) == 1:
# truncated ImageJ, STK, or shaped
if series.offset is None:
raise RuntimeError('truncated series is not contiguous')
page = series[0]
if page is None:
return keyframe, None, chunkindex, 0, 0
offset = pageindex * page.size * page.dtype.itemsize
offset += page.dataoffsets[chunkindex]
if self._chunkmode:
bytecount = page.size * page.dtype.itemsize
return page.keyframe, page, chunkindex, offset, bytecount
elif self._chunkmode:
page = series[pageindex]
if page is None:
return keyframe, None, None, 0, 0
return page.keyframe, page, None, None, None
else:
page = series[pageindex]
if page is None:
return keyframe, None, chunkindex, 0, 0
offset = page.dataoffsets[chunkindex]
bytecount = page.databytecounts[chunkindex]
return page.keyframe, page, chunkindex, offset, bytecount
def _indices(self, key, series):
"""Return page and strile indices from zarr chunk index."""
keyframe = series.keyframe
shape = series.get_shape(self._squeeze)
indices = [int(i) for i in key.split('.')]
assert len(indices) == len(shape)
if self._chunkmode:
chunked = (1,) * len(keyframe.shape)
else:
chunked = keyframe.chunked
p = 1
for i, s in enumerate(shape[::-1]):
p *= s
if p == keyframe.size:
i = len(indices) - i - 1
frames_indices = indices[:i]
strile_indices = indices[i:]
frames_chunked = shape[:i]
strile_chunked = list(shape[i:]) # updated later
break
else:
raise RuntimeError
if len(strile_chunked) == len(keyframe.shape):
strile_chunked = chunked
else:
# get strile_chunked including singleton dimensions
i = len(strile_indices) - 1
j = len(keyframe.shape) - 1
while True:
if strile_chunked[i] == keyframe.shape[j]:
strile_chunked[i] = chunked[j]
i -= 1
j -= 1
elif strile_chunked[i] == 1:
i -= 1
else:
raise RuntimeError('shape does not match page shape')
if i < 0 or j < 0:
break
assert product(strile_chunked) == product(chunked)
if len(frames_indices) > 0:
frameindex = int(
numpy.ravel_multi_index(frames_indices, frames_chunked)
)
else:
frameindex = 0
if len(strile_indices) > 0:
strileindex = int(
numpy.ravel_multi_index(strile_indices, strile_chunked)
)
else:
strileindex = 0
return frameindex, strileindex
@staticmethod
def _chunks(chunks, shape):
"""Return chunks with same length as shape."""
ndim = len(shape)
if ndim == 0:
return () # empty array
if 0 in shape:
return (1,) * ndim
newchunks = []
i = ndim - 1
j = len(chunks) - 1
while True:
if j < 0:
newchunks.append(1)
i -= 1
elif shape[i] > 1 and chunks[j] > 1:
newchunks.append(chunks[j])
i -= 1
j -= 1
elif shape[i] == chunks[j]: # both 1
newchunks.append(1)
i -= 1
j -= 1
elif shape[i] == 1:
newchunks.append(1)
i -= 1
elif chunks[j] == 1:
newchunks.append(1)
j -= 1
else:
raise RuntimeError
if i < 0 or ndim == len(newchunks):
break
# assert ndim == len(newchunks)
return tuple(newchunks[::-1])
@staticmethod
def _ndindex(shape, chunks):
"""Return iterator over all chunk index strings."""
assert len(shape) == len(chunks)
chunked = tuple(
i // j + (1 if i % j else 0) for i, j in zip(shape, chunks)
)
for indices in numpy.ndindex(chunked):
yield '.'.join(str(index) for index in indices)
class ZarrFileStore(ZarrStore):
"""Zarr storage interface to image data in TiffSequence."""
def __init__(self, arg, fillvalue=None, chunkmode=None, **kwargs):
"""Initialize Zarr storage from FileSequence."""
super().__init__(fillvalue=fillvalue, chunkmode=chunkmode)
if self._chunkmode not in (0, 3):
raise NotImplementedError(f'{self._chunkmode!r} not implemented')
if not isinstance(arg, FileSequence):
raise TypeError('not a FileSequence')
if arg._container:
raise NotImplementedError('cannot open container as zarr storage')
image = arg.imread(arg.files[0], **kwargs)
dtype = image.dtype
chunks = image.shape
shape = arg.shape + chunks
chunks = (1,) * len(arg.shape) + chunks
self._store['.zattrs'] = ZarrStore._json({})
self._store['.zarray'] = ZarrStore._json(
{
'zarr_format': 2,
'shape': shape,
'chunks': chunks,
'dtype': ZarrStore._dtype(dtype),
'compressor': None,
'fill_value': ZarrStore._value(fillvalue, dtype),
'order': 'C',
'filters': None,
}
)
self._kwargs = kwargs
self._imread = arg.imread
self._lookup = dict(zip(arg.indices, arg.files))
self._chunks = image.shape
self._dtype = image.dtype
self._cache = {arg.indices[0]: image} # TODO: cache MRU number chunks
def _getitem(self, key):
"""Return chunk from file."""
indices = tuple(int(i) for i in key.split('.'))
indices = indices[: -len(self._chunks)]
if indices in self._cache:
return self._cache[indices]
self._cache.clear()
filename = self._lookup.get(indices, None)
if filename is None:
chunk = ZarrStore._empty_chunk(
self._chunks, self._dtype, self._fillvalue
)
else:
chunk = self._imread(filename, **self._kwargs).tobytes()
self._cache[indices] = chunk
return chunk
def close(self):
"""Clear chunk cache."""
self._cache.clear()
def write_fsspec(self, arg, url, compressors=None, version=None):
"""Write fsspec ReferenceFileSystem as JSON to file."""
raise NotImplementedError
class FileSequence:
"""Series of files containing array data of compatible shape and data type.
Attributes
----------
files : list
List of file names.
shape : tuple
Shape of file series. Excludes shape of individual arrays.
axes : str
Labels of axes in shape.
indices : tuple of tuples
ND indices of files in shape.
"""
def __init__(
self,
imread,
files,
container=None,
sort=None,
pattern=None,
axesorder=None,
):
r"""Initialize instance from multiple files.
Parameters
----------
imread : function or class
Array read function or class with asarray function returning numpy
array from single file.
files : str, path-like, or sequence thereof
Glob filename pattern or sequence of file names. Default: \*.
Binary streams are not supported.
container : str or container instance
Name or open instance of ZIP file in which files are stored.
sort : function
Sort function used to sort file names when 'files' is a pattern.
The default (None) is natural_sorted. Use sort=False to disable
sorting.
pattern : str
Regular expression pattern that matches axes and sequence indices
in file names. By default (None), no pattern matching is performed.
Axes can be specified by matching groups preceding the index groups
in the file name, be provided as group names for the index groups,
or be omitted. The predefined 'axes' pattern matches Olympus OIF
and Leica TIFF series.
axesorder : sequence of int
Indices of axes in pattern.
"""
if files is None:
files = '*'
if sort is None:
sort = natural_sorted
self._container = container
if container:
import fnmatch
if isinstance(container, (str, os.PathLike)):
import zipfile
self._container = zipfile.ZipFile(container)
elif not hasattr(self._container, 'open'):
raise ValueError('invalid container')
if isinstance(files, str):
files = fnmatch.filter(self._container.namelist(), files)
if sort:
files = sort(files)
elif isinstance(files, os.PathLike):
files = [os.fspath(files)]
elif isinstance(files, str):
files = glob.glob(files)
if sort:
files = sort(files)
files = [os.fspath(f) for f in files]
if not files:
raise ValueError('no files found')
if hasattr(imread, 'asarray'):
# redefine imread to use asarray from imread class
if not callable(imread.asarray):
raise ValueError('invalid imread function')
_imread_ = imread
def imread(fname, **kwargs):
with _imread_(fname) as handle:
return handle.asarray(**kwargs)
elif not callable(imread):
raise ValueError('invalid imread function')
if container:
# redefine imread to read from container
_imread_ = imread
def imread(fname, **kwargs):
with self._container.open(fname) as handle1:
with io.BytesIO(handle1.read()) as handle2:
return _imread_(handle2, **kwargs)
axes = 'I'
shape = (len(files),)
indices = tuple((i,) for i in range(len(files)))
startindex = (0,)
pattern = TIFF.FILE_PATTERNS.get(pattern, pattern)
if pattern:
try:
axes, shape, indices, startindex = parse_filenames(
files, pattern, axesorder
)
except ValueError as exc:
log_warning(
f'FileSequence: failed to parse file names ({exc})'
)
axesorder = None
if product(shape) != len(files):
log_warning(
'FileSequence: files are missing. Missing data are zeroed'
)
self.imread = imread
self.files = files
self.pattern = pattern
self.axes = axes.upper()
self.shape = shape
self.indices = indices
self._startindex = startindex
def __str__(self):
"""Return string with information about file FileSequence."""
file = str(self._container) if self._container else self.files[0]
file = os.path.split(file)[-1]
return '\n '.join(
(
self.__class__.__name__,
file,
f'files: {len(self.files)}',
'shape: {}'.format(', '.join(str(i) for i in self.shape)),
f'axes: {self.axes}',
)
)
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):
if self._container:
self._container.close()
self._container = None
def asarray(self, file=None, ioworkers=1, out=None, **kwargs):
"""Read image data from files and return as numpy array.
Raise IndexError or ValueError if array shapes do not match.
Parameters
----------
file : int or None
Index or name of single file to read.
ioworkers : int or None
Maximum number of threads to execute the array read function
asynchronously. Default: 1.
If None, default to the number of processors multiplied by 5.
Using threads can significantly improve runtime when
reading many small files from a network share.
out : numpy.ndarray, str, or file-like object
Buffer where image data are saved.
If None (default), a new array is created.
If numpy.ndarray, a writable array of compatible dtype and shape.
If 'memmap', 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.
kwargs : dict
Additional parameters passed to the array read function.
"""
if file is not None:
if isinstance(file, int):
return self.imread(self.files[file], **kwargs)
return self.imread(file, **kwargs)
im = self.imread(self.files[0], **kwargs)
shape = self.shape + im.shape
result = create_output(out, shape, dtype=im.dtype)
result = result.reshape(-1, *im.shape)
def func(index, fname):
"""Read single image from file into result."""
index = int(numpy.ravel_multi_index(index, self.shape))
im = self.imread(fname, **kwargs)
result[index] = im
if len(self.files) < 2:
ioworkers = 1
elif ioworkers is None or ioworkers < 1:
import multiprocessing
ioworkers = max(multiprocessing.cpu_count() * 5, 1)
if ioworkers < 2:
for index, fname in zip(self.indices, self.files):
func(index, fname)
else:
with ThreadPoolExecutor(ioworkers) as executor:
for _ in executor.map(func, self.indices, self.files):
pass
result.shape = shape
return result
def aszarr(self, **kwargs):
"""Return image data from files as zarr storage."""
return ZarrFileStore(self, **kwargs)
class TiffSequence(FileSequence):
"""Series of TIFF files."""
def __init__(
self,
files=None,
container=None,
sort=None,
pattern=None,
axesorder=None,
imread=imread,
):
"""Initialize instance from multiple TIFF files."""
super().__init__(
imread,
'*.tif' if files is None else files,
container=container,
sort=sort,
pattern=pattern,
axesorder=axesorder,
)
class FileHandle:
"""Binary file handle.
A limited, special purpose file handle that can:
* handle embedded files (e.g. for LSM within LSM 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', 'r+b', 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 fileno 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=None, name=None, offset=None, size=None):
"""Initialize file handle from file name or another file handle.
Parameters
----------
file : str, path-like, 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', 'r+b',
or 'wb'. Default is 'rb'.
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._fh = None
self._file = file
self._mode = 'rb' if mode is None else mode
self._name = name
self._dir = ''
self._offset = offset
self._size = size
self._close = True
self.is_file = None
self._lock = NullContext()
self.open()
def open(self):
"""Open or re-open file."""
if self._fh is not None:
return # file is open
if isinstance(self._file, os.PathLike):
self._file = os.fspath(self._file)
if isinstance(self._file, str):
# 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 = f'{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, os.SEEK_END)
self._size = self._fh.tell()
self._fh.seek(pos)
if self.is_file is None:
try:
self._fh.fileno()
self.is_file = True
except Exception:
self.is_file = False
def close(self):
"""Close file."""
if self._close and self._fh:
self._fh.close()
self._fh = None
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
if whence == 2 and self._size > 0:
self._fh.seek(self._offset + self._size + offset, 0)
return
self._fh.seek(offset, whence)
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 readinto(self, b):
"""Read up to len(b) bytes into b and return number of bytes read."""
return self._fh.readinto(b)
def write(self, bytestring):
"""Write bytes 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, out=None):
"""Return numpy array from file in native byte order."""
dtype = numpy.dtype(dtype)
if count < 0:
nbytes = self._size if out is None else out.nbytes
count = nbytes // dtype.itemsize
else:
nbytes = count * dtype.itemsize
result = numpy.empty(count, dtype) if out is None else out
if result.nbytes != nbytes:
raise ValueError('size mismatch')
try:
n = self._fh.readinto(result)
except AttributeError:
result[:] = numpy.frombuffer(self._fh.read(nbytes), dtype).reshape(
result.shape
)
n = nbytes
if n != nbytes:
raise ValueError(f'failed to read {nbytes} bytes')
if not result.dtype.isnative:
if not dtype.isnative:
result.byteswap(True)
result = result.newbyteorder()
elif result.dtype.isnative != dtype.isnative:
result.byteswap(True)
if out is not None:
if hasattr(out, 'flush'):
out.flush()
return result
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 = bytearray(size)
# n = self._fh.readinto(data)
# data = data[:n]
# TODO: record is not writable
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, os.SEEK_CUR)
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.tobytes())
def read_segments(
self,
offsets,
bytecounts,
indices=None,
sort=True,
lock=None,
buffersize=None,
flat=True,
):
"""Return iterator over segments read from file and their indices.
The purpose of this function is to
* reduce small or random reads
* reduce acquiring reentrant locks
* synchronize seeks and reads
* limit the size of segments read into memory at once
(ThreadPoolExecutor.map is not collecting iterables lazily).
Parameters
----------
offsets, bytecounts : sequence of int
offsets and bytecounts of the segments to read from file.
indices : sequence of int
Indices of the segments in the image. Default: range(len(offsets)).
sort : bool
If True (default), segments are read from file in the order of
their offsets.
lock:
A reentrant lock used to synchronize seeks and reads.
buffersize : int
Approximate number of bytes to read from file in one pass.
Default: 64 MB.
flat : bool
If True (default), return an iterator over individual
(segment, index) tuples. Else return an iterator over a list
of (segment, index) tuples that were acquired in one pass.
Returns
-------
items : (bytes, int) or [(bytes, int)]
Iterator over individual or lists of (segment, index) tuples.
"""
# TODO: Cythonize this?
length = len(offsets)
if length < 1:
return
if length == 1:
index = 0 if indices is None else indices[0]
if bytecounts[index] > 0 and offsets[index] > 0:
if lock is None:
lock = self._lock
with lock:
self.seek(offsets[index])
data = self._fh.read(bytecounts[index])
else:
data = None
yield (data, index) if flat else [(data, index)]
return
if lock is None:
lock = self._lock
if buffersize is None:
buffersize = 67108864 # 2 ** 26, 64 MB
if indices is None:
segments = [(i, offsets[i], bytecounts[i]) for i in range(length)]
else:
segments = [
(indices[i], offsets[i], bytecounts[i]) for i in range(length)
]
if sort:
segments = sorted(segments, key=lambda x: x[1])
iscontig = True
for i in range(length - 1):
_, offset, bytecount = segments[i]
nextoffset = segments[i + 1][1]
if offset == 0 or bytecount == 0 or nextoffset == 0:
continue
if offset + bytecount != nextoffset:
iscontig = False
break
seek = self.seek
read = self._fh.read
if iscontig:
# consolidate reads
i = 0
while i < length:
j = i
offset = None
bytecount = 0
while bytecount < buffersize and i < length:
_, o, b = segments[i]
if o > 0 and b > 0:
if offset is None:
offset = o
bytecount += b
i += 1
if offset is None:
data = None
else:
with lock:
seek(offset)
data = read(bytecount)
start = 0
stop = 0
result = []
while j < i:
index, offset, bytecount = segments[j]
if offset > 0 and bytecount > 0:
stop += bytecount
result.append((data[start:stop], index))
start = stop
else:
result.append((None, index))
j += 1
if flat:
yield from result
else:
yield result
return
i = 0
while i < length:
result = []
size = 0
with lock:
while size < buffersize and i < length:
index, offset, bytecount = segments[i]
if offset > 0 and bytecount > 0:
seek(offset)
result.append((read(bytecount), index))
# buffer = bytearray(bytecount)
# n = fh.readinto(buffer)
# data.append(buffer[:n])
size += bytecount
else:
result.append((None, index))
i += 1
if flat:
yield from result
else:
yield result
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(
f'FileHandle: {name!r} not implemented for embedded files',
UserWarning,
)
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 current lock instance."""
return self._lock
@lock.setter
def lock(self, value):
if bool(value) == isinstance(self._lock, NullContext):
self._lock = threading.RLock() if value else NullContext()
@property
def has_lock(self):
"""Return if a RLock is used."""
return not isinstance(self._lock, NullContext)
class FileCache:
"""Keep FileHandles open."""
__slots__ = ('files', 'keep', 'past', 'lock', 'size')
def __init__(self, size=None, lock=None):
"""Initialize open file cache."""
self.past = [] # FIFO of opened files
self.files = {} # refcounts of opened file handles
self.keep = set() # files to keep open
self.lock = NullContext() if lock is None else lock
self.size = 8 if size is None else int(size)
def __len__(self):
"""Return number of open files."""
return len(self.files)
def open(self, filehandle):
"""Open file, re-open 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)
else:
self.files[filehandle] = 2
self.keep.add(filehandle)
self.past.append(filehandle)
def close(self, filehandle):
"""Close least recently used open files."""
with self.lock:
if filehandle in self.files:
self.files[filehandle] -= 1
self._trim()
def clear(self):
"""Close all opened files if not in use when opened first."""
with self.lock:
for filehandle, refcount in list(self.files.items()):
if filehandle not in self.keep:
filehandle.close()
del self.files[filehandle]
del self.past[self.past.index(filehandle)]
def read(self, filehandle, offset, bytecount, whence=0):
"""Return bytes read from binary file."""
with self.lock:
b = filehandle not in self.files
if b:
if filehandle.closed:
filehandle.open()
self.files[filehandle] = 0
else:
self.files[filehandle] = 1
self.keep.add(filehandle)
self.past.append(filehandle)
filehandle.seek(offset, whence)
data = filehandle.read(bytecount)
if b:
self._trim()
return data
def _trim(self):
"""Trim the file cache."""
index = 0
size = len(self.past)
while size > self.size and index < size:
filehandle = self.past[index]
if filehandle not in self.keep and self.files[filehandle] <= 0:
filehandle.close()
del self.files[filehandle]
del self.past[index]
size -= 1
else:
index += 1
class NullContext:
"""Null context manager.
>>> with NullContext():
... pass
"""
__slots = ()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
class Timer:
"""Stopwatch for timing execution speed."""
__slots__ = ('started', 'stopped', 'duration')
clock = time.perf_counter
def __init__(self, message=None, end=' '):
"""Initialize timer and print message."""
if message is not None:
print(message, end=end, flush=True)
self.duration = 0
self.started = self.stopped = Timer.clock()
def start(self, message=None, end=' '):
"""Start timer and return current time."""
if message is not None:
print(message, end=end, flush=True)
self.duration = 0
self.started = self.stopped = Timer.clock()
return self.started
def stop(self, message=None, end=' '):
"""Return duration of timer till start."""
self.stopped = Timer.clock()
if message is not None:
print(message, end=end, flush=True)
self.duration = self.stopped - self.started
return self.duration
def print(self, message=None, end=None):
"""Print duration from timer start till last stop or now."""
msg = str(self)
if message is not None:
print(message, end=' ')
print(msg, end=end, flush=True)
def __str__(self):
"""Return duration from timer start till last stop or now as string."""
if self.duration <= 0:
# not stopped
duration = Timer.clock() - self.started
else:
duration = self.duration
s = str(datetime.timedelta(seconds=duration))
i = 0
while i < len(s) and s[i : i + 2] in '0:0010203040506070809':
i += 1
if s[i : i + 1] == ':':
i += 1
return f'{s[i:]} s'
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.print()
class OmeXmlError(Exception):
"""Exception to indicate invalid OME-XML or unsupported cases."""
class OmeXml:
"""OME-TIFF XML."""
def __init__(self, **metadata):
"""Create a new instance.
Creator : str (optional)
Name of the creating application. Default 'tifffile.py'.
UUID : str (optional)
Unique identifier.
"""
if 'OME' in metadata:
metadata = metadata['OME']
self.ifd = 0
self.images = []
self.annotations = []
self.elements = []
# TODO: parse other OME elements from metadata
# Project
# Dataset
# Folder
# Experiment
# Plate
# Screen
# Experimenter
# ExperimenterGroup
# Instrument
# StructuredAnnotations
# ROI
if 'UUID' in metadata:
self.uuid = metadata['UUID'].split(':')[-1]
else:
from uuid import uuid1 # noqa: delayed import
self.uuid = str(uuid1())
creator = OmeXml._attribute(
metadata, 'Creator', default=f'tifffile.py {__version__}'
)
schema = 'http://www.openmicroscopy.org/Schemas/OME/2016-06'
self.xml = (
'{declaration}'
f'<OME xmlns="{schema}" '
f'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
f'xsi:schemaLocation="{schema} {schema}/ome.xsd" '
f'UUID="urn:uuid:{self.uuid}" {creator}>'
'{images}'
'{annotations}'
'{elements}'
f'</OME>'
)
def addimage(self, dtype, shape, storedshape, axes=None, **metadata):
"""Add image to OME-XML.
The OME model can handle up to 9 dimensional images for selected
axes orders. Refer to the OME-XML specification for details.
Non-TZCYXS (modulo) dimensions must be after a TZC dimension or
require an unused TZC dimension.
dtype : numpy.dtype
Data type of image array.
shape : tuple
Shape of image array.
storedshape: tuple
Normalized shape describing how the image array is stored in TIFF:
(pages, separate_samples, depth, length, width, contig_samples).
axes : str (optional)
Axes labels for each dimension in shape.
By default, axes are matched to the shape in reverse order of
TZC(S)YX(S) based on storedshape.
The following axes codes are supported: 'S' sample, 'X' width,
'Y' length, 'Z' depth, 'C' channel, 'T' time, 'A' angle, 'P' phase,
'R' tile, 'H' lifetime, 'E' lambda, 'Q' other.
metadata : miscellaneous (optional)
Additional OME-XML attributes or elements to be stored.
Image/Pixels: Name, AcquisitionDate, Description,
PhysicalSizeX, PhysicalSizeXUnit, PhysicalSizeY, PhysicalSizeYUnit,
PhysicalSizeZ, PhysicalSizeZUnit, TimeIncrement, TimeIncrementUnit.
Per Plane: DeltaTUnit, ExposureTime, ExposureTimeUnit,
PositionX, PositionXUnit, PositionY, PositionYUnit, PositionZ,
PositionZUnit.
Per Channel: Name, AcquisitionMode, Color, ContrastMethod,
EmissionWavelength, EmissionWavelengthUnit, ExcitationWavelength,
ExcitationWavelengthUnit, Fluor, IlluminationType, NDFilter,
PinholeSize, PinholeSizeUnit, PockelCellSetting.
"""
index = len(self.images)
# get Image and Pixels metadata
metadata = metadata.get('OME', metadata)
metadata = metadata.get('Image', metadata)
if isinstance(metadata, (list, tuple)):
# multiple images
metadata = metadata[index]
if 'Pixels' in metadata:
# merge with Image
if 'ID' in metadata['Pixels']:
del metadata['Pixels']['ID']
metadata.update(metadata['Pixels'])
del metadata['Pixels']
try:
dtype = numpy.dtype(dtype).name
dtype = {
'int8': 'int8',
'int16': 'int16',
'int32': 'int32',
'uint8': 'uint8',
'uint16': 'uint16',
'uint32': 'uint32',
'float32': 'float',
'float64': 'double',
'complex64': 'complex',
'complex128': 'double-complex',
'bool': 'bit',
}[dtype]
except KeyError:
raise OmeXmlError(f'data type {dtype!r} not supported')
if metadata.get('Type', dtype) != dtype:
raise OmeXmlError(
f'metadata Pixels Type {metadata["Type"]!r} '
f'does not match array dtype {dtype!r}'
)
samples = 1
planecount, separate, depth, length, width, contig = storedshape
if depth != 1:
raise OmeXmlError('ImageDepth not supported')
if not (separate == 1 or contig == 1):
raise ValueError('invalid stored shape')
shape = tuple(int(i) for i in shape)
ndim = len(shape)
if ndim < 1 or product(shape) <= 0:
raise OmeXmlError('empty arrays not supported')
if axes is None:
# get axes from shape, stored shape, and DimensionOrder
if contig != 1 or shape[-3:] == (length, width, 1):
axes = 'YXS'
samples = contig
elif separate != 1 or (
ndim == 6 and shape[-3:] == (1, length, width)
):
axes = 'SYX'
samples = separate
else:
axes = 'YX'
if not len(axes) <= ndim <= (6 if 'S' in axes else 5):
raise OmeXmlError(f'{ndim} dimensions not supported')
hiaxes = metadata.get('DimensionOrder', 'XYCZT')[:1:-1]
axes = hiaxes[(6 if 'S' in axes else 5) - ndim :] + axes
assert len(axes) == len(shape)
else:
# validate axes against shape and stored shape
axes = axes.upper()
if len(axes) != len(shape):
raise ValueError('axes do not match shape')
if not (axes.endswith('YX') or axes.endswith('YXS')):
raise OmeXmlError('dimensions must end with YX or YXS')
unique = []
for ax in axes:
if ax not in 'TZCYXSAPRHEQ':
raise OmeXmlError(f'dimension {ax!r} not supported')
if ax in unique:
raise OmeXmlError(f'multiple {ax!r} dimensions')
unique.append(ax)
if ndim > (9 if 'S' in axes else 8):
raise OmeXmlError('more than 8 dimensions not supported')
if contig != 1:
samples = contig
if ndim < 3:
raise ValueError('dimensions do not match stored shape')
if axes[-1] != 'S':
raise ValueError('axes do not match stored shape')
if shape[-1] != contig or shape[-2] != width:
raise ValueError('shape does not match stored shape')
elif separate != 1:
samples = separate
if ndim < 3:
raise ValueError('dimensions do not match stored shape')
if axes[-3] != 'S':
raise ValueError('axes do not match stored shape')
if shape[-3] != separate or shape[-1] != length:
raise ValueError('shape does not match stored shape')
if shape[axes.index('X')] != width or shape[axes.index('Y')] != length:
raise ValueError('shape does not match stored shape')
if 'S' in axes:
hiaxes = axes[: min(axes.index('S'), axes.index('Y'))]
else:
hiaxes = axes[: axes.index('Y')]
if any(ax in 'APRHEQ' for ax in hiaxes):
# modulo axes
modulo = {}
dimorder = []
axestype = {
'A': 'angle',
'P': 'phase',
'R': 'tile',
'H': 'lifetime',
'E': 'lambda',
'Q': 'other',
}
for i, ax in enumerate(hiaxes):
if ax in 'APRHEQ':
x = hiaxes[i - 1 : i]
if x and x in 'TZC':
# use previous axis
modulo[x] = axestype[ax], shape[i]
else:
# use next unused axis
for x in 'TZC':
if x not in dimorder and x not in modulo:
modulo[x] = axestype[ax], shape[i]
dimorder.append(x)
break
else:
# TODO: support any order of axes, e.g. APRTZC
raise OmeXmlError('more than 3 modulo dimensions')
else:
dimorder.append(ax)
hiaxes = ''.join(dimorder)
# TODO: use user-specified start, stop, step, or labels
moduloalong = ''.join(
f'<ModuloAlong{ax} Type="{axtype}" Start="0" End="{size-1}"/>'
for ax, (axtype, size) in modulo.items()
)
annotationref = f'<AnnotationRef ID="Annotation:{index}"/>'
annotations = (
f'<XMLAnnotation ID="Annotation:{index}" '
'Namespace="openmicroscopy.org/omero/dimension/modulo">'
'<Value>'
'<Modulo namespace='
'"http://www.openmicroscopy.org/Schemas/Additions/2011-09">'
f'{moduloalong}'
'</Modulo>'
'</Value>'
'</XMLAnnotation>'
)
self.annotations.append(annotations)
else:
modulo = {}
annotationref = ''
hiaxes = hiaxes[::-1]
for dimorder in (
metadata.get('DimensionOrder', 'XYCZT'),
'XYCZT',
'XYZCT',
'XYZTC',
'XYCTZ',
'XYTCZ',
'XYTZC',
):
if hiaxes in dimorder:
break
else:
raise OmeXmlError(f'dimension order {axes!r} not supported')
dimsizes = []
for ax in dimorder:
if ax == 'S':
continue
if ax in axes:
size = shape[axes.index(ax)]
else:
size = 1
if ax == 'C':
sizec = size
size *= samples
if ax in modulo:
size *= modulo[ax][1]
dimsizes.append(size)
sizes = ''.join(
f' Size{ax}="{size}"' for ax, size in zip(dimorder, dimsizes)
)
# verify DimensionOrder in metadata is compatible
if 'DimensionOrder' in metadata:
omedimorder = metadata['DimensionOrder']
omedimorder = ''.join(
ax for ax in omedimorder if dimsizes[dimorder.index(ax)] > 1
)
if hiaxes not in omedimorder:
raise OmeXmlError(
f'metadata DimensionOrder does not match {axes!r}'
)
# verify metadata Size values match shape
for ax, size in zip(dimorder, dimsizes):
if metadata.get(f'Size{ax}', size) != size:
raise OmeXmlError(
f'metadata Size{ax} does not match {shape!r}'
)
dimsizes[dimorder.index('C')] //= samples
if planecount != product(dimsizes[2:]):
raise ValueError('shape does not match stored shape')
planes = []
planeattributes = metadata.get('Plane', '')
if planeattributes:
cztorder = tuple(dimorder[2:].index(ax) for ax in 'CZT')
for p in range(planecount):
attributes = OmeXml._attributes(
planeattributes,
p,
'DeltaTUnit',
'ExposureTime',
'ExposureTimeUnit',
'PositionX',
'PositionXUnit',
'PositionY',
'PositionYUnit',
'PositionZ',
'PositionZUnit',
)
unraveled = numpy.unravel_index(p, dimsizes[2:], order='F')
c, z, t = (int(unraveled[i]) for i in cztorder)
planes.append(
f'<Plane TheC="{c}" TheZ="{z}" TheT="{t}"{attributes}/>'
)
# TODO: if possible, verify c, z, t match planeattributes
planes = ''.join(planes)
channels = []
for c in range(sizec):
lightpath = '<LightPath/>'
# TODO: use LightPath elements from metadata
# 'AnnotationRef',
# 'DichroicRef',
# 'EmissionFilterRef',
# 'ExcitationFilterRef'
attributes = OmeXml._attributes(
metadata.get('Channel', ''),
c,
'Name',
'AcquisitionMode',
'Color',
'ContrastMethod',
'EmissionWavelength',
'EmissionWavelengthUnit',
'ExcitationWavelength',
'ExcitationWavelengthUnit',
'Fluor',
'IlluminationType',
'NDFilter',
'PinholeSize',
'PinholeSizeUnit',
'PockelCellSetting',
)
channels.append(
f'<Channel ID="Channel:{index}:{c}" '
f'SamplesPerPixel="{samples}"'
f'{attributes}>'
f'{lightpath}'
'</Channel>'
)
channels = ''.join(channels)
# TODO: support more Image elements
elements = OmeXml._elements(metadata, 'AcquisitionDate', 'Description')
name = OmeXml._attribute(metadata, 'Name', default=f'Image{index}')
attributes = OmeXml._attributes(
metadata,
None,
'SignificantBits',
'PhysicalSizeX',
'PhysicalSizeXUnit',
'PhysicalSizeY',
'PhysicalSizeYUnit',
'PhysicalSizeZ',
'PhysicalSizeZUnit',
'TimeIncrement',
'TimeIncrementUnit',
)
if separate > 1 or contig > 1:
interleaved = 'false' if separate > 1 else 'true'
interleaved = f' Interleaved="{interleaved}"'
else:
interleaved = ''
self.images.append(
f'<Image ID="Image:{index}"{name}>'
f'{elements}'
f'<Pixels ID="Pixels:{index}" '
f'DimensionOrder="{dimorder}" '
f'Type="{dtype}"'
f'{sizes}'
f'{interleaved}'
f'{attributes}>'
f'{channels}'
f'<TiffData IFD="{self.ifd}" PlaneCount="{planecount}"/>'
f'{planes}'
f'</Pixels>'
f'{annotationref}'
f'</Image>'
)
self.ifd += planecount
def tostring(self, declaration=False):
"""Return OME-XML string."""
# TODO: support other top-level elements
elements = ''.join(self.elements)
images = ''.join(self.images)
annotations = ''.join(self.annotations)
if annotations:
annotations = (
f'<StructuredAnnotations>{annotations}</StructuredAnnotations>'
)
if declaration:
declaration = '<?xml version="1.0" encoding="UTF-8"?>'
else:
declaration = ''
xml = self.xml.format(
declaration=declaration,
images=images,
annotations=annotations,
elements=elements,
)
return xml
def __str__(self):
"""Return OME-XML string."""
xml = self.tostring()
try:
from lxml import etree # noqa: delayed import
parser = etree.XMLParser(remove_blank_text=True)
tree = etree.fromstring(xml, parser)
xml = etree.tostring(
tree, encoding='utf-8', pretty_print=True, xml_declaration=True
).decode()
except Exception as exc:
warnings.warn(f'OmeXml.__str__: {exc}', UserWarning)
except ImportError:
pass
return xml
@staticmethod
def _escape(value):
"""Return escaped string of value."""
if not isinstance(value, str):
value = str(value)
elif '&amp;' in value or '&gt;' in value or '&lt;' in value:
return value
value = value.replace('&', '&amp;')
value = value.replace('>', '&gt;')
value = value.replace('<', '&lt;')
return value
@staticmethod
def _element(metadata, name, default=None):
"""Return XML formatted element if name in metadata."""
value = metadata.get(name, default)
if value is None:
return None
return f'<{name}>{OmeXml._escape(value)}</{name}>'
@staticmethod
def _elements(metadata, *names):
"""Return XML formatted elements."""
if not metadata:
return ''
elements = (OmeXml._element(metadata, name) for name in names)
return ''.join(e for e in elements if e)
@staticmethod
def _attribute(metadata, name, index=None, default=None):
"""Return XML formatted attribute if name in metadata."""
value = metadata.get(name, default)
if value is None:
return None
if index is not None:
if isinstance(value, (list, tuple)):
value = value[index]
elif index > 0:
raise TypeError(
f'{type(value).__name__!r} is not a list or tuple'
)
return f' {name}="{OmeXml._escape(value)}"'
@staticmethod
def _attributes(metadata, index_, *names):
"""Return XML formatted attributes."""
if not metadata:
return ''
if index_ is None:
attributes = (OmeXml._attribute(metadata, name) for name in names)
elif isinstance(metadata, (list, tuple)):
metadata = metadata[index_]
attributes = (OmeXml._attribute(metadata, name) for name in names)
elif isinstance(metadata, dict):
attributes = (
OmeXml._attribute(metadata, name, index_) for name in names
)
return ''.join(a for a in attributes if a)
@staticmethod
def _reference(metadata, name):
"""Return XML formatted reference element."""
value = metadata.get(name, None)
if value is None:
return ''
try:
value = value['ID']
except KeyError:
pass
return f'<{name} ID="{OmeXml._escape(value)}"/>'
@staticmethod
def validate(omexml, omexsd=None, assert_=True, _schema=[]):
"""Return if OME-XML is valid according to XMLSchema.
If 'assert_' is True, raise an AssertionError if validation fails.
On first run, this function takes several seconds to download and
parse the 2016-06 OME XMLSchema.
"""
from lxml import etree # noqa: delay import
if not _schema:
if omexsd is None:
omexsd = os.path.join(os.path.dirname(__file__), 'ome.xsd')
if os.path.exists(omexsd):
with open(omexsd, 'rb') as fh:
omexsd = fh.read()
else:
import urllib.request # noqa: delay import
with urllib.request.urlopen(
'https://www.openmicroscopy.org/'
'Schemas/OME/2016-06/ome.xsd'
) as fh:
omexsd = fh.read()
if omexsd.startswith(b'<?xml'):
omexsd = omexsd.split(b'>', 1)[-1]
try:
_schema.append(
etree.XMLSchema(etree.fromstring(omexsd.decode()))
)
except Exception:
# raise
_schema.append(None)
if _schema and _schema[0] is not None:
if omexml.startswith('<?xml'):
omexml = omexml.split('>', 1)[-1]
tree = etree.fromstring(omexml)
if assert_:
_schema[0].assert_(tree)
return True
return _schema[0].validate(tree)
return None
class LazyConst:
"""Class whose attributes are computed on first access from its methods."""
def __init__(self, cls):
self._cls = cls
self.__doc__ = cls.__doc__
self.__module__ = cls.__module__
self.__name__ = cls.__name__
self.__qualname__ = cls.__qualname__
self.lock = threading.RLock()
def __reduce__(self):
# decorated class will be pickled by name
return self._cls.__qualname__
def __getattr__(self, name):
with self.lock:
if name in self.__dict__:
# another thread set attribute while awaiting lock
return self.__dict__[name]
func = getattr(self._cls, name)
value = func() if callable(func) else func
for attr in (
'__module__',
'__name__',
'__qualname__',
# '__doc__',
# '__annotations__'
):
try:
setattr(value, attr, getattr(func, attr))
except AttributeError:
pass
setattr(self, name, value)
return value
@LazyConst
class TIFF:
"""Namespace for module constants."""
def CLASSIC_LE():
class ClassicTiffLe:
__slots__ = ()
version = 42
byteorder = '<'
offsetsize = 4
offsetformat = '<I'
tagnosize = 2
tagnoformat = '<H'
tagsize = 12
tagformat1 = '<HH'
tagformat2 = '<I4s'
tagoffsetthreshold = 4
return ClassicTiffLe
def CLASSIC_BE():
class ClassicTiffBe:
__slots__ = ()
version = 42
byteorder = '>'
offsetsize = 4
offsetformat = '>I'
tagnosize = 2
tagnoformat = '>H'
tagsize = 12
tagformat1 = '>HH'
tagformat2 = '>I4s'
tagoffsetthreshold = 4
return ClassicTiffBe
def BIG_LE():
class BigTiffLe:
__slots__ = ()
version = 43
byteorder = '<'
offsetsize = 8
offsetformat = '<Q'
tagnosize = 8
tagnoformat = '<Q'
tagsize = 20
tagformat1 = '<HH'
tagformat2 = '<Q8s'
tagoffsetthreshold = 8
return BigTiffLe
def BIG_BE():
class BigTiffBe:
__slots__ = ()
version = 43
byteorder = '>'
offsetsize = 8
offsetformat = '>Q'
tagnosize = 8
tagnoformat = '>Q'
tagsize = 20
tagformat1 = '>HH'
tagformat2 = '>Q8s'
tagoffsetthreshold = 8
return BigTiffBe
def NDPI_LE():
class NdpiTiffLe:
__slots__ = ()
version = 42
byteorder = '<'
offsetsize = 8 # NDPI uses 8 bytes IFD and tag offsets
offsetformat = '<Q'
tagnosize = 2
tagnoformat = '<H'
tagsize = 12
tagformat1 = '<HH'
tagformat2 = '<I8s' # after patching
tagoffsetthreshold = 4
return NdpiTiffLe
def TAGS():
# TIFF tag codes and names from TIFF6, TIFF/EP, EXIF, and other specs
# TODO: divide into baseline, exif, private, ... tags
return TiffTagRegistry(
(
(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'), # use SampleFormat
(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'),
(33471, 'OlympusINI'),
(33550, 'ModelPixelScaleTag'),
(33560, 'OlympusSIS'), # see also 33471 and 34853
(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 tags
(33918, 'IntergraphPacketData'), # INGRPacketDataTag
(33919, 'IntergraphFlagRegisters'), # INGRFlagRegisters
(33920, 'IntergraphMatrixTag'), # IrasBTransformationMatrix
(33921, 'INGRReserved'),
(33922, 'ModelTiepointTag'),
(33923, 'LeicaMagic'),
(34016, 'Site'), # 34016..34032 ANSI IT8 TIFF/IT
(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'), # EXIF, also TI FrameCount
(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 also OlympusSIS2
(34853, 'OlympusSIS2'),
(34855, 'ISOSpeedRatings'),
(34855, 'PhotographicSensitivity'),
(34856, 'OECF'), # optoelectric conversion factor
(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
(36864, 'TVX_Unknown'),
(36865, 'TVX_NumExposure'),
(36866, 'TVX_NumBackground'),
(36867, 'TVX_ExposureTime'),
(36868, 'TVX_BackgroundTime'),
(36870, 'TVX_Unknown'),
(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'),
(40000, 'XPos'), # Janelia
(40001, 'YPos'),
(40002, 'ZPos'),
(40001, 'MC_IpWinScal'), # Media Cybernetics
(40001, 'RecipName'), # MS FAX
(40002, 'RecipNumber'),
(40003, 'SenderName'),
(40004, 'Routing'),
(40005, 'CallerId'),
(40006, 'TSID'),
(40007, 'CSID'),
(40008, 'FaxTime'),
(40100, 'MC_IdOld'),
(40106, 'MC_Unknown'),
(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'),
(42080, 'CompositeImage'),
(42081, 'SourceImageNumberCompositeImage'),
(42082, 'SourceExposureTimesCompositeImage'),
(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'),
(50003, 'KodakAPP3'),
(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'),
(50648, 'CR2Unknown1'),
(50649, 'CR2Unknown2'),
(50656, 'CR2CFAPattern'),
(50674, 'LercParameters'), # ESGI 50674 .. 50677
(50706, 'DNGVersion'), # DNG 50706 .. 51114
(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'),
(50908, 'RSID'), # DGIWG
(50909, 'GEO_METADATA'), # DGIWG XML
(50931, 'CameraCalibrationSignature'),
(50932, 'ProfileCalibrationSignature'),
(50933, 'ProfileIFD'), # EXTRACAMERAPROFILES
(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'),
(51113, 'CacheBlob'),
(51114, 'CacheVersion'),
(51123, 'MicroManagerMetadata'),
(51125, 'DefaultUserCrop'),
(51159, 'ZIFmetadata'), # Objective Pathology Services
(51160, 'ZIFannotations'), # Objective Pathology Services
(51177, 'DepthFormat'),
(51178, 'DepthNear'),
(51179, 'DepthFar'),
(51180, 'DepthUnits'),
(51181, 'DepthMeasureType'),
(51182, 'EnhanceParams'),
(59932, 'Padding'),
(59933, 'OffsetSchema'),
# Reusable Tags 65000-65535
# (65000, DimapDocumentXML'),
# (65001, 'EER_XML'),
# 65000-65112, Photoshop Camera RAW EXIF tags
# (65000, 'OwnerName'),
# (65001, 'SerialNumber'),
# (65002, 'Lens'),
# (65024, 'KodakKDCPrivateIFD'),
# (65100, 'RawFile'),
# (65101, 'Converter'),
# (65102, 'WhiteBalance'),
# (65105, 'Exposure'),
# (65106, 'Shadows'),
# (65107, 'Brightness'),
# (65108, 'Contrast'),
# (65109, 'Saturation'),
# (65110, 'Sharpness'),
# (65111, 'Smoothness'),
# (65112, 'MoireFilter'),
(65200, 'FlexXML'),
)
)
def TAG_READERS():
# map 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,
33471: read_sis_ini,
33560: read_sis,
34665: read_exif_ifd,
34853: read_gps_ifd, # conflicts with OlympusSIS
40965: read_interoperability_ifd,
65426: read_numpy, # NDPI McuStarts
65432: read_numpy, # NDPI McuStartsHighBytes
65439: read_numpy, # NDPI unknown
65459: read_bytes, # NDPI bytes, not string
}
def TAG_TUPLE():
# tags whose values must be stored as tuples
return frozenset((273, 279, 324, 325, 330, 338, 530, 531, 34736))
def TAG_ATTRIBUTES():
# map tag codes to TiffPage attribute names
return {
254: 'subfiletype',
256: 'imagewidth',
257: 'imagelength',
# 258: 'bitspersample', # set manually
259: 'compression',
262: 'photometric',
266: 'fillorder',
270: 'description',
277: 'samplesperpixel',
278: 'rowsperstrip',
284: 'planarconfig',
305: 'software',
320: 'colormap',
317: 'predictor',
322: 'tilewidth',
323: 'tilelength',
330: 'subifds',
338: 'extrasamples',
# 339: 'sampleformat', # set manually
347: 'jpegtables',
32997: 'imagedepth',
32998: 'tiledepth',
}
def TAG_ENUM():
# map tag codes to Enums
class TAG_ENUM:
__slots__ = ('_codes',)
def __init__(self):
self._codes = {
254: None,
255: None,
259: TIFF.COMPRESSION,
262: TIFF.PHOTOMETRIC,
263: None,
266: None,
274: None,
284: TIFF.PLANARCONFIG,
290: None,
296: None,
300: None,
317: None,
338: None,
339: TIFF.SAMPLEFORMAT,
}
def __contains__(self, key):
return key in self._codes
def __getitem__(self, key):
value = self._codes[key]
if value is not None:
return value
if key == 254:
value = TIFF.FILETYPE
elif key == 255:
value = TIFF.OFILETYPE
elif key == 263:
value = TIFF.THRESHHOLD
elif key == 266:
value = TIFF.FILLORDER
elif key == 274:
value = TIFF.ORIENTATION
elif key == 290:
value = TIFF.GRAYRESPONSEUNIT
# elif key == 292:
# value = TIFF.GROUP3OPT
# elif key == 293:
# value = TIFF.GROUP4OPT
elif key == 296:
value = TIFF.RESUNIT
elif key == 300:
value = TIFF.COLORRESPONSEUNIT
elif key == 317:
value = TIFF.PREDICTOR
elif key == 338:
value = TIFF.EXTRASAMPLE
# elif key == 512:
# TIFF.JPEGPROC
# elif key == 531:
# TIFF.YCBCRPOSITION
else:
raise KeyError(key)
self._codes[key] = value
return value
return TAG_ENUM()
def FILETYPE():
class FILETYPE(enum.IntFlag):
UNDEFINED = 0
REDUCEDIMAGE = 1
PAGE = 2
MASK = 4
UNKNOWN = 8 # found in AperioSVS
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
LERC = 34887 # ESRI Lerc
JPEG_LOSSY = 34892
LZMA = 34925
ZSTD_DEPRECATED = 34926
WEBP_DEPRECATED = 34927
PNG = 34933 # Objective Pathology Services
JPEGXR = 34934 # Objective Pathology Services
ZSTD = 50000
WEBP = 50001
PIXTIFF = 50013
# EER_V0 = 65000
# EER_V1 = 65001
# KODAK_DCR = 65000
# PENTAX_PEF = 65535
def __bool__(self):
return self != 1
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 PHOTOMETRIC_SAMPLES():
return {
0: 1, # MINISWHITE
1: 1, # MINISBLACK
2: 3, # RGB
3: 1, # PALETTE
4: 1, # MASK
5: 4, # SEPARATED
6: 3, # YCBCR
8: 3, # CIELAB
9: 3, # ICCLAB
10: 3, # ITULAB
32803: 1, # CFA
32844: 1, # LOGL ?
32845: 3, # LOGLUV
34892: 3, # LINEAR_RAW ?
}
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 # CHUNKY
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
MILLIMETER = 4 # DNG
MICROMETER = 5 # DNG
def __bool__(self):
return self != 1
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
HORIZONTALX2 = 34892 # DNG
HORIZONTALX4 = 34893
FLOATINGPOINTX2 = 34894
FLOATINGPOINTX4 = 34895
def __bool__(self):
return self != 1
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):
BYTE = 1 # 8-bit unsigned integer
ASCII = 2 # 8-bit byte that contains a 7-bit ASCII code;
# the last byte must be NULL (binary zero)
SHORT = 3 # 16-bit (2-byte) unsigned integer
LONG = 4 # 32-bit (4-byte) unsigned integer
RATIONAL = 5 # two LONGs: the first represents the numerator
# of a fraction; the second, the denominator
SBYTE = 6 # an 8-bit signed (twos-complement) integer
UNDEFINED = 7 # an 8-bit byte that may contain anything,
# depending on the definition of the field
SSHORT = 8 # A 16-bit (2-byte) signed (twos-complement) integer
SLONG = 9 # a 32-bit (4-byte) signed (twos-complement) integer
SRATIONAL = 10 # two SLONGs: the first represents the numerator
# of a fraction, the second the denominator
FLOAT = 11 # single precision (4-byte) IEEE format
DOUBLE = 12 # double precision (8-byte) IEEE format
IFD = 13 # unsigned 4 byte IFD offset
UNICODE = 14
COMPLEX = 15
LONG8 = 16 # unsigned 8 byte integer (BigTiff)
SLONG8 = 17 # signed 8 byte integer (BigTiff)
IFD8 = 18 # unsigned 8 byte IFD offset (BigTiff)
return DATATYPES
def DATA_FORMATS():
# map TIFF DATATYPES to Python struct formats
return {
1: '1B',
2: '1s',
3: '1H',
4: '1I',
5: '2I',
6: '1b',
7: '1B',
8: '1h',
9: '1i',
10: '2i',
11: '1f',
12: '1d',
13: '1I',
# 14: '',
# 15: '',
16: '1Q',
17: '1q',
18: '1Q',
}
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 SampleFormat and BitsPerSample to numpy dtype
return {
# UINT
(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',
# VOID : treat as UINT
(4, 1): '?', # bitmap
(4, 2): 'B',
(4, 3): 'B',
(4, 4): 'B',
(4, 5): 'B',
(4, 6): 'B',
(4, 7): 'B',
(4, 8): 'B',
(4, 9): 'H',
(4, 10): 'H',
(4, 11): 'H',
(4, 12): 'H',
(4, 13): 'H',
(4, 14): 'H',
(4, 15): 'H',
(4, 16): 'H',
(4, 17): 'I',
(4, 18): 'I',
(4, 19): 'I',
(4, 20): 'I',
(4, 21): 'I',
(4, 22): 'I',
(4, 23): 'I',
(4, 24): 'I',
(4, 25): 'I',
(4, 26): 'I',
(4, 27): 'I',
(4, 28): 'I',
(4, 29): 'I',
(4, 30): 'I',
(4, 31): 'I',
(4, 32): 'I',
(4, 64): 'Q',
# INT
(2, 8): 'b',
(2, 16): 'h',
(2, 32): 'i',
(2, 64): 'q',
# IEEEFP
(3, 16): 'e',
(3, 24): 'f', # float24 bit not supported by numpy
(3, 32): 'f',
(3, 64): 'd',
# COMPLEXIEEEFP
(6, 64): 'F',
(6, 128): 'D',
# RGB565
(1, (5, 6, 5)): 'B',
# COMPLEXINT : not supported by numpy
}
def PREDICTORS():
# map PREDICTOR to predictor encode functions
class PREDICTORS:
def __init__(self):
self._codecs = {None: identityfunc, 1: identityfunc}
if imagecodecs is None:
self._codecs[2] = delta_encode
def __getitem__(self, key):
if key in self._codecs:
return self._codecs[key]
try:
if key == 2:
codec = imagecodecs.delta_encode
elif key == 3:
codec = imagecodecs.floatpred_encode
elif key == 34892:
def codec(data, axis=-1, out=None):
return imagecodecs.delta_encode(
data, axis=axis, out=out, dist=2
)
elif key == 34893:
def codec(data, axis=-1, out=None):
return imagecodecs.delta_encode(
data, axis=axis, out=out, dist=4
)
elif key == 34894:
def codec(data, axis=-1, out=None):
return imagecodecs.floatpred_encode(
data, axis=axis, out=out, dist=2
)
elif key == 34895:
def codec(data, axis=-1, out=None):
return imagecodecs.floatpred_encode(
data, axis=axis, out=out, dist=4
)
else:
raise KeyError(f'{key} is not a known PREDICTOR')
except AttributeError:
raise KeyError(
f'{TIFF.PREDICTOR(key)!r}'
" requires the 'imagecodecs' package"
)
self._codecs[key] = codec
return codec
return PREDICTORS()
def UNPREDICTORS():
# map PREDICTOR to predictor decode functions
class UNPREDICTORS:
def __init__(self):
self._codecs = {None: identityfunc, 1: identityfunc}
if imagecodecs is None:
self._codecs[2] = delta_decode
def __getitem__(self, key):
if key in self._codecs:
return self._codecs[key]
try:
if key == 2:
codec = imagecodecs.delta_decode
elif key == 3:
codec = imagecodecs.floatpred_decode
elif key == 34892:
def codec(data, axis=-1, out=None):
return imagecodecs.delta_decode(
data, axis=axis, out=out, dist=2
)
elif key == 34893:
def codec(data, axis=-1, out=None):
return imagecodecs.delta_decode(
data, axis=axis, out=out, dist=4
)
elif key == 34894:
def codec(data, axis=-1, out=None):
return imagecodecs.floatpred_decode(
data, axis=axis, out=out, dist=2
)
elif key == 34895:
def codec(data, axis=-1, out=None):
return imagecodecs.floatpred_decode(
data, axis=axis, out=out, dist=4
)
else:
raise KeyError(f'{key} is not a known PREDICTOR')
except AttributeError:
raise KeyError(
f'{TIFF.PREDICTOR(key)!r}'
" requires the 'imagecodecs' package"
)
self._codecs[key] = codec
return codec
return UNPREDICTORS()
def COMPESSORS():
# map COMPRESSION to compress functions
class COMPESSORS:
def __init__(self):
self._codecs = {None: identityfunc, 1: identityfunc}
if imagecodecs is None:
self._codecs[8] = zlib_encode
self._codecs[32946] = zlib_encode
self._codecs[34925] = lzma_encode
def __getitem__(self, key):
if key in self._codecs:
return self._codecs[key]
try:
if key == 5:
codec = imagecodecs.lzw_encode
elif key == 7:
codec = imagecodecs.jpeg_encode
elif key == 8 or key == 32946:
if (
hasattr(imagecodecs, 'DEFLATE')
and imagecodecs.DEFLATE
):
codec = imagecodecs.deflate_encode
elif imagecodecs.ZLIB:
codec = imagecodecs.zlib_encode
else:
codec = zlib_encode
elif key == 32773:
codec = imagecodecs.packbits_encode
elif key == 33003 or key == 33005 or key == 34712:
codec = imagecodecs.jpeg2k_encode
elif key == 34887:
codec = imagecodecs.lerc_encode
elif key == 34892:
codec = imagecodecs.jpeg8_encode # DNG lossy
elif key == 34925:
if imagecodecs.LZMA:
codec = imagecodecs.lzma_encode
else:
codec = lzma_encode
elif key == 34933:
codec = imagecodecs.png_encode
elif key == 34934:
codec = imagecodecs.jpegxr_encode
elif key == 50000:
codec = imagecodecs.zstd_encode
elif key == 50001:
codec = imagecodecs.webp_encode
else:
try:
msg = f'{TIFF.COMPRESSION(key)!r} not supported'
except ValueError:
msg = f'{key} is not a known COMPRESSION'
raise KeyError(msg)
except AttributeError:
raise KeyError(
f'{TIFF.COMPRESSION(key)!r} '
"requires the 'imagecodecs' package"
)
self._codecs[key] = codec
return codec
return COMPESSORS()
def DECOMPESSORS():
# map COMPRESSION to decompress functions
class DECOMPESSORS:
def __init__(self):
self._codecs = {None: identityfunc, 1: identityfunc}
if imagecodecs is None:
self._codecs[8] = zlib_decode
self._codecs[32773] = packbits_decode
self._codecs[32946] = zlib_decode
self._codecs[34925] = lzma_decode
def __getitem__(self, key):
if key in self._codecs:
return self._codecs[key]
try:
if key == 5:
codec = imagecodecs.lzw_decode
elif key == 6 or key == 7:
codec = imagecodecs.jpeg_decode
elif key == 8 or key == 32946:
if (
hasattr(imagecodecs, 'DEFLATE')
and imagecodecs.DEFLATE
):
codec = imagecodecs.deflate_decode
elif imagecodecs.ZLIB:
codec = imagecodecs.zlib_decode
else:
codec = zlib_decode
elif key == 32773:
codec = imagecodecs.packbits_decode
elif key == 33003 or key == 33005 or key == 34712:
codec = imagecodecs.jpeg2k_decode
elif key == 34887:
codec = imagecodecs.lerc_decode
elif key == 34892:
codec = imagecodecs.jpeg8_decode # DNG lossy
elif key == 34925:
if imagecodecs.LZMA:
codec = imagecodecs.lzma_decode
else:
codec = lzma_decode
elif key == 34933:
codec = imagecodecs.png_decode
elif key == 34934:
codec = imagecodecs.jpegxr_decode
elif key == 50000 or key == 34926: # 34926 deprecated
codec = imagecodecs.zstd_decode
elif key == 50001 or key == 34927: # 34927 deprecated
codec = imagecodecs.webp_decode
else:
try:
msg = f'{TIFF.COMPRESSION(key)!r} not supported'
except ValueError:
msg = f'{key} is not a known COMPRESSION'
raise KeyError(msg)
except AttributeError:
raise KeyError(
f'{TIFF.COMPRESSION(key)!r} '
"requires the 'imagecodecs' package"
)
self._codecs[key] = codec
return codec
def __contains__(self, key):
try:
self[key]
except KeyError:
return False
return True
return DECOMPESSORS()
def FRAME_ATTRS():
# attributes that a TiffFrame shares with its keyframe
return {'shape', 'ndim', 'size', 'dtype', 'axes', 'is_final', 'decode'}
def FILE_FLAGS():
# TiffFile and TiffPage 'is_\*' attributes
exclude = {
'reduced',
'mask',
'final',
'memmappable',
'contiguous',
'tiled',
'subsampled',
}
return {
a[3:]
for a in dir(TiffPage)
if a[:3] == 'is_' and a[3:] not in exclude
}
def FILE_PATTERNS():
# predefined FileSequence patterns
return {
'axes': r"""(?ix)
# 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}))?
"""
}
def FILE_EXTENSIONS():
# TIFF file extensions
return (
'tif',
'tiff',
'ome.tif',
'lsm',
'stk',
'qpi',
'pcoraw',
'qptiff',
'gel',
'seq',
'svs',
'scn',
'zif',
'ndpi',
'bif',
'tf8',
'tf2',
'btf',
'eer',
)
def FILEOPEN_FILTER():
# string for use in Windows File Open box
return [
(f'{ext.upper()} files', f'*.{ext}')
for ext in TIFF.FILE_EXTENSIONS
] + [('allfiles', '*')]
def AXES_LABELS():
# TODO: is there a standard for character axes labels?
axes = {
'X': 'width',
'Y': 'length', # height
'Z': 'depth',
'S': 'sample', # rgb(a), cmyk
'I': 'series', # general sequence of frames/planes/pages/IFDs
'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({v: k for k, v in axes.items()})
return axes
def NDPI_TAGS():
# 65420 - 65458 Private Hamamatsu NDPI tags
# TODO: obtain specification
return TiffTagRegistry(
(
(65324, 'OffsetHighBytes'),
(65325, 'ByteCountHighBytes'),
(65420, 'FileFormat'),
(65421, 'Magnification'), # SourceLens
(65422, 'XOffsetFromSlideCenter'),
(65423, 'YOffsetFromSlideCenter'),
(65424, 'ZOffsetFromSlideCenter'), # FocalPlane
(65425, 'TissueIndex'),
(65426, 'McuStarts'),
(65427, 'SlideLabel'),
(65428, 'AuthCode'), # ?
(65429, '65429'),
(65430, '65430'),
(65431, '65431'),
(65432, 'McuStartsHighBytes'),
(65433, '65433'),
(65434, 'Fluorescence'), # FilterSetName
(65435, 'ExposureRatio'),
(65436, 'RedMultiplier'),
(65437, 'GreenMultiplier'),
(65438, 'BlueMultiplier'),
(65439, 'FocusPoints'),
(65440, 'FocusPointRegions'),
(65441, 'CaptureMode'),
(65442, 'ScannerSerialNumber'),
(65443, '65443'),
(65444, 'JpegQuality'),
(65445, 'RefocusInterval'),
(65446, 'FocusOffset'),
(65447, 'BlankLines'),
(65448, 'FirmwareVersion'),
(65449, 'Comments'), # PropertyMap, CalibrationInfo
(65450, 'LabelObscured'),
(65451, 'Wavelength'),
(65452, '65452'),
(65453, 'LampAge'),
(65454, 'ExposureTime'),
(65455, 'FocusTime'),
(65456, 'ScanTime'),
(65457, 'WriteTime'),
(65458, 'FullyAutoFocus'),
(65500, 'DefaultGamma'),
)
)
def EXIF_TAGS():
# 65000 - 65112 Photoshop Camera RAW EXIF tags
tags = TiffTagRegistry(
(
(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 TiffTagRegistry(
(
(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 TiffTagRegistry(
(
(1, 'InteroperabilityIndex'),
(2, 'InteroperabilityVersion'),
(4096, 'RelatedImageFileFormat'),
(4097, 'RelatedImageWidth'),
(4098, 'RelatedImageLength'),
)
)
def GEO_KEYS():
try:
from .tifffile_geodb import GeoKeys # delayed import
except ImportError:
try:
from tifffile_geodb import GeoKeys # delayed import
except ImportError:
class GeoKeys(enum.IntEnum):
pass
return GeoKeys
def GEO_CODES():
try:
from .tifffile_geodb import GEO_CODES # delayed import
except ImportError:
try:
from tifffile_geodb import GEO_CODES # delayed import
except ImportError:
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_positions,
'TilePositions': read_lsm_positions,
'VectorOverlay': None,
'InputLut': read_lsm_lookuptable,
'OutputLut': read_lsm_lookuptable,
'TimeIntervall': None,
'ChannelDataTypes': read_lsm_channeldatatypes,
'KsData': None,
'Roi': None,
'BleachRoi': None,
'NextRecording': None, # read with TiffFile(fh, offset=)
'MeanOfRoisOverlay': None,
'TopoIsolineOverlay': None,
'TopoProfileOverlay': None,
'ChannelWavelength': read_lsm_channelwavelength,
'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 CZ_LSM_LUTTYPE():
class CZ_LSM_LUTTYPE(enum.IntEnum):
NORMAL = 0
ORIGINAL = 1
RAMP = 2
POLYLINE = 3
SPLINE = 4
GAMMA = 5
return CZ_LSM_LUTTYPE
def CZ_LSM_SUBBLOCK_TYPE():
class CZ_LSM_SUBBLOCK_TYPE(enum.IntEnum):
END = 0
GAMMA = 1
BRIGHTNESS = 2
CONTRAST = 3
RAMP = 4
KNOTS = 5
PALETTE_12_TO_12 = 6
return CZ_LSM_SUBBLOCK_TYPE
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 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 ALLOCATIONGRANULARITY():
# alignment for writing contiguous data to TIFF
import mmap # delayed import
return mmap.ALLOCATIONGRANULARITY
def MAXWORKERS():
# half of CPU cores
import multiprocessing # delayed import
return max(multiprocessing.cpu_count() // 2, 1)
def CHUNKMODE():
class CHUNKMODE(enum.IntEnum):
NONE = 0
PLANE = 1
PAGE = 2
FILE = 3
return CHUNKMODE
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.
Does not work with NDPI.
"""
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 TiffFileError('suspicious number of tags')
except Exception:
log_warning(f'read_tags: corrupted tag list at offset {offset}')
break
tags = {}
data = fh.read(tagsize * tagno)
pos = fh.tell()
index = 0
for _ in range(tagno):
code, dtype = unpack(tagformat1, data[index : index + 4])
count, value = unpack(
tagformat2, data[index + 4 : index + tagsize]
)
index += tagsize
name = tagnames.get(code, str(code))
try:
dataformat = TIFF.DATA_FORMATS[dtype]
except KeyError:
raise TiffFileError(f'unknown tag data type {dtype}')
fmt = '{}{}{}'.format(
byteorder, count * int(dataformat[0]), dataformat[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 TiffFileError(f'invalid tag value offset {offset}')
fh.seek(offset)
if code in customtags:
readfunc = customtags[code][1]
value = readfunc(fh, byteorder, dtype, count, offsetsize)
elif dtype == 7 or (count > 1 and dtype == 1):
value = read_bytes(fh, byteorder, dtype, count, offsetsize)
elif code in tagnames or dtype == 2:
value = unpack(fmt, fh.read(size))
else:
value = read_numpy(fh, byteorder, dtype, count, offsetsize)
elif dtype in (1, 7):
# BYTES, UNDEFINED
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 dtype == 2 and isinstance(value, bytes):
# TIFF ASCII fields can contain multiple strings,
# each terminated with a NUL
try:
value = bytes2str(stripnull(value, first=False).strip())
except UnicodeDecodeError:
log_warning(
'read_tags: coercing invalid ASCII to bytes '
f'(tag {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:
log_warning(f'read_tags: invalid page offset ({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."""
return read_tags(fh, byteorder, offsetsize, TIFF.IOP_TAGS, maxifds=1)
def read_bytes(fh, byteorder, dtype, count, offsetsize):
"""Read tag data from file and return as bytes."""
dtype = 'B' if dtype == 2 else byteorder + TIFF.DATA_FORMATS[dtype][-1]
count *= numpy.dtype(dtype).itemsize
data = fh.read(count)
if len(data) != count:
log_warning(
f'read_bytes: failed to read all bytes ({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()
def read_numpy(fh, byteorder, dtype, count, offsetsize):
"""Read tag data from file and return as numpy array."""
dtype = 'b' if dtype == 2 else byteorder + TIFF.DATA_FORMATS[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 + TIFF.DATA_FORMATS[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(stripnull(data).decode())
except ValueError:
log_warning('read_json: invalid JSON')
return None
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.
"""
if dtype not in (4, 5) or byteorder != '<':
raise ValueError(f'invalid UIC1Tag {byteorder}{dtype}')
result = {}
if dtype == 5:
# pre MetaMorph 2.5 (not tested)
values = fh.read_array('<u4', 2 * count).reshape(count, 2)
result = {'ZDistance': values[:, 0] / values[:, 1]}
elif planecount:
for _ in range(count):
tagid = struct.unpack('<I', fh.read(4))[0]
if tagid in (28, 29, 37, 40, 41):
# silently skip unexpected tags
fh.read(4)
continue
name, value = read_uic_tag(fh, tagid, planecount, offset=True)
result[name] = value
return result
def read_uic2tag(fh, byteorder, dtype, planecount, offsetsize):
"""Read MetaMorph STK UIC2Tag from file and return as dict."""
if dtype != 5 or byteorder != '<':
raise ValueError('invalid UIC2Tag')
values = fh.read_array('<u4', 6 * planecount).reshape(planecount, 6)
return {
'ZDistance': values[:, 0] / values[:, 1],
'DateCreated': values[:, 2], # julian days
'TimeCreated': values[:, 3], # milliseconds
'DateModified': values[:, 4], # julian days
'TimeModified': values[:, 5], # milliseconds
}
def read_uic3tag(fh, byteorder, dtype, planecount, offsetsize):
"""Read MetaMorph STK UIC3Tag from file and return as dict."""
if dtype != 5 or byteorder != '<':
raise ValueError('invalid UIC3Tag')
values = fh.read_array('<u4', 2 * planecount).reshape(planecount, 2)
return {'Wavelengths': values[:, 0] / values[:, 1]}
def read_uic4tag(fh, byteorder, dtype, planecount, offsetsize):
"""Read MetaMorph STK UIC4Tag from file and return as dict."""
if dtype != 4 or byteorder != '<':
raise ValueError('invalid UIC4Tag')
result = {}
while True:
tagid = struct.unpack('<H', fh.read(2))[0]
if tagid == 0:
break
name, value = read_uic_tag(fh, tagid, planecount, offset=False)
result[name] = value
return result
def read_uic_tag(fh, tagid, planecount, offset):
"""Read a single UIC tag value from file and return tag name and value.
UIC1Tags use an offset.
"""
def read_int(count=1):
value = struct.unpack(f'<{count}I', fh.read(4 * count))
return value[0] if count == 1 else value
try:
name, dtype = TIFF.UIC_TAGS[tagid]
except IndexError:
# unknown tag
return f'_TagId{tagid}', read_int()
Fraction = TIFF.UIC_TAGS[4][1]
if offset:
pos = fh.tell()
if dtype not in (int, None):
off = read_int()
if off < 8:
if dtype is str:
return name, ''
log_warning(
f'read_uic_tag: invalid offset for tag {name!r} @{off}'
)
return name, off
fh.seek(off)
if dtype is None:
# skip
name = '_' + name
value = read_int()
elif dtype is int:
# int
value = read_int()
elif dtype is Fraction:
# fraction
value = read_int(2)
value = value[0] / value[1]
elif dtype is julian_datetime:
# datetime
value = julian_datetime(*read_int(2))
elif dtype is read_uic_image_property:
# ImagePropertyEx
value = read_uic_image_property(fh)
elif dtype is str:
# pascal string
size = read_int()
if 0 <= size < 2 ** 10:
value = struct.unpack(f'{size}s', fh.read(size))[0][:-1]
value = bytes2str(stripnull(value))
elif offset:
value = ''
log_warning(f'read_uic_tag: corrupt string in tag {name!r}')
else:
raise ValueError(f'read_uic_tag: invalid string size {size}')
elif dtype == '%ip':
# sequence of pascal strings
value = []
for _ in range(planecount):
size = read_int()
if 0 <= size < 2 ** 10:
string = struct.unpack(f'{size}s', fh.read(size))[0][:-1]
string = bytes2str(stripnull(string))
value.append(string)
elif offset:
log_warning(f'read_uic_tag: corrupt string in tag {name!r}')
else:
raise ValueError(f'read_uic_tag: invalid string size: {size}')
else:
# struct or numpy type
dtype = '<' + dtype
if '%i' in dtype:
dtype = dtype % planecount
if '(' in dtype:
# numpy type
value = fh.read_array(dtype, 1)[0]
if value.shape[-1] == 2:
# assume fractions
value = value[..., 0] / value[..., 1]
else:
# struct format
value = struct.unpack(dtype, fh.read(struct.calcsize(dtype)))
if len(value) == 1:
value = value[0]
if offset:
fh.seek(pos + 4)
return name, value
def read_uic_image_property(fh):
"""Read UIC ImagePropertyEx tag from file and return as dict."""
# TODO: test this
size = struct.unpack('B', fh.read(1))[0]
name = struct.unpack(f'{size}s', fh.read(size))[0][:-1]
flags, prop = struct.unpack('<IB', fh.read(5))
if prop == 1:
value = struct.unpack('II', fh.read(8))
value = value[0] / value[1]
else:
size = struct.unpack('B', fh.read(1))[0]
value = struct.unpack(f'{size}s', fh.read(size))[0]
return dict(name=name, flags=flags, value=value)
def read_cz_lsminfo(fh, byteorder, dtype, count, offsetsize):
"""Read CZ_LSMINFO tag from file and return as dict."""
if byteorder != '<':
raise ValueError('invalid CZ_LSMINFO structure')
magic_number, structure_size = struct.unpack('<II', fh.read(8))
if magic_number not in (50350412, 67127628):
raise ValueError('invalid CZ_LSMINFO structure')
fh.seek(-8, os.SEEK_CUR)
if structure_size < numpy.dtype(TIFF.CZ_LSMINFO).itemsize:
# adjust structure according to structure_size
lsminfo = []
size = 0
for name, dtype in TIFF.CZ_LSMINFO:
size += numpy.dtype(dtype).itemsize
if size > 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_channeldatatypes(fh):
"""Read LSM channel data type."""
size = struct.unpack('<I', fh.read(4))[0]
return fh.read_array('<u4', count=size)
def read_lsm_channelwavelength(fh):
"""Read LSM channel wavelength ranges from file and return as list."""
size = struct.unpack('<i', fh.read(4))[0]
return fh.read_array('<2f8', count=size)
def read_lsm_positions(fh):
"""Read LSM positions from file and return as list."""
size = struct.unpack('<I', fh.read(4))[0]
return fh.read_array('<3f8', count=size)
def read_lsm_timestamps(fh):
"""Read LSM time stamps from file and return as list."""
size, count = struct.unpack('<ii', fh.read(8))
if size != (8 + 8 * count):
log_warning('read_lsm_timestamps: invalid LSM TimeStamps block')
return []
# return struct.unpack(f'<{count}d', fh.read(8 * count))
return fh.read_array('<f8', count=count)
def read_lsm_eventlist(fh):
"""Read LSM events from file and return as list of (time, type, text)."""
count = struct.unpack('<II', fh.read(8))[1]
events = []
while count > 0:
esize, etime, etype = struct.unpack('<IdI', fh.read(16))
etext = bytes2str(stripnull(fh.read(esize - 16)))
events.append((etime, etype, etext))
count -= 1
return events
def read_lsm_channelcolors(fh):
"""Read LSM ChannelColors structure from file and return as dict."""
result = {'Mono': False, 'Colors': [], 'ColorNames': []}
pos = fh.tell()
(size, ncolors, nnames, coffset, noffset, mono) = struct.unpack(
'<IIIIII', fh.read(24)
)
if ncolors != nnames:
log_warning(
'read_lsm_channelcolors: invalid LSM ChannelColors structure'
)
return result
result['Mono'] = bool(mono)
# Colors
fh.seek(pos + coffset)
colors = fh.read_array('uint8', count=ncolors * 4).reshape((ncolors, 4))
result['Colors'] = colors.tolist()
# ColorNames
fh.seek(pos + noffset)
buffer = fh.read(size - noffset)
names = []
while len(buffer) > 4:
size = struct.unpack('<I', buffer[:4])[0]
names.append(bytes2str(buffer[4 : 3 + size]))
buffer = buffer[4 + size :]
result['ColorNames'] = names
return result
def read_lsm_lookuptable(fh):
"""Read LSM lookup tables from file and return as dict."""
result = {}
(
size,
nsubblocks,
nchannels,
luttype,
advanced,
currentchannel,
) = struct.unpack('<iiiiii', fh.read(24))
if size < 60:
log_warning('read_lsm_lookuptable: invalid LSM LookupTables structure')
return result
fh.read(9 * 4) # reserved
result['LutType'] = TIFF.CZ_LSM_LUTTYPE(luttype)
result['Advanced'] = advanced
result['NumberChannels'] = nchannels
result['CurrentChannel'] = currentchannel
result['SubBlocks'] = subblocks = []
for i in range(nsubblocks):
sbtype = struct.unpack('<i', fh.read(4))[0]
if sbtype <= 0:
break
size = struct.unpack('<i', fh.read(4))[0] - 8
if sbtype == 1:
data = fh.read_array('<f8', count=nchannels)
elif sbtype == 2:
data = fh.read_array('<f8', count=nchannels)
elif sbtype == 3:
data = fh.read_array('<f8', count=nchannels)
elif sbtype == 4:
# the data type is wrongly documented as f8
data = fh.read_array('<i4', count=nchannels * 4)
data = data.reshape((-1, 2, 2))
elif sbtype == 5:
# the data type is wrongly documented as f8
nknots = struct.unpack('<i', fh.read(4))[0] # undocumented
data = fh.read_array('<i4', count=nchannels * nknots * 2)
data = data.reshape((nchannels, nknots, 2))
elif sbtype == 6:
data = fh.read_array('<i2', count=nchannels * 4096)
data = data.reshape((-1, 4096))
else:
log_warning(
f'read_lsm_lookuptable: invalid LSM SubBlock type {sbtype}'
)
break
subblocks.append(
{'Type': TIFF.CZ_LSM_SUBBLOCK_TYPE(sbtype), 'Data': data}
)
return result
def read_lsm_scaninfo(fh):
"""Read LSM ScanInfo structure from file and return as dict."""
block = {}
blocks = [block]
unpack = struct.unpack
if struct.unpack('<I', fh.read(4))[0] != 0x10000000:
# not a Recording sub block
log_warning('read_lsm_scaninfo: invalid LSM ScanInfo structure')
return block
fh.read(8)
while True:
entry, dtype, size = unpack('<III', fh.read(12))
if dtype == 2:
# ascii
value = bytes2str(stripnull(fh.read(size)))
elif dtype == 4:
# long
value = unpack('<i', fh.read(4))[0]
elif dtype == 5:
# rational
value = unpack('<d', fh.read(8))[0]
else:
value = 0
if entry in TIFF.CZ_LSMINFO_SCANINFO_ARRAYS:
blocks.append(block)
name = TIFF.CZ_LSMINFO_SCANINFO_ARRAYS[entry]
newobj = []
block[name] = newobj
block = newobj
elif entry in TIFF.CZ_LSMINFO_SCANINFO_STRUCTS:
blocks.append(block)
newobj = {}
block.append(newobj)
block = newobj
elif entry in TIFF.CZ_LSMINFO_SCANINFO_ATTRIBUTES:
name = TIFF.CZ_LSMINFO_SCANINFO_ATTRIBUTES[entry]
block[name] = value
elif entry == 0xFFFFFFFF:
# end sub block
block = blocks.pop()
else:
# unknown entry
block[f'Entry0x{entry:x}'] = value
if not blocks:
break
return block
def read_sis(fh, byteorder, dtype, count, offsetsize):
"""Read OlympusSIS structure and return as dict.
No specification is avaliable. Only few fields are known.
"""
result = {}
(magic, minute, hour, day, month, year, name, tagcount) = struct.unpack(
'<4s6xhhhhh6x32sh', fh.read(60)
)
if magic != b'SIS0':
raise ValueError('invalid OlympusSIS structure')
result['name'] = bytes2str(stripnull(name))
try:
result['datetime'] = datetime.datetime(
1900 + year, month + 1, day, hour, minute
)
except ValueError:
pass
data = fh.read(8 * tagcount)
for i in range(0, tagcount * 8, 8):
tagtype, count, offset = struct.unpack('<hhI', data[i : i + 8])
fh.seek(offset)
if tagtype == 1:
# general data
(lenexp, xcal, ycal, mag, camname, pictype) = struct.unpack(
'<10xhdd8xd2x34s32s', fh.read(112) # 220
)
m = math.pow(10, lenexp)
result['pixelsizex'] = xcal * m
result['pixelsizey'] = ycal * m
result['magnification'] = mag
result['cameraname'] = bytes2str(stripnull(camname))
result['picturetype'] = bytes2str(stripnull(pictype))
elif tagtype == 10:
# channel data
continue
# TODO: does not seem to work?
# (length, _, exptime, emv, _, camname, _, mictype,
# ) = struct.unpack('<h22sId4s32s48s32s', fh.read(152)) # 720
# result['exposuretime'] = exptime
# result['emvoltage'] = emv
# result['cameraname2'] = bytes2str(stripnull(camname))
# result['microscopename'] = bytes2str(stripnull(mictype))
return result
def read_sis_ini(fh, byteorder, dtype, count, offsetsize):
"""Read OlympusSIS INI string and return as dict."""
inistr = fh.read(count)
inistr = bytes2str(stripnull(inistr))
try:
return olympusini_metadata(inistr)
except Exception as exc:
log_warning(f'olympusini_metadata: {exc.__class__.__name__}: {exc}')
return {}
def read_tvips_header(fh, byteorder, dtype, count, offsetsize):
"""Read TVIPS EM-MENU headers and return as dict."""
result = {}
header = fh.read_record(TIFF.TVIPS_HEADER_V1, byteorder=byteorder)
for name, typestr in TIFF.TVIPS_HEADER_V1:
result[name] = header[name].tolist()
if header['Version'] == 2:
header = fh.read_record(TIFF.TVIPS_HEADER_V2, byteorder=byteorder)
if header['Magic'] != int(0xAAAAAAAA):
log_warning('read_tvips_header: invalid TVIPS v2 magic number')
return {}
# decode utf16 strings
for name, typestr in TIFF.TVIPS_HEADER_V2:
if typestr.startswith('V'):
s = header[name].tobytes().decode('utf-16', errors='ignore')
result[name] = stripnull(s, null='\x00')
else:
result[name] = header[name].tolist()
# convert nm to m
for axis in 'XY':
header['PhysicalPixelSize' + axis] /= 1e9
header['PixelSize' + axis] /= 1e9
elif header.version != 1:
log_warning('read_tvips_header: unknown TVIPS header version')
return {}
return result
def read_fei_metadata(fh, byteorder, dtype, count, offsetsize):
"""Read FEI SFEG/HELIOS headers and return as dict."""
result = {}
section = {}
data = bytes2str(stripnull(fh.read(count)))
for line in data.splitlines():
line = line.strip()
if line.startswith('['):
section = {}
result[line[1:-1]] = section
continue
try:
key, value = line.split('=')
except ValueError:
continue
section[key] = astype(value)
return result
def read_cz_sem(fh, byteorder, dtype, count, offsetsize):
"""Read Zeiss SEM tag and return as dict.
See https://sourceforge.net/p/gwyddion/mailman/message/29275000/ for
unnamed values.
"""
result = {'': ()}
key = None
data = bytes2str(stripnull(fh.read(count)))
for line in data.splitlines():
if line.isupper():
key = line.lower()
elif key:
try:
name, value = line.split('=')
except ValueError:
try:
name, value = line.split(':', 1)
except Exception:
continue
value = value.strip()
unit = ''
try:
v, u = value.split()
number = astype(v, (int, float))
if number != v:
value = number
unit = u
except Exception:
number = astype(value, (int, float))
if number != value:
value = number
if value in ('No', 'Off'):
value = False
elif value in ('Yes', 'On'):
value = True
result[key] = (name.strip(), value)
if unit:
result[key] += (unit,)
key = None
else:
result[''] += (astype(line, (int, float)),)
return result
def read_nih_image_header(fh, byteorder, dtype, count, offsetsize):
"""Read NIH_IMAGE_HEADER tag from file and return as dict."""
a = fh.read_record(TIFF.NIH_IMAGE_HEADER, byteorder=byteorder)
a = a.newbyteorder(byteorder)
a = recarray2dict(a)
a['XUnit'] = a['XUnit'][: a['XUnitSize']]
a['UM'] = a['UM'][: a['UMsize']]
return a
def read_scanimage_metadata(fh):
"""Read ScanImage BigTIFF v3 or v4 static and ROI metadata from open file.
Return non-varying frame data, ROI group data, and version as
tuple(dict, dict, int).
The settings can be used to read image data and metadata without parsing
the TIFF file.
Raise ValueError if file does not contain valid ScanImage metadata.
Frame data and ROI groups can alternatively be obtained from the Software
and Artist tags of any TIFF page.
"""
fh.seek(0)
try:
byteorder, version = struct.unpack('<2sH', fh.read(4))
if byteorder != b'II' or version != 43:
raise ValueError('not a BigTIFF file')
fh.seek(16)
magic, version, size0, size1 = struct.unpack('<IIII', fh.read(16))
if magic != 117637889 or version not in (3, 4):
raise ValueError(
f'invalid magic {magic} or version {version} number'
)
except UnicodeDecodeError as exc:
raise ValueError('file must be opened in binary mode') from exc
except Exception as exc:
raise ValueError('not a ScanImage BigTIFF v3 or v4 file') from exc
frame_data = matlabstr2py(bytes2str(fh.read(size0)[:-1]))
roi_data = read_json(fh, '<', None, size1, None) if size1 > 1 else {}
return frame_data, roi_data, version
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.
"""
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 map
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:
result['Summary'] = read_json(
fh, byteorder, None, summary_length, None
)
else:
log_warning('invalid MicroManager summary header')
if index_header == 54773648:
fh.seek(index_offset)
header, count = struct.unpack(byteorder + 'II', fh.read(8))
if header == 3453623:
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],
}
else:
log_warning('invalid MicroManager index header')
else:
log_warning('invalid MicroManager index header')
if display_header == 483765892:
fh.seek(display_offset)
header, count = struct.unpack(byteorder + 'II', fh.read(8))
if header == 347834724:
result['DisplaySettings'] = read_json(
fh, byteorder, None, count, None
)
else:
log_warning('invalid MicroManager display header')
else:
log_warning('invalid MicroManager display header')
result['MajorVersion'] = 0
if comments_header == 99384722:
# Micro-Manager multipage TIFF
fh.seek(comments_offset)
header, count = struct.unpack(byteorder + 'II', fh.read(8))
if header == 84720485:
result['Comments'] = read_json(fh, byteorder, None, count, None)
else:
log_warning('invalid MicroManager comments header')
elif comments_header == 483729:
# NDTiffStorage
result['MajorVersion'] = comments_offset
else:
log_warning('invalid MicroManager comments header')
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_tag(metadata, byteorder):
"""Return IJMetadata and IJMetadataByteCounts tags from metadata dict.
The tags can be passed to TiffWriter.write() 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.
"""
if not metadata:
return ()
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', _string),
('Labels', b'labl', _string),
('Ranges', b'rang', _doubles),
('LUTs', b'luts', _ndarray),
('Plot', b'plot', _bytes),
('ROI', b'roi ', _bytes),
('Overlays', b'over', _bytes),
)
for key, mtype, 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 isinstance(values, list):
count = len(values)
else:
values = [values]
count = 1
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, 1, len(data), data, True),
(50838, 4, 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.
'ROI' and 'Overlays' are returned as bytes, which can be parsed with the
ImagejRoi.frombytes() function of the roifile package.
"""
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
# big-endian
metadata_types = {
b'info': ('Info', _string),
b'labl': ('Labels', _string),
b'rang': ('Ranges', _doubles),
b'luts': ('LUTs', _lut),
b'plot': ('Plot', _bytes),
b'roi ': ('ROI', _bytes),
b'over': ('Overlays', _bytes),
}
# little-endian
metadata_types.update({k[::-1]: v for k, v in metadata_types.items()})
if not bytecounts:
raise ValueError('no ImageJ metadata')
if not data[:4] 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):
r"""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 an ImageJ image description')
return result
def imagej_description(
shape,
rgb=None,
colormaped=False,
version=None,
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')
if version is None:
version = kwargs.pop('ImageJ', '1.11a')
axes = kwargs.pop('axes', None)
shape = imagej_shape(shape, rgb=rgb, axes=axes)
rgb = shape[-1] in (3, 4)
append = []
result = [f'ImageJ={version}']
result.append(f'images={product(shape[:-3])}')
if hyperstack is None:
hyperstack = True
append.append('hyperstack=true')
else:
append.append(f'hyperstack={bool(hyperstack)}')
if shape[2] > 1:
result.append(f'channels={shape[2]}')
if mode is None and not rgb:
mode = 'grayscale'
if hyperstack and mode:
append.append(f'mode={mode}')
if shape[1] > 1:
result.append(f'slices={shape[1]}')
if shape[0] > 1:
result.append(f'frames={shape[0]}')
if loop is None:
append.append('loop=false')
if loop is not None:
append.append(f'loop={bool(loop)}'.lower())
for key, value in kwargs.items():
if key not in ('images', 'channels', 'slices', 'frames'):
append.append(f'{key.lower()}={value}')
return '\n'.join(result + append + [''])
def imagej_shape(shape, rgb=None, axes=None):
"""Return shape normalized to 6D ImageJ hyperstack TZCYXS.
Raise ValueError if not a valid ImageJ hyperstack shape or axes order.
>>> 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('ImageJ hyperstack must be 2-6 dimensional')
if axes:
if len(axes) != ndim:
raise ValueError('ImageJ hyperstack shape and axes do not match')
i = 0
axes = axes.upper()
for ax in axes:
j = 'TZCYXS'.find(ax)
if j < i:
raise ValueError(
'ImageJ hyperstack axes must be in TZCYXS order'
)
i = j
ndims = len(axes)
newshape = []
i = 0
for ax in 'TZCYXS':
if i < ndims and ax == axes[i]:
newshape.append(shape[i])
i += 1
else:
newshape.append(1)
if newshape[-1] not in (1, 3, 4):
raise ValueError(
'ImageJ hyperstack must contain 1, 3, or 4 samples'
)
return tuple(newshape)
if rgb is None:
rgb = shape[-1] in (3, 4) and ndim > 2
if rgb and shape[-1] not in (3, 4):
raise ValueError('ImageJ hyperstack is not a RGB image')
if not rgb and ndim == 6 and shape[-1] != 1:
raise ValueError('ImageJ hyperstack is not a grayscale image')
if rgb or shape[-1] == 1:
return (1,) * (6 - ndim) + shape
return (1,) * (5 - ndim) + shape + (1,)
def jpeg_decode_colorspace(photometric, planarconfig, extrasamples):
"""Return JPEG and output colorspace for jpeg_decode function."""
colorspace = None
outcolorspace = None
if extrasamples:
pass
elif photometric == 6:
# YCBCR -> RGB
outcolorspace = 2 # RGB
elif photometric == 2:
if planarconfig == 1:
colorspace = outcolorspace = 2 # RGB
elif photometric > 3:
outcolorspace = TIFF.PHOTOMETRIC(photometric).value
return colorspace, outcolorspace
def ndpi_jpeg_tile(jpeg):
"""Return tile shape and JPEG header from JPEG with restart markers."""
restartinterval = 0
sofoffset = 0
sosoffset = 0
i = 0
while True and i < len(jpeg):
marker = struct.unpack('>H', jpeg[i : i + 2])[0]
i += 2
if marker == 0xFFD8:
# start of image
continue
if marker == 0xFFD9:
# end of image
break
if marker >= 0xFFD0 and marker <= 0xFFD7:
# restart marker
continue
if marker == 0xFF01:
# private marker
continue
length = struct.unpack('>H', jpeg[i : i + 2])[0]
i += 2
if marker == 0xFFDD:
# define restart interval
restartinterval = struct.unpack('>H', jpeg[i : i + 2])[0]
elif marker == 0xFFC0:
# start of frame
sofoffset = i + 1
precision, imlength, imwidth, ncomponents = struct.unpack(
'>BHHB', jpeg[i : i + 6]
)
i += 6
mcuwidth = 1
mcuheight = 1
for _ in range(ncomponents):
cid, factor, table = struct.unpack('>BBB', jpeg[i : i + 3])
i += 3
if factor >> 4 > mcuwidth:
mcuwidth = factor >> 4
if factor & 0b00001111 > mcuheight:
mcuheight = factor & 0b00001111
mcuwidth *= 8
mcuheight *= 8
i = sofoffset - 1
elif marker == 0xFFDA:
# start of scan
sosoffset = i + length - 2
break
# skip to next marker
i += length - 2
if restartinterval == 0 or sofoffset == 0 or sosoffset == 0:
raise ValueError('missing required JPEG markers')
# patch jpeg header for tile size
tilelength = mcuheight
tilewidth = restartinterval * mcuwidth
jpegheader = (
jpeg[:sofoffset]
+ struct.pack('>HH', tilelength, tilewidth)
+ jpeg[sofoffset + 4 : sosoffset]
)
return tilelength, tilewidth, jpegheader
def json_description(shape, **metadata):
"""Return JSON image description from data shape and other metadata.
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()
def json_description_metadata(description):
"""Return metatata from JSON formated 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):
r"""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 '):
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 as exc:
log_warning(
f'stk_description_metadata: {exc.__class__.__name__}: {exc}'
)
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('<MetaData>'):
raise ValueError('invalid MetaSeries image description')
from xml.etree import ElementTree 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('&#13;&#10;', '\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 as exc:
log_warning(
f'scanimage_artist_metadata: {exc.__class__.__name__}: {exc}'
)
return None
def olympusini_metadata(inistr):
"""Return OlympusSIS metadata from INI string.
No documentation is available.
"""
def keyindex(key):
# split key into name and index
index = 0
i = len(key.rstrip('0123456789'))
if i < len(key):
index = int(key[i:]) - 1
key = key[:i]
return key, index
result = {}
bands = []
zpos = None
tpos = None
for line in inistr.splitlines():
line = line.strip()
if line == '' or line[0] == ';':
continue
if line[0] == '[' and line[-1] == ']':
section_name = line[1:-1]
result[section_name] = section = {}
if section_name == 'Dimension':
result['axes'] = axes = []
result['shape'] = shape = []
elif section_name == 'ASD':
result[section_name] = []
elif section_name == 'Z':
if 'Dimension' in result:
result[section_name]['ZPos'] = zpos = []
elif section_name == 'Time':
if 'Dimension' in result:
result[section_name]['TimePos'] = tpos = []
elif section_name == 'Band':
nbands = result['Dimension']['Band']
bands = [{'LUT': []} for _ in range(nbands)]
result[section_name] = bands
iband = 0
else:
key, value = line.split('=')
if value.strip() == '':
value = None
elif ',' in value:
value = tuple(astype(v) for v in value.split(','))
else:
value = astype(value)
if section_name == 'Dimension':
section[key] = value
axes.append(key)
shape.append(value)
elif section_name == 'ASD':
if key == 'Count':
result['ASD'] = [{}] * value
else:
key, index = keyindex(key)
result['ASD'][index][key] = value
elif section_name == 'Band':
if key[:3] == 'LUT':
lut = bands[iband]['LUT']
value = struct.pack('<I', value)
lut.append(
[ord(value[0:1]), ord(value[1:2]), ord(value[2:3])]
)
else:
key, iband = keyindex(key)
bands[iband][key] = value
elif key[:4] == 'ZPos' and zpos is not None:
zpos.append(value)
elif key[:7] == 'TimePos' and tpos is not None:
tpos.append(value)
else:
section[key] = value
if 'axes' in result:
sisaxes = {'Band': 'C'}
axes = []
shape = []
for i, x in zip(result['shape'], result['axes']):
if i > 1:
axes.append(sisaxes.get(x, x[0].upper()))
shape.append(i)
result['axes'] = ''.join(axes)
result['shape'] = tuple(shape)
try:
result['Z']['ZPos'] = numpy.array(
result['Z']['ZPos'][: result['Dimension']['Z']], 'float64'
)
except Exception:
pass
try:
result['Time']['TimePos'] = numpy.array(
result['Time']['TimePos'][: result['Dimension']['Time']], 'int32'
)
except Exception:
pass
for band in bands:
band['LUT'] = numpy.array(band['LUT'], 'uint8')
return result
def unpack_rgb(data, dtype=None, bitspersample=None, rescale=True):
"""Return array from bytes containing packed samples.
Use to unpack RGB565 or RGB555 to RGB888 format.
Works on little-endian platforms only.
Parameters
----------
data : byte str
The data to be decoded. Samples in each pixel are stored consecutively.
Pixels are aligned to 8, 16, or 32 bit boundaries.
dtype : numpy.dtype
The sample data type. The byteorder applies also to the data stream.
bitspersample : tuple
Number of bits for each sample in a pixel.
rescale : bool
Upscale samples to the number of bits in dtype.
Returns
-------
numpy.ndarray
Flattened array of unpacked samples of native dtype.
Examples
--------
>>> data = struct.pack('BBBB', 0x21, 0x08, 0xff, 0xff)
>>> print(unpack_rgb(data, '<B', (5, 6, 5), False))
[ 1 1 1 31 63 31]
>>> print(unpack_rgb(data, '<B', (5, 6, 5)))
[ 8 4 8 255 255 255]
>>> print(unpack_rgb(data, '<B', (5, 5, 5)))
[ 16 8 8 255 255 255]
"""
if bitspersample is None:
bitspersample = (5, 6, 5)
if dtype is None:
dtype = '<B'
dtype = numpy.dtype(dtype)
bits = int(numpy.sum(bitspersample))
if not (
bits <= 32 and all(i <= dtype.itemsize * 8 for i in bitspersample)
):
raise ValueError(f'sample size not supported: {bitspersample}')
dt = next(i for i in 'BHI' if numpy.dtype(i).itemsize * 8 >= 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)
def float24_decode(data, byteorder):
"""Return float32 array from float24."""
raise NotImplementedError('float24_decode')
def zlib_encode(data, level=None, out=None):
"""Compress Zlib DEFLATE."""
import zlib
return zlib.compress(data, 6 if level is None else level)
def zlib_decode(data, out=None):
"""Decompress Zlib DEFLATE."""
import zlib
return zlib.decompress(data)
def lzma_encode(data, level=None, out=None):
"""Compress LZMA."""
import lzma
return lzma.compress(data)
def lzma_decode(data, out=None):
"""Decompress LZMA."""
import lzma
return lzma.decompress(data)
if imagecodecs is None:
def delta_encode(data, axis=-1, dist=1, out=None):
"""Encode Delta."""
if dist != 1:
raise NotImplementedError(f'dist {dist} not implemented')
if isinstance(data, (bytes, bytearray)):
data = numpy.frombuffer(data, dtype='u1')
diff = numpy.diff(data, axis=0)
return numpy.insert(diff, 0, data[0]).tobytes()
dtype = data.dtype
if dtype.kind == 'f':
data = data.view(f'u{dtype.itemsize}')
diff = numpy.diff(data, axis=axis)
key = [slice(None)] * data.ndim
key[axis] = 0
diff = numpy.insert(diff, 0, data[tuple(key)], axis=axis)
if dtype.kind == 'f':
return diff.view(dtype)
return diff
def delta_decode(data, axis=-1, dist=1, out=None):
"""Decode Delta."""
if dist != 1:
raise NotImplementedError(f'dist {dist} not implemented')
if out is not None and not out.flags.writeable:
out = None
if isinstance(data, (bytes, bytearray)):
data = numpy.frombuffer(data, dtype='u1')
return numpy.cumsum(data, axis=0, dtype='u1', out=out).tobytes()
if data.dtype.kind == 'f':
view = data.view(f'u{data.dtype.itemsize}')
view = numpy.cumsum(view, axis=axis, dtype=view.dtype)
return view.view(data.dtype)
return numpy.cumsum(data, axis=axis, dtype=data.dtype, out=out)
def bitorder_decode(data, out=None, _bitorder=[]):
r"""Reverse bits in each byte of bytes or numpy array.
Decode data where pixels with lower column values are stored in the
lower-order bits of the bytes (TIFF FillOrder is LSB2MSB).
Parameters
----------
data : bytes or ndarray
The data to be bit reversed. If bytes, a new bit-reversed
bytes is returned. Numpy arrays are bit-reversed in-place.
Examples
--------
>>> bitorder_decode(b'\x01\x64')
b'\x80&'
>>> data = numpy.array([1, 666], dtype='uint16')
>>> bitorder_decode(data)
>>> data
array([ 128, 16473], dtype=uint16)
"""
if not _bitorder:
_bitorder.append(
b'\x00\x80@\xc0 \xa0`\xe0\x10\x90P\xd00\xb0p\xf0\x08\x88H'
b'\xc8(\xa8h\xe8\x18\x98X\xd88\xb8x\xf8\x04\x84D\xc4$\xa4d'
b'\xe4\x14\x94T\xd44\xb4t\xf4\x0c\x8cL\xcc,\xacl\xec\x1c\x9c'
b'\\\xdc<\xbc|\xfc\x02\x82B\xc2"\xa2b\xe2\x12\x92R\xd22'
b'\xb2r\xf2\n\x8aJ\xca*\xaaj\xea\x1a\x9aZ\xda:\xbaz\xfa'
b'\x06\x86F\xc6&\xa6f\xe6\x16\x96V\xd66\xb6v\xf6\x0e\x8eN'
b'\xce.\xaen\xee\x1e\x9e^\xde>\xbe~\xfe\x01\x81A\xc1!\xa1a'
b'\xe1\x11\x91Q\xd11\xb1q\xf1\t\x89I\xc9)\xa9i\xe9\x19'
b'\x99Y\xd99\xb9y\xf9\x05\x85E\xc5%\xa5e\xe5\x15\x95U\xd55'
b'\xb5u\xf5\r\x8dM\xcd-\xadm\xed\x1d\x9d]\xdd=\xbd}\xfd'
b'\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'
b'\xe7\x17\x97W\xd77\xb7w\xf7\x0f\x8fO\xcf/\xafo\xef\x1f\x9f_'
b'\xdf?\xbf\x7f\xff'
)
_bitorder.append(numpy.frombuffer(_bitorder[0], dtype='uint8'))
try:
view = data.view('uint8')
numpy.take(_bitorder[1], view, out=view)
return data
except AttributeError:
return data.translate(_bitorder[0])
except ValueError:
raise NotImplementedError('slices of arrays not supported')
return None
def packints_encode(data, bitspersample, axis=-1, out=None):
"""Tightly pack integers."""
raise NotImplementedError('packints_encode')
def packints_decode(data, dtype, bitspersample, runlen=0, out=None):
"""Decompress bytes to array of integers.
This implementation only handles itemsizes 1, 8, 16, 32, and 64 bits.
Install the imagecodecs package for decoding other integer sizes.
Parameters
----------
data : byte str
Data to decompress.
dtype : numpy.dtype or str
A numpy boolean or integer type.
bitspersample : int
Number of bits per integer.
runlen : int
Number of consecutive integers, after which to start at next byte.
Examples
--------
>>> packints_decode(b'a', 'B', 1)
array([0, 1, 1, 0, 0, 0, 0, 1], dtype=uint8)
"""
if bitspersample == 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)
if bitspersample in (8, 16, 32, 64):
return numpy.frombuffer(data, dtype)
raise NotImplementedError(
f'unpacking {bitspersample}-bit integers '
f'to {numpy.dtype(dtype)} not supported'
)
def packbits_decode(encoded, out=None):
r"""Decompress PackBits encoded byte string.
>>> packbits_decode(b'\x80\x80') # NOP
b''
>>> packbits_decode(b'\x02123')
b'123'
>>> packbits_decode(
... b'\xfe\xaa\x02\x80\x00\x2a\xfd\xaa\x03\x80\x00\x2a\x22\xf7\xaa'
... )[:-5]
b'\xaa\xaa\xaa\x80\x00*\xaa\xaa\xaa\xaa\x80\x00*"\xaa\xaa\xaa\xaa\xaa'
"""
out = []
out_extend = out.extend
i = 0
try:
while True:
n = ord(encoded[i : i + 1]) + 1
i += 1
if n > 129:
# replicate
out_extend(encoded[i : i + 1] * (258 - n))
i += 1
elif n < 129:
# literal
out_extend(encoded[i : i + n])
i += n
except TypeError:
pass
return bytes(out)
else:
bitorder_decode = imagecodecs.bitorder_decode # noqa
packints_decode = imagecodecs.packints_decode # noqa
packints_encode = imagecodecs.packints_encode # noqa
try:
float24_decode = imagecodecs.float24_decode # noqa
except AttributeError:
pass
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 parse_filenames(files, pattern, axesorder=None):
r"""Return shape and axes from sequence of file names matching pattern.
>>> parse_filenames(
... ['c1001.ext', 'c2002.ext'], r'([^\d])(\d)(?P<t>\d+)\.ext'
... )
('ct', (2, 2), [(0, 0), (1, 1)], (1, 1))
"""
if not pattern:
raise ValueError('invalid pattern')
if isinstance(pattern, str):
pattern = re.compile(pattern)
def parse(fname, pattern=pattern):
# return axes and indices from file name
# fname = os.path.split(fname)[-1]
axes = []
indices = []
groupindex = {v: k for k, v in pattern.groupindex.items()}
match = pattern.search(fname)
if not match:
raise ValueError('pattern does not match file name')
ax = None
for i, m in enumerate(match.groups()):
if m is None:
continue
if i + 1 in groupindex:
ax = groupindex[i + 1] # names axis
if not m[0].isdigit():
m = ord(m) # index letter to number
if m < 65 or m > 122:
raise ValueError(f'invalid index {m!r}')
elif m[0].isalpha():
ax = m # axis letter for next index
continue
if ax is None:
ax = 'Q' # no preceding axis letter
try:
m = int(m)
except Exception:
raise ValueError(f'invalid index {m!r}')
indices.append(m)
axes.append(ax)
ax = None
return ''.join(axes), indices
files = [os.path.normpath(f) for f in files]
if len(files) == 1:
prefix = os.path.dirname(files[0])
else:
prefix = os.path.commonpath(files)
prefix = len(prefix)
axes = None
indices = []
for fname in files:
ax, idx = parse(fname[prefix:])
if axes is None:
axes = ax
if axesorder is not None and (
len(axesorder) != len(axes)
or any(i not in axesorder for i in range(len(axes)))
):
raise ValueError('invalid axisorder')
elif axes != ax:
raise ValueError('axes do not match within image sequence')
if axesorder is not None:
idx = [idx[i] for i in axesorder]
indices.append(idx)
if axesorder is not None:
axes = ''.join(axes[i] for i in axesorder)
indices = numpy.array(indices, dtype=numpy.intp)
startindex = numpy.min(indices, axis=0)
shape = numpy.max(indices, axis=0)
shape -= startindex
shape += 1
shape = tuple(shape.tolist())
indices -= startindex
indices = indices.tolist()
indices = [tuple(index) for index in indices]
startindex = tuple(startindex.tolist())
return axes, shape, indices, startindex
def iter_images(data):
"""Return iterator over pages in data array of normalized shape."""
for image in data:
yield image
def iter_tiles(data, tile, tiles):
"""Return iterator over tiles in data array of normalized shape."""
shape = data.shape
chunk = numpy.empty(tile + (shape[-1],), dtype=data.dtype)
if not 1 < len(tile) < 4:
raise ValueError('invalid tile shape')
if len(tile) == 2:
for page in data:
for plane in page:
for ty in range(tiles[0]):
for tx in range(tiles[1]):
c1 = min(tile[0], shape[3] - ty * tile[0])
c2 = min(tile[1], shape[4] - tx * tile[1])
chunk[c1:, c2:] = 0
chunk[:c1, :c2] = plane[
0,
ty * tile[0] : ty * tile[0] + c1,
tx * tile[1] : tx * tile[1] + c2,
]
yield chunk
else:
for page in data:
for plane in page:
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 tile[0] == 1:
# squeeze for image compressors
yield chunk[0]
else:
yield chunk
def pad_tile(tile, shape, dtype):
"""Return tile padded to tile shape."""
if tile.dtype != dtype or tile.nbytes > product(shape) * dtype.itemsize:
raise ValueError('invalid tile shape or dtype')
pad = tuple((0, i - j) for i, j in zip(shape, tile.shape))
return numpy.pad(tile, pad)
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.
"""
orient = TIFF.ORIENTATION
orientation = enumarg(orient, orientation)
if orientation == orient.TOPLEFT:
return image
if orientation == orient.TOPRIGHT:
return image[..., ::-1, :]
if orientation == orient.BOTLEFT:
return image[..., ::-1, :, :]
if orientation == orient.BOTRIGHT:
return image[..., ::-1, ::-1, :]
if orientation == orient.LEFTTOP:
return numpy.swapaxes(image, -3, -2)
if orientation == orient.RIGHTTOP:
return numpy.swapaxes(image, -3, -2)[..., ::-1, :]
if orientation == orient.RIGHTBOT:
return numpy.swapaxes(image, -3, -2)[..., ::-1, :, :]
if orientation == orient.LEFTBOT:
return numpy.swapaxes(image, -3, -2)[..., ::-1, ::-1, :]
return image
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.
Examples
--------
>>> 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=None):
"""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')
>>> squeeze_axes((1,), 'Q')
((1,), 'Q')
"""
if len(shape) != len(axes):
raise ValueError('dimensions of axes and shape do not match')
if skip is None:
skip = 'XY'
try:
shape_squeezed, axes_squeezed = zip(
*(i for i in zip(shape, axes) if i[0] > 1 or i[1] in skip)
)
except ValueError:
# not enough values to unpack, return last axis
shape_squeezed = shape[-1:]
axes_squeezed = axes[-1:]
return tuple(shape_squeezed), ''.join(axes_squeezed)
def transpose_axes(image, axes, asaxes=None):
"""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(f'unknown axis {ax}')
# add missing axes to image
if asaxes is None:
asaxes = 'CTZYX'
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=None):
"""Return axes matching new shape.
By default, 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(f'cannot reshape {shape} to {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
elif unknown:
result.append(unknown)
else:
unknown = 'Q'
result.append(unknown)
return ''.join(reversed(result[lendiff:]))
def subresolution(a, b, p=2, n=16):
"""Return level of subresolution of series or page b vs a."""
if a.axes != b.axes or a.dtype != b.dtype:
return None
level = None
for ax, i, j in zip(a.axes.lower(), a.shape, b.shape):
if ax in 'xyz':
if level is None:
for r in range(n):
d = p ** r
if d > i:
return None
if abs((i / d) - j) < 1.0:
level = r
break
else:
return None
else:
d = p ** level
if d > i:
return None
if abs((i / d) - j) >= 1.0:
return None
elif i != j:
return None
return level
def pyramidize_series(series, isreduced=False):
"""Pyramidize list of TiffPageSeries in-place.
TiffPageSeries that are a subresolution of another TiffPageSeries are
appended to the other's TiffPageSeries levels and removed from the list.
Levels are to be ordered by size using the same downsampling factor.
TiffPageSeries of subifds cannot be pyramid top levels.
"""
samplingfactors = (2, 3, 4)
i = 0
while i < len(series):
a = series[i]
p = None
j = i + 1
if isinstance(a.keyframe.index, tuple):
# subifds cannot be pyramid top levels
i += 1
continue
while j < len(series):
b = series[j]
if isreduced and not b.keyframe.is_reduced:
# pyramid levels must be reduced
j += 1
continue # not a pyramid level
if p is None:
for f in samplingfactors:
if subresolution(a.levels[-1], b, p=f) == 1:
p = f
break # not a pyramid level
else:
j += 1
continue # not a pyramid level
elif subresolution(a.levels[-1], b, p=p) != 1:
j += 1
continue
a.levels.append(b)
del series[j]
i += 1
def stack_pages(pages, out=None, maxworkers=None, **kwargs):
"""Read data from sequence of TiffPage and stack them vertically.
Additional parameters are passsed to the TiffPage.asarray function.
"""
npages = len(pages)
if npages == 0:
raise ValueError('no pages')
if npages == 1:
kwargs['maxworkers'] = maxworkers
return pages[0].asarray(out=out, **kwargs)
page0 = next(p.keyframe for p in pages if p is not None)
shape = (npages,) + page0.shape
dtype = page0.dtype
out = create_output(out, shape, dtype)
# TODO: benchmark and optimize this
if maxworkers is None or maxworkers < 1:
# auto-detect
page_maxworkers = page0.maxworkers
maxworkers = min(npages, TIFF.MAXWORKERS)
if maxworkers == 1 or page_maxworkers < 1:
maxworkers = page_maxworkers = 1
elif npages < 3:
maxworkers = 1
elif (
page_maxworkers <= 2
and page0.compression == 1
and page0.fillorder == 1
and page0.predictor == 1
):
maxworkers = 1
else:
page_maxworkers = 1
elif maxworkers == 1:
maxworkers = page_maxworkers = 1
elif npages > maxworkers or page0.maxworkers < 2:
page_maxworkers = 1
else:
page_maxworkers = maxworkers
maxworkers = 1
kwargs['maxworkers'] = page_maxworkers
filehandle = page0.parent.filehandle
haslock = filehandle.has_lock
if not haslock and maxworkers > 1 or page_maxworkers > 1:
filehandle.lock = True
filecache = FileCache(size=max(4, maxworkers), lock=filehandle.lock)
def func(page, index, out=out, filecache=filecache, kwargs=kwargs):
# read, decode, and copy page data
if page is not None:
filecache.open(page.parent.filehandle)
page.asarray(lock=filecache.lock, out=out[index], **kwargs)
filecache.close(page.parent.filehandle)
if maxworkers < 2:
for i, page in enumerate(pages):
func(page, i)
else:
page0.decode # init TiffPage.decode function
with ThreadPoolExecutor(maxworkers) as executor:
for _ in executor.map(func, pages, range(npages)):
pass
filecache.clear()
if not haslock:
filehandle.lock = False
return out
def create_output(out, shape, dtype, mode='w+', suffix=None):
"""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, 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, str) and out[:6] == 'memmap':
import tempfile
tempdir = out[7:] if len(out) > 7 else None
if suffix is None:
suffix = '.memmap'
with tempfile.NamedTemporaryFile(dir=tempdir, suffix=suffix) as fh:
return numpy.memmap(fh, shape=shape, dtype=dtype, mode=mode)
return numpy.memmap(out, shape=shape, dtype=dtype, mode=mode)
def matlabstr2py(string):
r"""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 not s[j] 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', first=True):
r"""Return string truncated at first null character.
Clean NULL terminated C strings. For Unicode strings use null='\0'.
>>> stripnull(b'string\x00\x00')
b'string'
>>> stripnull(b'string\x00string\x00\x00', first=False)
b'string\x00string'
>>> stripnull('string\x00', null='\0')
'string'
"""
if first:
i = string.find(null)
return string if i < 0 else string[:i]
null = null[0]
i = len(string)
while i:
i -= 1
if string[i] != null:
break
else:
i = -1
return string[: i + 1]
def stripascii(string):
r"""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 < string[i] < 127:
break
else:
i = -1
return string[: i + 1]
def asbool(value, true=None, false=None):
"""Return string as bool if possible, else raise TypeError.
>>> asbool(b' False ')
False
>>> asbool('ON', ['on'], ['off'])
True
"""
value = value.strip().lower()
isbytes = False
if true is None:
if isinstance(value, bytes):
if value == b'true':
return True
isbytes = True
elif value == 'true':
return True
if false is None:
if isbytes or isinstance(value, bytes):
if value == b'false':
return False
elif value == 'false':
return False
if value in true:
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 f'{size} B'
for unit in ('KiB', 'MiB', 'GiB', 'TiB', 'PiB'):
size /= 1024.0
if size < threshold:
return f'{size:.2f} {unit}'
return 'ginormous'
def identityfunc(arg, *args, **kwargs):
"""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 tuple or list.
>>> sequence(1)
(1,)
>>> sequence([1])
[1]
>>> sequence('ab')
('ab',)
"""
return value if isinstance(value, (tuple, list)) else (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 epics_datetime(sec, nsec):
"""Return datetime object from epicsTSSec and epicsTSNsec tag values."""
return datetime.datetime.fromtimestamp(sec + 631152000 + nsec / 1e9)
def excel_datetime(timestamp, epoch=None):
"""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)
"""
if epoch is None:
epoch = datetime.datetime.fromordinal(693594)
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 in ('=', sys.byteorder):
return True
keys = {'big': '>', 'little': '<'}
return keys.get(byteorder, byteorder) == keys[sys.byteorder]
def byteorder_compare(byteorder, byteorder2):
"""Return if byteorders match.
>>> byteorder_compare('<', '<')
True
>>> byteorder_compare('>', '<')
False
"""
if byteorder == byteorder2 or byteorder == '|' or byteorder2 == '|':
return True
if byteorder == '=':
byteorder = {'big': '>', 'little': '<'}[sys.byteorder]
elif byteorder2 == '=':
byteorder2 = {'big': '>', 'little': '<'}[sys.byteorder]
return byteorder == byteorder2
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('<?xml version="1.0" ?><root attr="name"><key>1</key></root>')
{'root': {'key': 1, 'attr': 'name'}}
>>> xml2dict('<level1><level2>3.5322</level2></level1>')
{'level1': {'level2': 3.5322}}
"""
from xml.etree import ElementTree as etree # delayed import
at = tx = ''
if prefix:
at, tx = prefix
def astype(value):
# return string value as int, float, bool, or unchanged
if not isinstance(value, (str, bytes)):
return value
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=None):
"""Return hexdump representation of bytes.
>>> 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 = b'...' if ellipsis is None else ellipsis.encode('cp1252')
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(br'[^\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)
result = result.decode('ascii')
return result
def isprintable(string):
r"""Return if all characters in string are printable.
>>> isprintable('abc')
True
>>> isprintable(b'\01')
False
"""
string = string.strip()
if not string:
return True
try:
return string.isprintable()
except Exception:
pass
try:
return string.decode().isprintable()
except Exception:
pass
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:
from lxml import etree # delayed import
if not isinstance(xml, bytes):
xml = xml.encode()
tree = etree.parse(io.BytesIO(xml))
xml = etree.tostring(
tree,
pretty_print=True,
xml_declaration=True,
encoding=tree.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, bytes):
if arg[:5].lower() == b'<?xml' or arg[-4:] == b'OME>':
arg = bytes2str(arg)
if isinstance(arg, bytes):
if isprintable(arg):
arg = bytes2str(arg)
arg = clean_whitespace(arg)
else:
numpy.set_printoptions(**npopt)
return hexdump(arg, width=width, height=height, modulo=1)
arg = arg.rstrip()
elif isinstance(arg, str):
if arg[:5].lower() == '<?xml' or arg[-4:] == 'OME>':
arg = arg[: 4 * width] if height == 1 else pformat_xml(arg)
arg = arg.rstrip()
elif isinstance(arg, numpy.record):
arg = arg.pprint()
else:
import pprint # delayed import
arg = pprint.pformat(arg, width=width, compact=compact)
numpy.set_printoptions(**npopt)
if height == 1:
arg = clean_whitespace(arg, compact=True)
return arg[:width]
argl = list(arg.splitlines())
if len(argl) > height:
arg = '\n'.join(argl[: height // 2] + ['...'] + argl[-height // 2 :])
return arg
def snipstr(string, width=79, snipat=None, ellipsis=None):
"""Return string cut to specified length.
>>> snipstr('abcdefghijklmnop', 8)
'abc...op'
"""
if snipat is None:
snipat = 0.5
if ellipsis is None:
if isinstance(string, bytes):
ellipsis = b'...'
else:
ellipsis = '\u2026'
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)
return '\n'.join(result)
def enumstr(enum):
"""Return short string representation of Enum instance."""
name = enum.name
if name is None:
name = str(enum)
return name
def enumarg(enum, arg):
"""Return enum member from its name or value.
>>> enumarg(TIFF.PHOTOMETRIC, 2)
<PHOTOMETRIC.RGB: 2>
>>> enumarg(TIFF.PHOTOMETRIC, 'RGB')
<PHOTOMETRIC.RGB: 2>
"""
try:
return enum(arg)
except Exception:
try:
return enum[arg.upper()]
except Exception:
raise ValueError(f'invalid argument {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 log_warning(msg, *args, **kwargs):
"""Log message with level WARNING."""
import logging
logging.getLogger(__name__).warning(msg, *args, **kwargs)
def validate_jhove(filename, jhove=None, ignore=None):
"""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 <http://jhove.sourceforge.net/tiff-hul.html>`_
"""
import subprocess
if ignore is None:
ignore = ['More than 50 IFDs']
if jhove is None:
jhove = 'jhove'
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()
for i in ignore:
if i in error:
break
else:
raise ValueError(error)
break
def tiffcomment(arg, comment=None, index=None, code=None):
"""Return or replace ImageDescription value in first page of TIFF file."""
if index is None:
index = 0
if code is None:
code = 270
mode = None if comment is None else 'r+b'
with TiffFile(arg, mode=mode) as tif:
tag = tif.pages[index].tags.get(code, None)
if tag is None:
raise ValueError(f'no {TIFF.TAGS[code]} tag found')
if comment is None:
return tag.value
tag.overwrite(tif, comment)
def tiff2fsspec(
filename,
url,
out=None,
key=None,
series=None,
level=None,
chunkmode=None,
version=None,
):
"""Write fsspec ReferenceFileSystem JSON from TIFF file."""
if out is None:
out = filename + '.json'
with TiffFile(filename) as tif:
with tif.aszarr(
key=key, series=series, level=level, chunkmode=chunkmode
) as store:
store.write_fsspec(out, url, version=version)
def lsm2bin(lsmfile, binfile=None, tile=None, 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 tile is None:
tile = (256, 256)
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)
timer = Timer()
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.get_shape(False)
axes = series.get_axes(False)
dtype = series.dtype
size = product(shape) * dtype.itemsize
verbose(timer)
# verbose(lsm, flush=True)
verbose(
'Image\n axes: {}\n shape: {}\n dtype: {}\n size: {}'.format(
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)
timer.start()
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(timer, flush=True)
def imshow(
data,
photometric=None,
planarconfig=None,
bitspersample=None,
nodata=0,
interpolation=None,
cmap=None,
vmin=None,
vmax=None,
figure=None,
title=None,
dpi=96,
subplot=None,
maxdim=None,
**kwargs,
):
"""Plot n-dimensional images using matplotlib.pyplot.
Return figure, subplot, and plot axis.
Requires pyplot already imported C{from matplotlib import pyplot}.
Parameters
----------
data : nd array
The image data.
photometric : {'MINISWHITE', 'MINISBLACK', 'RGB', or 'PALETTE'}
The color space of the image data.
planarconfig : {'CONTIG' or 'SEPARATE'}
Defines how components of each pixel are stored.
bitspersample : int
Number of bits per channel in integer RGB images.
interpolation : str
The image interpolation method used in matplotlib.imshow. By default,
'nearest' is used for image dimensions <= 512, else 'bilinear'.
cmap : str or matplotlib.colors.Colormap
The colormap maps non-RGBA scalar data to colors.
vmin, vmax : scalar
Data range covered by the colormap. By default, the complete
range of the data is covered.
figure : matplotlib.figure.Figure
Matplotlib figure to use for plotting.
title : str
Window and subplot title.
subplot : int
A matplotlib.pyplot.subplot axis.
maxdim : int
Maximum image width and length.
kwargs : dict
Additional arguments for matplotlib.pyplot.imshow.
"""
# TODO: rewrite detection of isrgb, iscontig
# TODO: use planarconfig
if photometric is None:
photometric = 'RGB'
if maxdim is None:
maxdim = 2 ** 16
isrgb = photometric in ('RGB', 'YCBCR') # 'PALETTE', 'YCBCR'
if data.dtype == 'float16':
data = data.astype('float32')
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')
if 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
):
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 interpolation is None:
threshold = 512
elif isinstance(interpolation, int):
threshold = interpolation
else:
threshold = 0
if isrgb:
data = data[..., :maxdim, :maxdim, :maxdim]
if threshold:
if data.shape[-2] > threshold or data.shape[-3] > threshold:
interpolation = 'bilinear'
else:
interpolation = 'nearest'
else:
data = data[..., :maxdim, :maxdim]
if threshold:
if data.shape[-1] > threshold or data.shape[-2] > threshold:
interpolation = 'bilinear'
else:
interpolation = 'nearest'
if photometric == 'PALETTE' and isrgb:
try:
datamax = numpy.max(data)
except ValueError:
datamax = 1
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, (int, numpy.integer)):
# 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':
if nodata:
data = data.copy()
data[data > 1e30] = 0.0
try:
datamax = numpy.max(data)
except ValueError:
datamax = 1
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)
try:
datamax = numpy.max(data)
except ValueError:
datamax = 1
if isrgb:
vmin = 0
else:
if vmax is None:
vmax = datamax
if vmin is None:
if data.dtype.kind == 'i':
dtmin = numpy.iinfo(data.dtype).min
try:
vmin = numpy.min(data)
except ValueError:
vmin = -1
if vmin == dtmin:
vmin = numpy.min(data[data > dtmin])
elif data.dtype.kind == 'f':
dtmin = numpy.finfo(data.dtype).min
try:
vmin = numpy.min(data)
except ValueError:
vmin = 0.0
if vmin == dtmin:
vmin = numpy.min(data[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,
)
if subplot is None:
subplot = 111
subplot = pyplot.subplot(subplot)
subplot.set_facecolor((0, 0, 0))
if title:
try:
title = str(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 f'{curaxdat[1][y, x]} @ {current} [{y:4}, {x:4}]'
return f'{data[y, x]} @ [{y:4}, {x:4}]'
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]),
f'Dimension {axis}',
0,
data.shape[axis] - 1,
0,
facecolor='0.5',
valfmt=f'%.0f [{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."""
from tkinter import Tk, filedialog
root = Tk()
root.withdraw()
root.update()
filenames = filedialog.askopenfilename(**kwargs)
root.destroy()
return filenames
def main():
"""Tifffile command line usage main function."""
import logging
import optparse # TODO: use argparse
logging.getLogger(__name__).setLevel(logging.INFO)
parser = optparse.OptionParser(
usage='usage: %prog [options] path',
description='Display image data in TIFF files.',
version=f'%prog {__version__}',
prog='tifffile',
)
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(
'-l',
'--level',
dest='level',
type='int',
default=-1,
help='display pyramid level of series',
)
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=10,
help='maximum number of plots',
)
opt(
'--interpol',
dest='interpol',
metavar='INTERPOL',
default=None,
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=__debug__,
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
try:
import tifffile.tifffile as m
except ImportError:
m = None
doctest.testmod(m, 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 TIFF header:', end=' ', flush=True)
timer = Timer()
try:
tif = TiffFile(path, _multifile=not settings.nomultifile)
except Exception as exc:
if settings.debug:
raise
print(f'\n\n{exc.__class__.__name__}: {exc}')
sys.exit(0)
if not settings.quiet:
print(timer)
if tif.is_ome:
settings.norgb = True
images = []
if settings.noplots > 0:
if not settings.quiet:
print('Reading image data: ', end=' ', flush=True)
def notnone(x):
return next(i for i in x if i is not None)
timer.start()
try:
if settings.page >= 0:
images = [
(tif.asarray(key=settings.page), tif[settings.page], None)
]
elif settings.series >= 0:
series = tif.series[settings.series]
if settings.level >= 0:
level = settings.level
elif series.is_pyramidal and product(series.shape) > 2 ** 32:
level = -1
for r in series.levels:
level += 1
if product(r.shape) < 2 ** 32:
break
else:
level = 0
images = [
(
tif.asarray(series=settings.series, level=level),
notnone(tif.series[settings.series]._pages),
tif.series[settings.series],
)
]
else:
for i, s in enumerate(tif.series[: settings.noplots]):
if settings.level < 0:
level = -1
for r in s.levels:
level += 1
if product(r.shape) < 2 ** 31:
break
else:
level = 0
try:
images.append(
(
tif.asarray(series=i, level=level),
notnone(s._pages),
tif.series[i],
)
)
except Exception as exc:
images.append((None, notnone(s.pages), None))
if settings.debug:
raise
print(
'\nSeries {} failed with {}: {}... '.format(
i, exc.__class__.__name__, exc
),
end='',
)
except Exception as exc:
if settings.debug:
raise
print(f'{exc.__class__.__name__}: {exc}')
if not settings.quiet:
print(timer)
if not settings.quiet:
print('Generating report:', end=' ', flush=True)
timer.start()
info = TiffFile.__str__(tif, detail=int(settings.detail))
print(timer)
print()
print(info)
print()
tif.close()
if images and settings.noplots > 0:
try:
import matplotlib
matplotlib.use('TkAgg')
from matplotlib import pyplot
except ImportError as exc:
log_warning(f'tifffile.main: {exc.__class__.__name__}: {exc}')
else:
for img, page, series in images:
if img is None:
continue
keyframe = page.keyframe
vmin, vmax = settings.vmin, settings.vmax
if keyframe.nodata:
try:
vmin = numpy.min(img[img > keyframe.nodata])
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 = f'{tif}\n{page}\n{series}'
else:
title = f'{tif}\n {page}'
photometric = 'MINISBLACK'
if keyframe.photometric not in (3,):
photometric = TIFF.PHOTOMETRIC(keyframe.photometric).name
imshow(
img,
title=title,
vmin=vmin,
vmax=vmax,
bitspersample=keyframe.bitspersample,
nodata=keyframe.nodata,
photometric=photometric,
interpolation=settings.interpol,
dpi=settings.dpi,
)
pyplot.show()
return 0
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 bytestr(s, encoding='cp1252'):
"""Return bytes from Unicode string, else pass through."""
return s.encode(encoding) if isinstance(s, str) else s
# aliases and deprecated
imsave = imwrite
TiffWriter.save = TiffWriter.write
TiffReader = TiffFile
if __name__ == '__main__':
sys.exit(main())
Reference in New Issue View Git Blame Copy Permalink