diff options
Diffstat (limited to 'lib/png.py')
| -rwxr-xr-x | lib/png.py | 3785 |
1 files changed, 0 insertions, 3785 deletions
diff --git a/lib/png.py b/lib/png.py deleted file mode 100755 index 5519407..0000000 --- a/lib/png.py +++ /dev/null @@ -1,3785 +0,0 @@ -#!/usr/bin/env python - -# $URL: http://pypng.googlecode.com/svn/trunk/code/png.py $ -# $Rev: 228 $ - -# png.py - PNG encoder/decoder in pure Python -# -# Copyright (C) 2006 Johann C. Rocholl <johann@browsershots.org> -# Portions Copyright (C) 2009 David Jones <drj@pobox.com> -# And probably portions Copyright (C) 2006 Nicko van Someren <nicko@nicko.org> -# -# Original concept by Johann C. Rocholl. -# -# LICENSE (The MIT License) -# -# Permission is hereby granted, free of charge, to any person -# obtaining a copy of this software and associated documentation files -# (the "Software"), to deal in the Software without restriction, -# including without limitation the rights to use, copy, modify, merge, -# publish, distribute, sublicense, and/or sell copies of the Software, -# and to permit persons to whom the Software is furnished to do so, -# subject to the following conditions: -# -# The above copyright notice and this permission notice shall be -# included in all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS -# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -# -# Changelog (recent first): -# 2009-03-11 David: interlaced bit depth < 8 (writing). -# 2009-03-10 David: interlaced bit depth < 8 (reading). -# 2009-03-04 David: Flat and Boxed pixel formats. -# 2009-02-26 David: Palette support (writing). -# 2009-02-23 David: Bit-depths < 8; better PNM support. -# 2006-06-17 Nicko: Reworked into a class, faster interlacing. -# 2006-06-17 Johann: Very simple prototype PNG decoder. -# 2006-06-17 Nicko: Test suite with various image generators. -# 2006-06-17 Nicko: Alpha-channel, grey-scale, 16-bit/plane support. -# 2006-06-15 Johann: Scanline iterator interface for large input files. -# 2006-06-09 Johann: Very simple prototype PNG encoder. - -# Incorporated into Bangai-O Development Tools by drj on 2009-02-11 from -# http://trac.browsershots.org/browser/trunk/pypng/lib/png.py?rev=2885 - -# Incorporated into pypng by drj on 2009-03-12 from -# //depot/prj/bangaio/master/code/png.py#67 - - -""" -Pure Python PNG Reader/Writer - -This Python module implements support for PNG images (see PNG -specification at http://www.w3.org/TR/2003/REC-PNG-20031110/ ). It reads -and writes PNG files with all allowable bit depths (1/2/4/8/16/24/32/48/64 -bits per pixel) and colour combinations: greyscale (1/2/4/8/16 bit); RGB, -RGBA, LA (greyscale with alpha) with 8/16 bits per channel; colour mapped -images (1/2/4/8 bit). Adam7 interlacing is supported for reading and -writing. A number of optional chunks can be specified (when writing) -and understood (when reading): ``tRNS``, ``bKGD``, ``gAMA``. - -For help, type ``import png; help(png)`` in your python interpreter. - -A good place to start is the :class:`Reader` and :class:`Writer` classes. - -Requires Python 2.3. Limited support is available for Python 2.2, but -not everything works. Best with Python 2.4 and higher. Installation is -trivial, but see the ``README.txt`` file (with the source distribution) -for details. - -This file can also be used as a command-line utility to convert -`Netpbm <http://netpbm.sourceforge.net/>`_ PNM files to PNG, and the reverse conversion from PNG to -PNM. The interface is similar to that of the ``pnmtopng`` program from -Netpbm. Type ``python png.py --help`` at the shell prompt -for usage and a list of options. - -A note on spelling and terminology ----------------------------------- - -Generally British English spelling is used in the documentation. So -that's "greyscale" and "colour". This not only matches the author's -native language, it's also used by the PNG specification. - -The major colour models supported by PNG (and hence by PyPNG) are: -greyscale, RGB, greyscale--alpha, RGB--alpha. These are sometimes -referred to using the abbreviations: L, RGB, LA, RGBA. In this case -each letter abbreviates a single channel: *L* is for Luminance or Luma or -Lightness which is the channel used in greyscale images; *R*, *G*, *B* stand -for Red, Green, Blue, the components of a colour image; *A* stands for -Alpha, the opacity channel (used for transparency effects, but higher -values are more opaque, so it makes sense to call it opacity). - -A note on formats ------------------ - -When getting pixel data out of this module (reading) and presenting -data to this module (writing) there are a number of ways the data could -be represented as a Python value. Generally this module uses one of -three formats called "flat row flat pixel", "boxed row flat pixel", and -"boxed row boxed pixel". Basically the concern is whether each pixel -and each row comes in its own little tuple (box), or not. - -Consider an image that is 3 pixels wide by 2 pixels high, and each pixel -has RGB components: - -Boxed row flat pixel:: - - list([R,G,B, R,G,B, R,G,B], - [R,G,B, R,G,B, R,G,B]) - -Each row appears as its own list, but the pixels are flattened so that -three values for one pixel simply follow the three values for the previous -pixel. This is the most common format used, because it provides a good -compromise between space and convenience. PyPNG regards itself as -at liberty to replace any sequence type with any sufficiently compatible -other sequence type; in practice each row is an array (from the array -module), and the outer list is sometimes an iterator rather than an -explicit list (so that streaming is possible). - -Flat row flat pixel:: - - [R,G,B, R,G,B, R,G,B, - R,G,B, R,G,B, R,G,B] - -The entire image is one single giant sequence of colour values. -Generally an array will be used (to save space), not a list. - -Boxed row boxed pixel:: - - list([ (R,G,B), (R,G,B), (R,G,B) ], - [ (R,G,B), (R,G,B), (R,G,B) ]) - -Each row appears in its own list, but each pixel also appears in its own -tuple. A serious memory burn in Python. - -In all cases the top row comes first, and for each row the pixels are -ordered from left-to-right. Within a pixel the values appear in the -order, R-G-B-A (or L-A for greyscale--alpha). - -There is a fourth format, mentioned because it is used internally, -is close to what lies inside a PNG file itself, and has some support -from the public API. This format is called packed. When packed, -each row is a sequence of bytes (integers from 0 to 255), just as -it is before PNG scanline filtering is applied. When the bit depth -is 8 this is essentially the same as boxed row flat pixel; when the -bit depth is less than 8, several pixels are packed into each byte; -when the bit depth is 16 (the only value more than 8 that is supported -by the PNG image format) each pixel value is decomposed into 2 bytes -(and `packed` is a misnomer). This format is used by the -:meth:`Writer.write_packed` method. It isn't usually a convenient -format, but may be just right if the source data for the PNG image -comes from something that uses a similar format (for example, 1-bit -BMPs, or another PNG file). - -And now, my famous members --------------------------- -""" - -# http://www.python.org/doc/2.2.3/whatsnew/node5.html -from __future__ import generators - -__version__ = "$URL: http://pypng.googlecode.com/svn/trunk/code/png.py $ $Rev: 228 $" - -from array import array -try: # See :pyver:old - import itertools -except: - pass -import math -# http://www.python.org/doc/2.4.4/lib/module-operator.html -import operator -import struct -import sys -import zlib -# http://www.python.org/doc/2.4.4/lib/module-warnings.html -import warnings - - -__all__ = ['Image', 'Reader', 'Writer', 'write_chunks', 'from_array'] - - -# The PNG signature. -# http://www.w3.org/TR/PNG/#5PNG-file-signature -_signature = struct.pack('8B', 137, 80, 78, 71, 13, 10, 26, 10) - -_adam7 = ((0, 0, 8, 8), - (4, 0, 8, 8), - (0, 4, 4, 8), - (2, 0, 4, 4), - (0, 2, 2, 4), - (1, 0, 2, 2), - (0, 1, 1, 2)) - -def group(s, n): - # See - # http://www.python.org/doc/2.6/library/functions.html#zip - return zip(*[iter(s)]*n) - -def isarray(x): - """Same as ``isinstance(x, array)`` except on Python 2.2, where it - always returns ``False``. This helps PyPNG work on Python 2.2. - """ - - try: - return isinstance(x, array) - except: - return False - -try: # see :pyver:old - array.tostring -except: - def tostring(row): - l = len(row) - return struct.pack('%dB' % l, *row) -else: - def tostring(row): - """Convert row of bytes to string. Expects `row` to be an - ``array``. - """ - return row.tostring() - -# Conditionally convert to bytes. Works on Python 2 and Python 3. -try: - bytes('', 'ascii') - def strtobytes(x): return bytes(x, 'iso8859-1') - def bytestostr(x): return str(x, 'iso8859-1') -except: - strtobytes = str - bytestostr = str - -def interleave_planes(ipixels, apixels, ipsize, apsize): - """ - Interleave (colour) planes, e.g. RGB + A = RGBA. - - Return an array of pixels consisting of the `ipsize` elements of data - from each pixel in `ipixels` followed by the `apsize` elements of data - from each pixel in `apixels`. Conventionally `ipixels` and - `apixels` are byte arrays so the sizes are bytes, but it actually - works with any arrays of the same type. The returned array is the - same type as the input arrays which should be the same type as each other. - """ - - itotal = len(ipixels) - atotal = len(apixels) - newtotal = itotal + atotal - newpsize = ipsize + apsize - # Set up the output buffer - # See http://www.python.org/doc/2.4.4/lib/module-array.html#l2h-1356 - out = array(ipixels.typecode) - # It's annoying that there is no cheap way to set the array size :-( - out.extend(ipixels) - out.extend(apixels) - # Interleave in the pixel data - for i in range(ipsize): - out[i:newtotal:newpsize] = ipixels[i:itotal:ipsize] - for i in range(apsize): - out[i+ipsize:newtotal:newpsize] = apixels[i:atotal:apsize] - return out - -def check_palette(palette): - """Check a palette argument (to the :class:`Writer` class) for validity. - Returns the palette as a list if okay; raises an exception otherwise. - """ - - # None is the default and is allowed. - if palette is None: - return None - - p = list(palette) - if not (0 < len(p) <= 256): - raise ValueError("a palette must have between 1 and 256 entries") - seen_triple = False - for i,t in enumerate(p): - if len(t) not in (3,4): - raise ValueError( - "palette entry %d: entries must be 3- or 4-tuples." % i) - if len(t) == 3: - seen_triple = True - if seen_triple and len(t) == 4: - raise ValueError( - "palette entry %d: all 4-tuples must precede all 3-tuples" % i) - for x in t: - if int(x) != x or not(0 <= x <= 255): - raise ValueError( - "palette entry %d: values must be integer: 0 <= x <= 255" % i) - return p - -class Error(Exception): - prefix = 'Error' - def __str__(self): - return self.prefix + ': ' + ' '.join(self.args) - -class FormatError(Error): - """Problem with input file format. In other words, PNG file does - not conform to the specification in some way and is invalid. - """ - - prefix = 'FormatError' - -class ChunkError(FormatError): - prefix = 'ChunkError' - - -class Writer: - """ - PNG encoder in pure Python. - """ - - def __init__(self, width=None, height=None, - size=None, - greyscale=False, - alpha=False, - bitdepth=8, - palette=None, - transparent=None, - background=None, - gamma=None, - compression=None, - interlace=False, - bytes_per_sample=None, # deprecated - planes=None, - colormap=None, - maxval=None, - chunk_limit=2**20): - """ - Create a PNG encoder object. - - Arguments: - - width, height - Image size in pixels, as two separate arguments. - size - Image size (w,h) in pixels, as single argument. - greyscale - Input data is greyscale, not RGB. - alpha - Input data has alpha channel (RGBA or LA). - bitdepth - Bit depth: from 1 to 16. - palette - Create a palette for a colour mapped image (colour type 3). - transparent - Specify a transparent colour (create a ``tRNS`` chunk). - background - Specify a default background colour (create a ``bKGD`` chunk). - gamma - Specify a gamma value (create a ``gAMA`` chunk). - compression - zlib compression level (1-9). - interlace - Create an interlaced image. - chunk_limit - Write multiple ``IDAT`` chunks to save memory. - - The image size (in pixels) can be specified either by using the - `width` and `height` arguments, or with the single `size` - argument. If `size` is used it should be a pair (*width*, - *height*). - - `greyscale` and `alpha` are booleans that specify whether - an image is greyscale (or colour), and whether it has an - alpha channel (or not). - - `bitdepth` specifies the bit depth of the source pixel values. - Each source pixel value must be an integer between 0 and - ``2**bitdepth-1``. For example, 8-bit images have values - between 0 and 255. PNG only stores images with bit depths of - 1,2,4,8, or 16. When `bitdepth` is not one of these values, - the next highest valid bit depth is selected, and an ``sBIT`` - (significant bits) chunk is generated that specifies the original - precision of the source image. In this case the supplied pixel - values will be rescaled to fit the range of the selected bit depth. - - The details of which bit depth / colour model combinations the - PNG file format supports directly, are somewhat arcane - (refer to the PNG specification for full details). Briefly: - "small" bit depths (1,2,4) are only allowed with greyscale and - colour mapped images; colour mapped images cannot have bit depth - 16. - - For colour mapped images (in other words, when the `palette` - argument is specified) the `bitdepth` argument must match one of - the valid PNG bit depths: 1, 2, 4, or 8. (It is valid to have a - PNG image with a palette and an ``sBIT`` chunk, but the meaning - is slightly different; it would be awkward to press the - `bitdepth` argument into service for this.) - - The `palette` option, when specified, causes a colour mapped image - to be created: the PNG colour type is set to 3; greyscale - must not be set; alpha must not be set; transparent must - not be set; the bit depth must be 1,2,4, or 8. When a colour - mapped image is created, the pixel values are palette indexes - and the `bitdepth` argument specifies the size of these indexes - (not the size of the colour values in the palette). - - The palette argument value should be a sequence of 3- or - 4-tuples. 3-tuples specify RGB palette entries; 4-tuples - specify RGBA palette entries. If both 4-tuples and 3-tuples - appear in the sequence then all the 4-tuples must come - before all the 3-tuples. A ``PLTE`` chunk is created; if there - are 4-tuples then a ``tRNS`` chunk is created as well. The - ``PLTE`` chunk will contain all the RGB triples in the same - sequence; the ``tRNS`` chunk will contain the alpha channel for - all the 4-tuples, in the same sequence. Palette entries - are always 8-bit. - - If specified, the `transparent` and `background` parameters must - be a tuple with three integer values for red, green, blue, or - a simple integer (or singleton tuple) for a greyscale image. - - If specified, the `gamma` parameter must be a positive number - (generally, a float). A ``gAMA`` chunk will be created. Note that - this will not change the values of the pixels as they appear in - the PNG file, they are assumed to have already been converted - appropriately for the gamma specified. - - The `compression` argument specifies the compression level - to be used by the ``zlib`` module. Higher values are likely - to compress better, but will be slower to compress. The - default for this argument is ``None``; this does not mean - no compression, rather it means that the default from the - ``zlib`` module is used (which is generally acceptable). - - If `interlace` is true then an interlaced image is created - (using PNG's so far only interace method, *Adam7*). This does not - affect how the pixels should be presented to the encoder, rather - it changes how they are arranged into the PNG file. On slow - connexions interlaced images can be partially decoded by the - browser to give a rough view of the image that is successively - refined as more image data appears. - - .. note :: - - Enabling the `interlace` option requires the entire image - to be processed in working memory. - - `chunk_limit` is used to limit the amount of memory used whilst - compressing the image. In order to avoid using large amounts of - memory, multiple ``IDAT`` chunks may be created. - """ - - # At the moment the `planes` argument is ignored; - # its purpose is to act as a dummy so that - # ``Writer(x, y, **info)`` works, where `info` is a dictionary - # returned by Reader.read and friends. - # Ditto for `colormap`. - - # A couple of helper functions come first. Best skipped if you - # are reading through. - - def isinteger(x): - try: - return int(x) == x - except: - return False - - def check_color(c, which): - """Checks that a colour argument for transparent or - background options is the right form. Also "corrects" bare - integers to 1-tuples. - """ - - if c is None: - return c - if greyscale: - try: - l = len(c) - except TypeError: - c = (c,) - if len(c) != 1: - raise ValueError("%s for greyscale must be 1-tuple" % - which) - if not isinteger(c[0]): - raise ValueError( - "%s colour for greyscale must be integer" % - which) - else: - if not (len(c) == 3 and - isinteger(c[0]) and - isinteger(c[1]) and - isinteger(c[2])): - raise ValueError( - "%s colour must be a triple of integers" % - which) - return c - - if size: - if len(size) != 2: - raise ValueError( - "size argument should be a pair (width, height)") - if width is not None and width != size[0]: - raise ValueError( - "size[0] (%r) and width (%r) should match when both are used." - % (size[0], width)) - if height is not None and height != size[1]: - raise ValueError( - "size[1] (%r) and height (%r) should match when both are used." - % (size[1], height)) - width,height = size - del size - - if width <= 0 or height <= 0: - raise ValueError("width and height must be greater than zero") - if not isinteger(width) or not isinteger(height): - raise ValueError("width and height must be integers") - # http://www.w3.org/TR/PNG/#7Integers-and-byte-order - if width > 2**32-1 or height > 2**32-1: - raise ValueError("width and height cannot exceed 2**32-1") - - if alpha and transparent is not None: - raise ValueError( - "transparent colour not allowed with alpha channel") - - if bytes_per_sample is not None: - warnings.warn('please use bitdepth instead of bytes_per_sample', - DeprecationWarning) - if bytes_per_sample not in (0.125, 0.25, 0.5, 1, 2): - raise ValueError( - "bytes per sample must be .125, .25, .5, 1, or 2") - bitdepth = int(8*bytes_per_sample) - del bytes_per_sample - if not isinteger(bitdepth) or bitdepth < 1 or 16 < bitdepth: - raise ValueError("bitdepth (%r) must be a postive integer <= 16" % - bitdepth) - - self.rescale = None - if palette: - if bitdepth not in (1,2,4,8): - raise ValueError("with palette, bitdepth must be 1, 2, 4, or 8") - if transparent is not None: - raise ValueError("transparent and palette not compatible") - if alpha: - raise ValueError("alpha and palette not compatible") - if greyscale: - raise ValueError("greyscale and palette not compatible") - else: - # No palette, check for sBIT chunk generation. - if alpha or not greyscale: - if bitdepth not in (8,16): - targetbitdepth = (8,16)[bitdepth > 8] - self.rescale = (bitdepth, targetbitdepth) - bitdepth = targetbitdepth - del targetbitdepth - else: - assert greyscale - assert not alpha - if bitdepth not in (1,2,4,8,16): - if bitdepth > 8: - targetbitdepth = 16 - elif bitdepth == 3: - targetbitdepth = 4 - else: - assert bitdepth in (5,6,7) - targetbitdepth = 8 - self.rescale = (bitdepth, targetbitdepth) - bitdepth = targetbitdepth - del targetbitdepth - - if bitdepth < 8 and (alpha or not greyscale and not palette): - raise ValueError( - "bitdepth < 8 only permitted with greyscale or palette") - if bitdepth > 8 and palette: - raise ValueError( - "bit depth must be 8 or less for images with palette") - - transparent = check_color(transparent, 'transparent') - background = check_color(background, 'background') - - # It's important that the true boolean values (greyscale, alpha, - # colormap, interlace) are converted to bool because Iverson's - # convention is relied upon later on. - self.width = width - self.height = height - self.transparent = transparent - self.background = background - self.gamma = gamma - self.greyscale = bool(greyscale) - self.alpha = bool(alpha) - self.colormap = bool(palette) - self.bitdepth = int(bitdepth) - self.compression = compression - self.chunk_limit = chunk_limit - self.interlace = bool(interlace) - self.palette = check_palette(palette) - - self.color_type = 4*self.alpha + 2*(not greyscale) + 1*self.colormap - assert self.color_type in (0,2,3,4,6) - - self.color_planes = (3,1)[self.greyscale or self.colormap] - self.planes = self.color_planes + self.alpha - # :todo: fix for bitdepth < 8 - self.psize = (self.bitdepth/8) * self.planes - - def make_palette(self): - """Create the byte sequences for a ``PLTE`` and if necessary a - ``tRNS`` chunk. Returned as a pair (*p*, *t*). *t* will be - ``None`` if no ``tRNS`` chunk is necessary. - """ - - p = array('B') - t = array('B') - - for x in self.palette: - p.extend(x[0:3]) - if len(x) > 3: - t.append(x[3]) - p = tostring(p) - t = tostring(t) - if t: - return p,t - return p,None - - def write(self, outfile, rows): - """Write a PNG image to the output file. `rows` should be - an iterable that yields each row in boxed row flat pixel format. - The rows should be the rows of the original image, so there - should be ``self.height`` rows of ``self.width * self.planes`` values. - If `interlace` is specified (when creating the instance), then - an interlaced PNG file will be written. Supply the rows in the - normal image order; the interlacing is carried out internally. - - .. note :: - - Interlacing will require the entire image to be in working memory. - """ - - if self.interlace: - fmt = 'BH'[self.bitdepth > 8] - a = array(fmt, itertools.chain(*rows)) - return self.write_array(outfile, a) - else: - nrows = self.write_passes(outfile, rows) - if nrows != self.height: - raise ValueError( - "rows supplied (%d) does not match height (%d)" % - (nrows, self.height)) - - def write_passes(self, outfile, rows, packed=False): - """ - Write a PNG image to the output file. - - Most users are expected to find the :meth:`write` or - :meth:`write_array` method more convenient. - - The rows should be given to this method in the order that - they appear in the output file. For straightlaced images, - this is the usual top to bottom ordering, but for interlaced - images the rows should have already been interlaced before - passing them to this function. - - `rows` should be an iterable that yields each row. When - `packed` is ``False`` the rows should be in boxed row flat pixel - format; when `packed` is ``True`` each row should be a packed - sequence of bytes. - - """ - - # http://www.w3.org/TR/PNG/#5PNG-file-signature - outfile.write(_signature) - - # http://www.w3.org/TR/PNG/#11IHDR - write_chunk(outfile, 'IHDR', - struct.pack("!2I5B", self.width, self.height, - self.bitdepth, self.color_type, - 0, 0, self.interlace)) - - # See :chunk:order - # http://www.w3.org/TR/PNG/#11gAMA - if self.gamma is not None: - write_chunk(outfile, 'gAMA', - struct.pack("!L", int(round(self.gamma*1e5)))) - - # See :chunk:order - # http://www.w3.org/TR/PNG/#11sBIT - if self.rescale: - write_chunk(outfile, 'sBIT', - struct.pack('%dB' % self.planes, - *[self.rescale[0]]*self.planes)) - - # :chunk:order: Without a palette (PLTE chunk), ordering is - # relatively relaxed. With one, gAMA chunk must precede PLTE - # chunk which must precede tRNS and bKGD. - # See http://www.w3.org/TR/PNG/#5ChunkOrdering - if self.palette: - p,t = self.make_palette() - write_chunk(outfile, 'PLTE', p) - if t: - # tRNS chunk is optional. Only needed if palette entries - # have alpha. - write_chunk(outfile, 'tRNS', t) - - # http://www.w3.org/TR/PNG/#11tRNS - if self.transparent is not None: - if self.greyscale: - write_chunk(outfile, 'tRNS', - struct.pack("!1H", *self.transparent)) - else: - write_chunk(outfile, 'tRNS', - struct.pack("!3H", *self.transparent)) - - # http://www.w3.org/TR/PNG/#11bKGD - if self.background is not None: - if self.greyscale: - write_chunk(outfile, 'bKGD', - struct.pack("!1H", *self.background)) - else: - write_chunk(outfile, 'bKGD', - struct.pack("!3H", *self.background)) - - # http://www.w3.org/TR/PNG/#11IDAT - if self.compression is not None: - compressor = zlib.compressobj(self.compression) - else: - compressor = zlib.compressobj() - - # Choose an extend function based on the bitdepth. The extend - # function packs/decomposes the pixel values into bytes and - # stuffs them onto the data array. - data = array('B') - if self.bitdepth == 8 or packed: - extend = data.extend - elif self.bitdepth == 16: - # Decompose into bytes - def extend(sl): - fmt = '!%dH' % len(sl) - data.extend(array('B', struct.pack(fmt, *sl))) - else: - # Pack into bytes - assert self.bitdepth < 8 - # samples per byte - spb = int(8/self.bitdepth) - def extend(sl): - a = array('B', sl) - # Adding padding bytes so we can group into a whole - # number of spb-tuples. - l = float(len(a)) - extra = math.ceil(l / float(spb))*spb - l - a.extend([0]*int(extra)) - # Pack into bytes - l = group(a, spb) - l = map(lambda e: reduce(lambda x,y: - (x << self.bitdepth) + y, e), l) - data.extend(l) - if self.rescale: - oldextend = extend - factor = \ - float(2**self.rescale[1]-1) / float(2**self.rescale[0]-1) - def extend(sl): - oldextend(map(lambda x: int(round(factor*x)), sl)) - - # Build the first row, testing mostly to see if we need to - # changed the extend function to cope with NumPy integer types - # (they cause our ordinary definition of extend to fail, so we - # wrap it). See - # http://code.google.com/p/pypng/issues/detail?id=44 - enumrows = enumerate(rows) - del rows - - # First row's filter type. - data.append(0) - # :todo: Certain exceptions in the call to ``.next()`` or the - # following try would indicate no row data supplied. - # Should catch. - i,row = enumrows.next() - try: - # If this fails... - extend(row) - except: - # ... try a version that converts the values to int first. - # Not only does this work for the (slightly broken) NumPy - # types, there are probably lots of other, unknown, "nearly" - # int types it works for. - def wrapmapint(f): - return lambda sl: f(map(int, sl)) - extend = wrapmapint(extend) - del wrapmapint - extend(row) - - for i,row in enumrows: - # Add "None" filter type. Currently, it's essential that - # this filter type be used for every scanline as we do not - # mark the first row of a reduced pass image; that means we - # could accidentally compute the wrong filtered scanline if - # we used "up", "average", or "paeth" on such a line. - data.append(0) - extend(row) - if len(data) > self.chunk_limit: - compressed = compressor.compress(tostring(data)) - if len(compressed): - # print >> sys.stderr, len(data), len(compressed) - write_chunk(outfile, 'IDAT', compressed) - # Because of our very witty definition of ``extend``, - # above, we must re-use the same ``data`` object. Hence - # we use ``del`` to empty this one, rather than create a - # fresh one (which would be my natural FP instinct). - del data[:] - if len(data): - compressed = compressor.compress(tostring(data)) - else: - compressed = '' - flushed = compressor.flush() - if len(compressed) or len(flushed): - # print >> sys.stderr, len(data), len(compressed), len(flushed) - write_chunk(outfile, 'IDAT', compressed + flushed) - # http://www.w3.org/TR/PNG/#11IEND - write_chunk(outfile, 'IEND') - return i+1 - - def write_array(self, outfile, pixels): - """ - Write an array in flat row flat pixel format as a PNG file on - the output file. See also :meth:`write` method. - """ - - if self.interlace: - self.write_passes(outfile, self.array_scanlines_interlace(pixels)) - else: - self.write_passes(outfile, self.array_scanlines(pixels)) - - def write_packed(self, outfile, rows): - """ - Write PNG file to `outfile`. The pixel data comes from `rows` - which should be in boxed row packed format. Each row should be - a sequence of packed bytes. - - Technically, this method does work for interlaced images but it - is best avoided. For interlaced images, the rows should be - presented in the order that they appear in the file. - - This method should not be used when the source image bit depth - is not one naturally supported by PNG; the bit depth should be - 1, 2, 4, 8, or 16. - """ - - if self.rescale: - raise Error("write_packed method not suitable for bit depth %d" % - self.rescale[0]) - return self.write_passes(outfile, rows, packed=True) - - def convert_pnm(self, infile, outfile): - """ - Convert a PNM file containing raw pixel data into a PNG file - with the parameters set in the writer object. Works for - (binary) PGM, PPM, and PAM formats. - """ - - if self.interlace: - pixels = array('B') - pixels.fromfile(infile, - (self.bitdepth/8) * self.color_planes * - self.width * self.height) - self.write_passes(outfile, self.array_scanlines_interlace(pixels)) - else: - self.write_passes(outfile, self.file_scanlines(infile)) - - def convert_ppm_and_pgm(self, ppmfile, pgmfile, outfile): - """ - Convert a PPM and PGM file containing raw pixel data into a - PNG outfile with the parameters set in the writer object. - """ - pixels = array('B') - pixels.fromfile(ppmfile, - (self.bitdepth/8) * self.color_planes * - self.width * self.height) - apixels = array('B') - apixels.fromfile(pgmfile, - (self.bitdepth/8) * - self.width * self.height) - pixels = interleave_planes(pixels, apixels, - (self.bitdepth/8) * self.color_planes, - (self.bitdepth/8)) - if self.interlace: - self.write_passes(outfile, self.array_scanlines_interlace(pixels)) - else: - self.write_passes(outfile, self.array_scanlines(pixels)) - - def file_scanlines(self, infile): - """ - Generates boxed rows in flat pixel format, from the input file - `infile`. It assumes that the input file is in a "Netpbm-like" - binary format, and is positioned at the beginning of the first - pixel. The number of pixels to read is taken from the image - dimensions (`width`, `height`, `planes`) and the number of bytes - per value is implied by the image `bitdepth`. - """ - - # Values per row - vpr = self.width * self.planes - row_bytes = vpr - if self.bitdepth > 8: - assert self.bitdepth == 16 - row_bytes *= 2 - fmt = '>%dH' % vpr - def line(): - return array('H', struct.unpack(fmt, infile.read(row_bytes))) - else: - def line(): - scanline = array('B', infile.read(row_bytes)) - return scanline - for y in range(self.height): - yield line() - - def array_scanlines(self, pixels): - """ - Generates boxed rows (flat pixels) from flat rows (flat pixels) - in an array. - """ - - # Values per row - vpr = self.width * self.planes - stop = 0 - for y in range(self.height): - start = stop - stop = start + vpr - yield pixels[start:stop] - - def array_scanlines_interlace(self, pixels): - """ - Generator for interlaced scanlines from an array. `pixels` is - the full source image in flat row flat pixel format. The - generator yields each scanline of the reduced passes in turn, in - boxed row flat pixel format. - """ - - # http://www.w3.org/TR/PNG/#8InterlaceMethods - # Array type. - fmt = 'BH'[self.bitdepth > 8] - # Value per row - vpr = self.width * self.planes - for xstart, ystart, xstep, ystep in _adam7: - if xstart >= self.width: - continue - # Pixels per row (of reduced image) - ppr = int(math.ceil((self.width-xstart)/float(xstep))) - # number of values in reduced image row. - row_len = ppr*self.planes - for y in range(ystart, self.height, ystep): - if xstep == 1: - offset = y * vpr - yield pixels[offset:offset+vpr] - else: - row = array(fmt) - # There's no easier way to set the length of an array - row.extend(pixels[0:row_len]) - offset = y * vpr + xstart * self.planes - end_offset = (y+1) * vpr - skip = self.planes * xstep - for i in range(self.planes): - row[i::self.planes] = \ - pixels[offset+i:end_offset:skip] - yield row - -def write_chunk(outfile, tag, data=strtobytes('')): - """ - Write a PNG chunk to the output file, including length and - checksum. - """ - - # http://www.w3.org/TR/PNG/#5Chunk-layout - outfile.write(struct.pack("!I", len(data))) - tag = strtobytes(tag) - outfile.write(tag) - outfile.write(data) - checksum = zlib.crc32(tag) - checksum = zlib.crc32(data, checksum) - checksum &= 2**32-1 - outfile.write(struct.pack("!I", checksum)) - -def write_chunks(out, chunks): - """Create a PNG file by writing out the chunks.""" - - out.write(_signature) - for chunk in chunks: - write_chunk(out, *chunk) - -def filter_scanline(type, line, fo, prev=None): - """Apply a scanline filter to a scanline. `type` specifies the - filter type (0 to 4); `line` specifies the current (unfiltered) - scanline as a sequence of bytes; `prev` specifies the previous - (unfiltered) scanline as a sequence of bytes. `fo` specifies the - filter offset; normally this is size of a pixel in bytes (the number - of bytes per sample times the number of channels), but when this is - < 1 (for bit depths < 8) then the filter offset is 1. - """ - - assert 0 <= type < 5 - - # The output array. Which, pathetically, we extend one-byte at a - # time (fortunately this is linear). - out = array('B', [type]) - - def sub(): - ai = -fo - for x in line: - if ai >= 0: - x = (x - line[ai]) & 0xff - out.append(x) - ai += 1 - def up(): - for i,x in enumerate(line): - x = (x - prev[i]) & 0xff - out.append(x) - def average(): - ai = -fo - for i,x in enumerate(line): - if ai >= 0: - x = (x - ((line[ai] + prev[i]) >> 1)) & 0xff - else: - x = (x - (prev[i] >> 1)) & 0xff - out.append(x) - ai += 1 - def paeth(): - # http://www.w3.org/TR/PNG/#9Filter-type-4-Paeth - ai = -fo # also used for ci - for i,x in enumerate(line): - a = 0 - b = prev[i] - c = 0 - - if ai >= 0: - a = line[ai] - c = prev[ai] - p = a + b - c - pa = abs(p - a) - pb = abs(p - b) - pc = abs(p - c) - if pa <= pb and pa <= pc: Pr = a - elif pb <= pc: Pr = b - else: Pr = c - - x = (x - Pr) & 0xff - out.append(x) - ai += 1 - - if not prev: - # We're on the first line. Some of the filters can be reduced - # to simpler cases which makes handling the line "off the top" - # of the image simpler. "up" becomes "none"; "paeth" becomes - # "left" (non-trivial, but true). "average" needs to be handled - # specially. - if type == 2: # "up" - return line # type = 0 - elif type == 3: - prev = [0]*len(line) - elif type == 4: # "paeth" - type = 1 - if type == 0: - out.extend(line) - elif type == 1: - sub() - elif type == 2: - up() - elif type == 3: - average() - else: # type == 4 - paeth() - return out - - -def from_array(a, mode=None, info={}): - """Create a PNG :class:`Image` object from a 2- or 3-dimensional array. - One application of this function is easy PIL-style saving: - ``png.from_array(pixels, 'L').save('foo.png')``. - - .. note : - - The use of the term *3-dimensional* is for marketing purposes - only. It doesn't actually work. Please bear with us. Meanwhile - enjoy the complimentary snacks (on request) and please use a - 2-dimensional array. - - Unless they are specified using the *info* parameter, the PNG's - height and width are taken from the array size. For a 3 dimensional - array the first axis is the height; the second axis is the width; - and the third axis is the channel number. Thus an RGB image that is - 16 pixels high and 8 wide will use an array that is 16x8x3. For 2 - dimensional arrays the first axis is the height, but the second axis - is ``width*channels``, so an RGB image that is 16 pixels high and 8 - wide will use a 2-dimensional array that is 16x24 (each row will be - 8*3==24 sample values). - - *mode* is a string that specifies the image colour format in a - PIL-style mode. It can be: - - ``'L'`` - greyscale (1 channel) - ``'LA'`` - greyscale with alpha (2 channel) - ``'RGB'`` - colour image (3 channel) - ``'RGBA'`` - colour image with alpha (4 channel) - - The mode string can also specify the bit depth (overriding how this - function normally derives the bit depth, see below). Appending - ``';16'`` to the mode will cause the PNG to be 16 bits per channel; - any decimal from 1 to 16 can be used to specify the bit depth. - - When a 2-dimensional array is used *mode* determines how many - channels the image has, and so allows the width to be derived from - the second array dimension. - - The array is expected to be a ``numpy`` array, but it can be any - suitable Python sequence. For example, a list of lists can be used: - ``png.from_array([[0, 255, 0], [255, 0, 255]], 'L')``. The exact - rules are: ``len(a)`` gives the first dimension, height; - ``len(a[0])`` gives the second dimension; ``len(a[0][0])`` gives the - third dimension, unless an exception is raised in which case a - 2-dimensional array is assumed. It's slightly more complicated than - that because an iterator of rows can be used, and it all still - works. Using an iterator allows data to be streamed efficiently. - - The bit depth of the PNG is normally taken from the array element's - datatype (but if *mode* specifies a bitdepth then that is used - instead). The array element's datatype is determined in a way which - is supposed to work both for ``numpy`` arrays and for Python - ``array.array`` objects. A 1 byte datatype will give a bit depth of - 8, a 2 byte datatype will give a bit depth of 16. If the datatype - does not have an implicit size, for example it is a plain Python - list of lists, as above, then a default of 8 is used. - - The *info* parameter is a dictionary that can be used to specify - metadata (in the same style as the arguments to the - :class:``png.Writer`` class). For this function the keys that are - useful are: - - height - overrides the height derived from the array dimensions and allows - *a* to be an iterable. - width - overrides the width derived from the array dimensions. - bitdepth - overrides the bit depth derived from the element datatype (but - must match *mode* if that also specifies a bit depth). - - Generally anything specified in the - *info* dictionary will override any implicit choices that this - function would otherwise make, but must match any explicit ones. - For example, if the *info* dictionary has a ``greyscale`` key then - this must be true when mode is ``'L'`` or ``'LA'`` and false when - mode is ``'RGB'`` or ``'RGBA'``. - """ - - # We abuse the *info* parameter by modifying it. Take a copy here. - # (Also typechecks *info* to some extent). - info = dict(info) - - # Syntax check mode string. - bitdepth = None - try: - mode = mode.split(';') - if len(mode) not in (1,2): - raise Error() - if mode[0] not in ('L', 'LA', 'RGB', 'RGBA'): - raise Error() - if len(mode) == 2: - try: - bitdepth = int(mode[1]) - except: - raise Error() - except Error: - raise Error("mode string should be 'RGB' or 'L;16' or similar.") - mode = mode[0] - - # Get bitdepth from *mode* if possible. - if bitdepth: - if info.get('bitdepth') and bitdepth != info['bitdepth']: - raise Error("mode bitdepth (%d) should match info bitdepth (%d)." % - (bitdepth, info['bitdepth'])) - info['bitdepth'] = bitdepth - - # Fill in and/or check entries in *info*. - # Dimensions. - if 'size' in info: - # Check width, height, size all match where used. - for dimension,axis in [('width', 0), ('height', 1)]: - if dimension in info: - if info[dimension] != info['size'][axis]: - raise Error( - "info[%r] shhould match info['size'][%r]." % - (dimension, axis)) - info['width'],info['height'] = info['size'] - if 'height' not in info: - try: - l = len(a) - except: - raise Error( - "len(a) does not work, supply info['height'] instead.") - info['height'] = l - # Colour format. - if 'greyscale' in info: - if bool(info['greyscale']) != ('L' in mode): - raise Error("info['greyscale'] should match mode.") - info['greyscale'] = 'L' in mode - if 'alpha' in info: - if bool(info['alpha']) != ('A' in mode): - raise Error("info['alpha'] should match mode.") - info['alpha'] = 'A' in mode - - planes = len(mode) - if 'planes' in info: - if info['planes'] != planes: - raise Error("info['planes'] should match mode.") - - # In order to work out whether we the array is 2D or 3D we need its - # first row, which requires that we take a copy of its iterator. - # We may also need the first row to derive width and bitdepth. - a,t = itertools.tee(a) - row = t.next() - del t - try: - row[0][0] - threed = True - testelement = row[0] - except: - threed = False - testelement = row - if 'width' not in info: - if threed: - width = len(row) - else: - width = len(row) // planes - info['width'] = width - - # Not implemented yet - assert not threed - - if 'bitdepth' not in info: - try: - dtype = testelement.dtype - # goto the "else:" clause. Sorry. - except: - try: - # Try a Python array.array. - bitdepth = 8 * testelement.itemsize - except: - # We can't determine it from the array element's - # datatype, use a default of 8. - bitdepth = 8 - else: - # If we got here without exception, we now assume that - # the array is a numpy array. - if dtype.kind == 'b': - bitdepth = 1 - else: - bitdepth = 8 * dtype.itemsize - info['bitdepth'] = bitdepth - - for thing in 'width height bitdepth greyscale alpha'.split(): - assert thing in info - return Image(a, info) - -# So that refugee's from PIL feel more at home. Not documented. -fromarray = from_array - -class Image: - """A PNG image. - You can create an :class:`Image` object from an array of pixels by calling - :meth:`png.from_array`. It can be saved to disk with the - :meth:`save` method.""" - def __init__(self, rows, info): - """ - .. note :: - - The constructor is not public. Please do not call it. - """ - - self.rows = rows - self.info = info - - def save(self, file): - """Save the image to *file*. If *file* looks like an open file - descriptor then it is used, otherwise it is treated as a - filename and a fresh file is opened. - - In general, you can only call this method once; after it has - been called the first time and the PNG image has been saved, the - source data will have been streamed, and cannot be streamed - again. - """ - - w = Writer(**self.info) - - try: - file.write - def close(): pass - except: - file = open(file, 'wb') - def close(): file.close() - - try: - w.write(file, self.rows) - finally: - close() - -class _readable: - """ - A simple file-like interface for strings and arrays. - """ - - def __init__(self, buf): - self.buf = buf - self.offset = 0 - - def read(self, n): - r = self.buf[self.offset:self.offset+n] - if isarray(r): - r = r.tostring() - self.offset += n - return r - - -class Reader: - """ - PNG decoder in pure Python. - """ - - def __init__(self, _guess=None, **kw): - """ - Create a PNG decoder object. - - The constructor expects exactly one keyword argument. If you - supply a positional argument instead, it will guess the input - type. You can choose among the following keyword arguments: - - filename - Name of input file (a PNG file). - file - A file-like object (object with a read() method). - bytes - ``array`` or ``string`` with PNG data. - - """ - if ((_guess is not None and len(kw) != 0) or - (_guess is None and len(kw) != 1)): - raise TypeError("Reader() takes exactly 1 argument") - - # Will be the first 8 bytes, later on. See validate_signature. - self.signature = None - self.transparent = None - # A pair of (len,type) if a chunk has been read but its data and - # checksum have not (in other words the file position is just - # past the 4 bytes that specify the chunk type). See preamble - # method for how this is used. - self.atchunk = None - - if _guess is not None: - if isarray(_guess): - kw["bytes"] = _guess - elif isinstance(_guess, str): - kw["filename"] = _guess - elif isinstance(_guess, file): - kw["file"] = _guess - - if "filename" in kw: - self.file = open(kw["filename"], "rb") - elif "file" in kw: - self.file = kw["file"] - elif "bytes" in kw: - self.file = _readable(kw["bytes"]) - else: - raise TypeError("expecting filename, file or bytes array") - - def chunk(self, seek=None): - """ - Read the next PNG chunk from the input file; returns a - (*type*,*data*) tuple. *type* is the chunk's type as a string - (all PNG chunk types are 4 characters long). *data* is the - chunk's data content, as a string. - - If the optional `seek` argument is - specified then it will keep reading chunks until it either runs - out of file or finds the type specified by the argument. Note - that in general the order of chunks in PNGs is unspecified, so - using `seek` can cause you to miss chunks. - """ - - self.validate_signature() - - while True: - # http://www.w3.org/TR/PNG/#5Chunk-layout - if not self.atchunk: - self.atchunk = self.chunklentype() - length,type = self.atchunk - self.atchunk = None - data = self.file.read(length) - if len(data) != length: - raise ChunkError('Chunk %s too short for required %i octets.' - % (type, length)) - checksum = self.file.read(4) - if len(checksum) != 4: - raise ValueError('Chunk %s too short for checksum.', tag) - if seek and type != seek: - continue - verify = zlib.crc32(strtobytes(type)) - verify = zlib.crc32(data, verify) - # Whether the output from zlib.crc32 is signed or not varies - # according to hideous implementation details, see - # http://bugs.python.org/issue1202 . - # We coerce it to be positive here (in a way which works on - # Python 2.3 and older). - verify &= 2**32 - 1 - verify = struct.pack('!I', verify) - if checksum != verify: - # print repr(checksum) - (a, ) = struct.unpack('!I', checksum) - (b, ) = struct.unpack('!I', verify) - raise ChunkError( - "Checksum error in %s chunk: 0x%08X != 0x%08X." % - (type, a, b)) - return type, data - - def chunks(self): - """Return an iterator that will yield each chunk as a - (*chunktype*, *content*) pair. - """ - - while True: - t,v = self.chunk() - yield t,v - if t == 'IEND': - break - - def undo_filter(self, filter_type, scanline, previous): - """Undo the filter for a scanline. `scanline` is a sequence of - bytes that does not include the initial filter type byte. - `previous` is decoded previous scanline (for straightlaced - images this is the previous pixel row, but for interlaced - images, it is the previous scanline in the reduced image, which - in general is not the previous pixel row in the final image). - When there is no previous scanline (the first row of a - straightlaced image, or the first row in one of the passes in an - interlaced image), then this argument should be ``None``. - - The scanline will have the effects of filtering removed, and the - result will be returned as a fresh sequence of bytes. - """ - - # :todo: Would it be better to update scanline in place? - - # Create the result byte array. It seems that the best way to - # create the array to be the right size is to copy from an - # existing sequence. *sigh* - # If we fill the result with scanline, then this allows a - # micro-optimisation in the "null" and "sub" cases. - result = array('B', scanline) - - if filter_type == 0: - # And here, we _rely_ on filling the result with scanline, - # above. - return result - - if filter_type not in (1,2,3,4): - raise FormatError('Invalid PNG Filter Type.' - ' See http://www.w3.org/TR/2003/REC-PNG-20031110/#9Filters .') - - # Filter unit. The stride from one pixel to the corresponding - # byte from the previous previous. Normally this is the pixel - # size in bytes, but when this is smaller than 1, the previous - # byte is used instead. - fu = max(1, self.psize) - - # For the first line of a pass, synthesize a dummy previous - # line. An alternative approach would be to observe that on the - # first line 'up' is the same as 'null', 'paeth' is the same - # as 'sub', with only 'average' requiring any special case. - if not previous: - previous = array('B', [0]*len(scanline)) - - def sub(): - """Undo sub filter.""" - - ai = 0 - # Loops starts at index fu. Observe that the initial part - # of the result is already filled in correctly with - # scanline. - for i in range(fu, len(result)): - x = scanline[i] - a = result[ai] - result[i] = (x + a) & 0xff - ai += 1 - - def up(): - """Undo up filter.""" - - for i in range(len(result)): - x = scanline[i] - b = previous[i] - result[i] = (x + b) & 0xff - - def average(): - """Undo average filter.""" - - ai = -fu - for i in range(len(result)): - x = scanline[i] - if ai < 0: - a = 0 - else: - a = result[ai] - b = previous[i] - result[i] = (x + ((a + b) >> 1)) & 0xff - ai += 1 - - def paeth(): - """Undo Paeth filter.""" - - # Also used for ci. - ai = -fu - for i in range(len(result)): - x = scanline[i] - if ai < 0: - a = c = 0 - else: - a = result[ai] - c = previous[ai] - b = previous[i] - p = a + b - c - pa = abs(p - a) - pb = abs(p - b) - pc = abs(p - c) - if pa <= pb and pa <= pc: - pr = a - elif pb <= pc: - pr = b - else: - pr = c - result[i] = (x + pr) & 0xff - ai += 1 - - # Call appropriate filter algorithm. Note that 0 has already - # been dealt with. - (None, sub, up, average, paeth)[filter_type]() - return result - - def deinterlace(self, raw): - """ - Read raw pixel data, undo filters, deinterlace, and flatten. - Return in flat row flat pixel format. - """ - - # print >> sys.stderr, ("Reading interlaced, w=%s, r=%s, planes=%s," + - # " bpp=%s") % (self.width, self.height, self.planes, self.bps) - # Values per row (of the target image) - vpr = self.width * self.planes - - # Make a result array, and make it big enough. Interleaving - # writes to the output array randomly (well, not quite), so the - # entire output array must be in memory. - fmt = 'BH'[self.bitdepth > 8] - a = array(fmt, [0]*vpr*self.height) - source_offset = 0 - - for xstart, ystart, xstep, ystep in _adam7: - # print >> sys.stderr, "Adam7: start=%s,%s step=%s,%s" % ( - # xstart, ystart, xstep, ystep) - if xstart >= self.width: - continue - # The previous (reconstructed) scanline. None at the - # beginning of a pass to indicate that there is no previous - # line. - recon = None - # Pixels per row (reduced pass image) - ppr = int(math.ceil((self.width-xstart)/float(xstep))) - # Row size in bytes for this pass. - row_size = int(math.ceil(self.psize * ppr)) - for y in range(ystart, self.height, ystep): - filter_type = raw[source_offset] - source_offset += 1 - scanline = raw[source_offset:source_offset+row_size] - source_offset += row_size - recon = self.undo_filter(filter_type, scanline, recon) - # Convert so that there is one element per pixel value - flat = self.serialtoflat(recon, ppr) - if xstep == 1: - assert xstart == 0 - offset = y * vpr - a[offset:offset+vpr] = flat - else: - offset = y * vpr + xstart * self.planes - end_offset = (y+1) * vpr - skip = self.planes * xstep - for i in range(self.planes): - a[offset+i:end_offset:skip] = \ - flat[i::self.planes] - return a - - def iterboxed(self, rows): - """Iterator that yields each scanline in boxed row flat pixel - format. `rows` should be an iterator that yields the bytes of - each row in turn. - """ - - def asvalues(raw): - """Convert a row of raw bytes into a flat row. Result may - or may not share with argument""" - - if self.bitdepth == 8: - return raw - if self.bitdepth == 16: - raw = tostring(raw) - return array('H', struct.unpack('!%dH' % (len(raw)//2), raw)) - assert self.bitdepth < 8 - width = self.width - # Samples per byte - spb = 8//self.bitdepth - out = array('B') - mask = 2**self.bitdepth - 1 - shifts = map(self.bitdepth.__mul__, reversed(range(spb))) - for o in raw: - out.extend(map(lambda i: mask&(o>>i), shifts)) - return out[:width] - - return itertools.imap(asvalues, rows) - - def serialtoflat(self, bytes, width=None): - """Convert serial format (byte stream) pixel data to flat row - flat pixel. - """ - - if self.bitdepth == 8: - return bytes - if self.bitdepth == 16: - bytes = tostring(bytes) - return array('H', - struct.unpack('!%dH' % (len(bytes)//2), bytes)) - assert self.bitdepth < 8 - if width is None: - width = self.width - # Samples per byte - spb = 8//self.bitdepth - out = array('B') - mask = 2**self.bitdepth - 1 - shifts = map(self.bitdepth.__mul__, reversed(range(spb))) - l = width - for o in bytes: - out.extend([(mask&(o>>s)) for s in shifts][:l]) - l -= spb - if l <= 0: - l = width - return out - - def iterstraight(self, raw): - """Iterator that undoes the effect of filtering, and yields each - row in serialised format (as a sequence of bytes). Assumes input - is straightlaced. `raw` should be an iterable that yields the - raw bytes in chunks of arbitrary size.""" - - # length of row, in bytes - rb = self.row_bytes - a = array('B') - # The previous (reconstructed) scanline. None indicates first - # line of image. - recon = None - for some in raw: - a.extend(some) - while len(a) >= rb + 1: - filter_type = a[0] - scanline = a[1:rb+1] - del a[:rb+1] - recon = self.undo_filter(filter_type, scanline, recon) - yield recon - if len(a) != 0: - # :file:format We get here with a file format error: when the - # available bytes (after decompressing) do not pack into exact - # rows. - raise FormatError( - 'Wrong size for decompressed IDAT chunk.') - assert len(a) == 0 - - def validate_signature(self): - """If signature (header) has not been read then read and - validate it; otherwise do nothing. - """ - - if self.signature: - return - self.signature = self.file.read(8) - if self.signature != _signature: - raise FormatError("PNG file has invalid signature.") - - def preamble(self): - """ - Extract the image metadata by reading the initial part of the PNG - file up to the start of the ``IDAT`` chunk. All the chunks that - precede the ``IDAT`` chunk are read and either processed for - metadata or discarded. - """ - - self.validate_signature() - - while True: - if not self.atchunk: - self.atchunk = self.chunklentype() - if self.atchunk is None: - raise FormatError( - 'This PNG file has no IDAT chunks.') - if self.atchunk[1] == 'IDAT': - return - self.process_chunk() - - def chunklentype(self): - """Reads just enough of the input to determine the next - chunk's length and type, returned as a (*length*, *type*) pair - where *type* is a string. If there are no more chunks, ``None`` - is returned. - """ - - x = self.file.read(8) - if not x: - return None - if len(x) != 8: - raise FormatError( - 'End of file whilst reading chunk length and type.') - length,type = struct.unpack('!I4s', x) - type = bytestostr(type) - if length > 2**31-1: - raise FormatError('Chunk %s is too large: %d.' % (type,length)) - return length,type - - def process_chunk(self): - """Process the next chunk and its data. This only processes the - following chunk types, all others are ignored: ``IHDR``, - ``PLTE``, ``bKGD``, ``tRNS``, ``gAMA``, ``sBIT``. - """ - - type, data = self.chunk() - if type == 'IHDR': - # http://www.w3.org/TR/PNG/#11IHDR - if len(data) != 13: - raise FormatError('IHDR chunk has incorrect length.') - (self.width, self.height, self.bitdepth, self.color_type, - self.compression, self.filter, - self.interlace) = struct.unpack("!2I5B", data) - - # Check that the header specifies only valid combinations. - if self.bitdepth not in (1,2,4,8,16): - raise Error("invalid bit depth %d" % self.bitdepth) - if self.color_type not in (0,2,3,4,6): - raise Error("invalid colour type %d" % self.color_type) - # Check indexed (palettized) images have 8 or fewer bits - # per pixel; check only indexed or greyscale images have - # fewer than 8 bits per pixel. - if ((self.color_type & 1 and self.bitdepth > 8) or - (self.bitdepth < 8 and self.color_type not in (0,3))): - raise FormatError("Illegal combination of bit depth (%d)" - " and colour type (%d)." - " See http://www.w3.org/TR/2003/REC-PNG-20031110/#table111 ." - % (self.bitdepth, self.color_type)) - if self.compression != 0: - raise Error("unknown compression method %d" % self.compression) - if self.filter != 0: - raise FormatError("Unknown filter method %d," - " see http://www.w3.org/TR/2003/REC-PNG-20031110/#9Filters ." - % self.filter) - if self.interlace not in (0,1): - raise FormatError("Unknown interlace method %d," - " see http://www.w3.org/TR/2003/REC-PNG-20031110/#8InterlaceMethods ." - % self.interlace) - - # Derived values - # http://www.w3.org/TR/PNG/#6Colour-values - colormap = bool(self.color_type & 1) - greyscale = not (self.color_type & 2) - alpha = bool(self.color_type & 4) - color_planes = (3,1)[greyscale or colormap] - planes = color_planes + alpha - - self.colormap = colormap - self.greyscale = greyscale - self.alpha = alpha - self.color_planes = color_planes - self.planes = planes - self.psize = float(self.bitdepth)/float(8) * planes - if int(self.psize) == self.psize: - self.psize = int(self.psize) - self.row_bytes = int(math.ceil(self.width * self.psize)) - # Stores PLTE chunk if present, and is used to check - # chunk ordering constraints. - self.plte = None - # Stores tRNS chunk if present, and is used to check chunk - # ordering constraints. - self.trns = None - # Stores sbit chunk if present. - self.sbit = None - elif type == 'PLTE': - # http://www.w3.org/TR/PNG/#11PLTE - if self.plte: - warnings.warn("Multiple PLTE chunks present.") - self.plte = data - if len(data) % 3 != 0: - raise FormatError( - "PLTE chunk's length should be a multiple of 3.") - if len(data) > (2**self.bitdepth)*3: - raise FormatError("PLTE chunk is too long.") - if len(data) == 0: - raise FormatError("Empty PLTE is not allowed.") - elif type == 'bKGD': - try: - if self.colormap: - if not self.plte: - warnings.warn( - "PLTE chunk is required before bKGD chunk.") - self.background = struct.unpack('B', data) - else: - self.background = struct.unpack("!%dH" % self.color_planes, - data) - except struct.error: - raise FormatError("bKGD chunk has incorrect length.") - elif type == 'tRNS': - # http://www.w3.org/TR/PNG/#11tRNS - self.trns = data - if self.colormap: - if not self.plte: - warnings.warn("PLTE chunk is required before tRNS chunk.") - else: - if len(data) > len(self.plte)/3: - # Was warning, but promoted to Error as it - # would otherwise cause pain later on. - raise FormatError("tRNS chunk is too long.") - else: - if self.alpha: - raise FormatError( - "tRNS chunk is not valid with colour type %d." % - self.color_type) - try: - self.transparent = \ - struct.unpack("!%dH" % self.color_planes, data) - except struct.error: - raise FormatError("tRNS chunk has incorrect length.") - elif type == 'gAMA': - try: - self.gamma = struct.unpack("!L", data)[0] / 100000.0 - except struct.error: - raise FormatError("gAMA chunk has incorrect length.") - elif type == 'sBIT': - self.sbit = data - if (self.colormap and len(data) != 3 or - not self.colormap and len(data) != self.planes): - raise FormatError("sBIT chunk has incorrect length.") - - def read(self): - """ - Read the PNG file and decode it. Returns (`width`, `height`, - `pixels`, `metadata`). - - May use excessive memory. - - `pixels` are returned in boxed row flat pixel format. - """ - - def iteridat(): - """Iterator that yields all the ``IDAT`` chunks as strings.""" - while True: - try: - type, data = self.chunk() - except ValueError, e: - raise ChunkError(e.args[0]) - if type == 'IEND': - # http://www.w3.org/TR/PNG/#11IEND - break - if type != 'IDAT': - continue - # type == 'IDAT' - # http://www.w3.org/TR/PNG/#11IDAT - if self.colormap and not self.plte: - warnings.warn("PLTE chunk is required before IDAT chunk") - yield data - - def iterdecomp(idat): - """Iterator that yields decompressed strings. `idat` should - be an iterator that yields the ``IDAT`` chunk data. - """ - - # Currently, with no max_length paramter to decompress, this - # routine will do one yield per IDAT chunk. So not very - # incremental. - d = zlib.decompressobj() - # Each IDAT chunk is passed to the decompressor, then any - # remaining state is decompressed out. - for data in idat: - # :todo: add a max_length argument here to limit output - # size. - yield array('B', d.decompress(data)) - yield array('B', d.flush()) - - self.preamble() - raw = iterdecomp(iteridat()) - - if self.interlace: - raw = array('B', itertools.chain(*raw)) - arraycode = 'BH'[self.bitdepth>8] - # Like :meth:`group` but producing an array.array object for - # each row. - pixels = itertools.imap(lambda *row: array(arraycode, row), - *[iter(self.deinterlace(raw))]*self.width*self.planes) - else: - pixels = self.iterboxed(self.iterstraight(raw)) - meta = dict() - for attr in 'greyscale alpha planes bitdepth interlace'.split(): - meta[attr] = getattr(self, attr) - meta['size'] = (self.width, self.height) - for attr in 'gamma transparent background'.split(): - a = getattr(self, attr, None) - if a is not None: - meta[attr] = a - return self.width, self.height, pixels, meta - - - def read_flat(self): - """ - Read a PNG file and decode it into flat row flat pixel format. - Returns (*width*, *height*, *pixels*, *metadata*). - - May use excessive memory. - - `pixels` are returned in flat row flat pixel format. - - See also the :meth:`read` method which returns pixels in the - more stream-friendly boxed row flat pixel format. - """ - - x, y, pixel, meta = self.read() - arraycode = 'BH'[meta['bitdepth']>8] - pixel = array(arraycode, itertools.chain(*pixel)) - return x, y, pixel, meta - - def palette(self, alpha='natural'): - """Returns a palette that is a sequence of 3-tuples or 4-tuples, - synthesizing it from the ``PLTE`` and ``tRNS`` chunks. These - chunks should have already been processed (for example, by - calling the :meth:`preamble` method). All the tuples are the - same size: 3-tuples if there is no ``tRNS`` chunk, 4-tuples when - there is a ``tRNS`` chunk. Assumes that the image is colour type - 3 and therefore a ``PLTE`` chunk is required. - - If the `alpha` argument is ``'force'`` then an alpha channel is - always added, forcing the result to be a sequence of 4-tuples. - """ - - if not self.plte: - raise FormatError( - "Required PLTE chunk is missing in colour type 3 image.") - plte = group(array('B', self.plte), 3) - if self.trns or alpha == 'force': - trns = array('B', self.trns or '') - trns.extend([255]*(len(plte)-len(trns))) - plte = map(operator.add, plte, group(trns, 1)) - return plte - - def asDirect(self): - """Returns the image data as a direct representation of an - ``x * y * planes`` array. This method is intended to remove the - need for callers to deal with palettes and transparency - themselves. Images with a palette (colour type 3) - are converted to RGB or RGBA; images with transparency (a - ``tRNS`` chunk) are converted to LA or RGBA as appropriate. - When returned in this format the pixel values represent the - colour value directly without needing to refer to palettes or - transparency information. - - Like the :meth:`read` method this method returns a 4-tuple: - - (*width*, *height*, *pixels*, *meta*) - - This method normally returns pixel values with the bit depth - they have in the source image, but when the source PNG has an - ``sBIT`` chunk it is inspected and can reduce the bit depth of - the result pixels; pixel values will be reduced according to - the bit depth specified in the ``sBIT`` chunk (PNG nerds should - note a single result bit depth is used for all channels; the - maximum of the ones specified in the ``sBIT`` chunk. An RGB565 - image will be rescaled to 6-bit RGB666). - - The *meta* dictionary that is returned reflects the `direct` - format and not the original source image. For example, an RGB - source image with a ``tRNS`` chunk to represent a transparent - colour, will have ``planes=3`` and ``alpha=False`` for the - source image, but the *meta* dictionary returned by this method - will have ``planes=4`` and ``alpha=True`` because an alpha - channel is synthesized and added. - - *pixels* is the pixel data in boxed row flat pixel format (just - like the :meth:`read` method). - - All the other aspects of the image data are not changed. - """ - - self.preamble() - - # Simple case, no conversion necessary. - if not self.colormap and not self.trns and not self.sbit: - return self.read() - - x,y,pixels,meta = self.read() - - if self.colormap: - meta['colormap'] = False - meta['alpha'] = bool(self.trns) - meta['bitdepth'] = 8 - meta['planes'] = 3 + bool(self.trns) - plte = self.palette() - def iterpal(pixels): - for row in pixels: - row = map(plte.__getitem__, row) - yield array('B', itertools.chain(*row)) - pixels = iterpal(pixels) - elif self.trns: - # It would be nice if there was some reasonable way of doing - # this without generating a whole load of intermediate tuples. - # But tuples does seem like the easiest way, with no other way - # clearly much simpler or much faster. (Actually, the L to LA - # conversion could perhaps go faster (all those 1-tuples!), but - # I still wonder whether the code proliferation is worth it) - it = self.transparent - maxval = 2**meta['bitdepth']-1 - planes = meta['planes'] - meta['alpha'] = True - meta['planes'] += 1 - typecode = 'BH'[meta['bitdepth']>8] - def itertrns(pixels): - for row in pixels: - # For each row we group it into pixels, then form a - # characterisation vector that says whether each pixel - # is opaque or not. Then we convert True/False to - # 0/maxval (by multiplication), and add it as the extra - # channel. - row = group(row, planes) - opa = map(it.__ne__, row) - opa = map(maxval.__mul__, opa) - opa = zip(opa) # convert to 1-tuples - yield array(typecode, - itertools.chain(*map(operator.add, row, opa))) - pixels = itertrns(pixels) - targetbitdepth = None - if self.sbit: - sbit = struct.unpack('%dB' % len(self.sbit), self.sbit) - targetbitdepth = max(sbit) - if targetbitdepth > meta['bitdepth']: - raise Error('sBIT chunk %r exceeds bitdepth %d' % - (sbit,self.bitdepth)) - if min(sbit) <= 0: - raise Error('sBIT chunk %r has a 0-entry' % sbit) - if targetbitdepth == meta['bitdepth']: - targetbitdepth = None - if targetbitdepth: - shift = meta['bitdepth'] - targetbitdepth - meta['bitdepth'] = targetbitdepth - def itershift(pixels): - for row in pixels: - yield map(shift.__rrshift__, row) - pixels = itershift(pixels) - return x,y,pixels,meta - - def asFloat(self, maxval=1.0): - """Return image pixels as per :meth:`asDirect` method, but scale - all pixel values to be floating point values between 0.0 and - *maxval*. - """ - - x,y,pixels,info = self.asDirect() - sourcemaxval = 2**info['bitdepth']-1 - del info['bitdepth'] - info['maxval'] = float(maxval) - factor = float(maxval)/float(sourcemaxval) - def iterfloat(): - for row in pixels: - yield map(factor.__mul__, row) - return x,y,iterfloat(),info - - def _as_rescale(self, get, targetbitdepth): - """Helper used by :meth:`asRGB8` and :meth:`asRGBA8`.""" - - width,height,pixels,meta = get() - maxval = 2**meta['bitdepth'] - 1 - targetmaxval = 2**targetbitdepth - 1 - factor = float(targetmaxval) / float(maxval) - meta['bitdepth'] = targetbitdepth - def iterscale(): - for row in pixels: - yield map(lambda x: int(round(x*factor)), row) - return width, height, iterscale(), meta - - def asRGB8(self): - """Return the image data as an RGB pixels with 8-bits per - sample. This is like the :meth:`asRGB` method except that - this method additionally rescales the values so that they - are all between 0 and 255 (8-bit). In the case where the - source image has a bit depth < 8 the transformation preserves - all the information; where the source image has bit depth - > 8, then rescaling to 8-bit values loses precision. No - dithering is performed. Like :meth:`asRGB`, an alpha channel - in the source image will raise an exception. - - This function returns a 4-tuple: - (*width*, *height*, *pixels*, *metadata*). - *width*, *height*, *metadata* are as per the :meth:`read` method. - - *pixels* is the pixel data in boxed row flat pixel format. - """ - - return self._as_rescale(self.asRGB, 8) - - def asRGBA8(self): - """Return the image data as RGBA pixels with 8-bits per - sample. This method is similar to :meth:`asRGB8` and - :meth:`asRGBA`: The result pixels have an alpha channel, *and* - values are rescaled to the range 0 to 255. The alpha channel is - synthesized if necessary (with a small speed penalty). - """ - - return self._as_rescale(self.asRGBA, 8) - - def asRGB(self): - """Return image as RGB pixels. RGB colour images are passed - through unchanged; greyscales are expanded into RGB - triplets (there is a small speed overhead for doing this). - - An alpha channel in the source image will raise an - exception. - - The return values are as for the :meth:`read` method - except that the *metadata* reflect the returned pixels, not the - source image. In particular, for this method - ``metadata['greyscale']`` will be ``False``. - """ - - width,height,pixels,meta = self.asDirect() - if meta['alpha']: - raise Error("will not convert image with alpha channel to RGB") - if not meta['greyscale']: - return width,height,pixels,meta - meta['greyscale'] = False - typecode = 'BH'[meta['bitdepth'] > 8] - def iterrgb(): - for row in pixels: - a = array(typecode, [0]) * 3 * width - for i in range(3): - a[i::3] = row - yield a - return width,height,iterrgb(),meta - - def asRGBA(self): - """Return image as RGBA pixels. Greyscales are expanded into - RGB triplets; an alpha channel is synthesized if necessary. - The return values are as for the :meth:`read` method - except that the *metadata* reflect the returned pixels, not the - source image. In particular, for this method - ``metadata['greyscale']`` will be ``False``, and - ``metadata['alpha']`` will be ``True``. - """ - - width,height,pixels,meta = self.asDirect() - if meta['alpha'] and not meta['greyscale']: - return width,height,pixels,meta - typecode = 'BH'[meta['bitdepth'] > 8] - maxval = 2**meta['bitdepth'] - 1 - def newarray(): - return array(typecode, [0]) * 4 * width - if meta['alpha'] and meta['greyscale']: - # LA to RGBA - def convert(): - for row in pixels: - # Create a fresh target row, then copy L channel - # into first three target channels, and A channel - # into fourth channel. - a = newarray() - for i in range(3): - a[i::4] = row[0::2] - a[3::4] = row[1::2] - yield a - elif meta['greyscale']: - # L to RGBA - def convert(): - for row in pixels: - a = newarray() - for i in range(3): - a[i::4] = row - a[3::4] = array(typecode, [maxval]) * width - yield a - else: - assert not meta['alpha'] and not meta['greyscale'] - # RGB to RGBA - def convert(): - for row in pixels: - a = newarray() - for i in range(3): - a[i::4] = row[i::3] - a[3::4] = array(typecode, [maxval]) * width - yield a - meta['alpha'] = True - meta['greyscale'] = False - return width,height,convert(),meta - - -# === Legacy Version Support === - -# :pyver:old: PyPNG works on Python versions 2.3 and 2.2, but not -# without some awkward problems. Really PyPNG works on Python 2.4 (and -# above); it works on Pythons 2.3 and 2.2 by virtue of fixing up -# problems here. It's a bit ugly (which is why it's hidden down here). -# -# Generally the strategy is one of pretending that we're running on -# Python 2.4 (or above), and patching up the library support on earlier -# versions so that it looks enough like Python 2.4. When it comes to -# Python 2.2 there is one thing we cannot patch: extended slices -# http://www.python.org/doc/2.3/whatsnew/section-slices.html. -# Instead we simply declare that features that are implemented using -# extended slices will not work on Python 2.2. -# -# In order to work on Python 2.3 we fix up a recurring annoyance involving -# the array type. In Python 2.3 an array cannot be initialised with an -# array, and it cannot be extended with a list (or other sequence). -# Both of those are repeated issues in the code. Whilst I would not -# normally tolerate this sort of behaviour, here we "shim" a replacement -# for array into place (and hope no-ones notices). You never read this. -# -# In an amusing case of warty hacks on top of warty hacks... the array -# shimming we try and do only works on Python 2.3 and above (you can't -# subclass array.array in Python 2.2). So to get it working on Python -# 2.2 we go for something much simpler and (probably) way slower. -try: - array('B').extend([]) - array('B', array('B')) -except: - # Expect to get here on Python 2.3 - try: - class _array_shim(array): - true_array = array - def __new__(cls, typecode, init=None): - super_new = super(_array_shim, cls).__new__ - it = super_new(cls, typecode) - if init is None: - return it - it.extend(init) - return it - def extend(self, extension): - super_extend = super(_array_shim, self).extend - if isinstance(extension, self.true_array): - return super_extend(extension) - if not isinstance(extension, (list, str)): - # Convert to list. Allows iterators to work. - extension = list(extension) - return super_extend(self.true_array(self.typecode, extension)) - array = _array_shim - except: - # Expect to get here on Python 2.2 - def array(typecode, init=()): - if type(init) == str: - return map(ord, init) - return list(init) - -# Further hacks to get it limping along on Python 2.2 -try: - enumerate -except: - def enumerate(seq): - i=0 - for x in seq: - yield i,x - i += 1 - -try: - reversed -except: - def reversed(l): - l = list(l) - l.reverse() - for x in l: - yield x - -try: - itertools -except: - class _dummy_itertools: - pass - itertools = _dummy_itertools() - def _itertools_imap(f, seq): - for x in seq: - yield f(x) - itertools.imap = _itertools_imap - def _itertools_chain(*iterables): - for it in iterables: - for element in it: - yield element - itertools.chain = _itertools_chain - - - -# === Internal Test Support === - -# This section comprises the tests that are internally validated (as -# opposed to tests which produce output files that are externally -# validated). Primarily they are unittests. - -# Note that it is difficult to internally validate the results of -# writing a PNG file. The only thing we can do is read it back in -# again, which merely checks consistency, not that the PNG file we -# produce is valid. - -# Run the tests from the command line: -# python -c 'import png;png.test()' - -# (For an in-memory binary file IO object) We use BytesIO where -# available, otherwise we use StringIO, but name it BytesIO. -try: - from io import BytesIO -except: - from StringIO import StringIO as BytesIO -import tempfile -# http://www.python.org/doc/2.4.4/lib/module-unittest.html -import unittest - - -def test(): - unittest.main(__name__) - -def topngbytes(name, rows, x, y, **k): - """Convenience function for creating a PNG file "in memory" as a - string. Creates a :class:`Writer` instance using the keyword arguments, - then passes `rows` to its :meth:`Writer.write` method. The resulting - PNG file is returned as a string. `name` is used to identify the file for - debugging. - """ - - import os - - print name - f = BytesIO() - w = Writer(x, y, **k) - w.write(f, rows) - if os.environ.get('PYPNG_TEST_TMP'): - w = open(name, 'wb') - w.write(f.getvalue()) - w.close() - return f.getvalue() - -def testWithIO(inp, out, f): - """Calls the function `f` with ``sys.stdin`` changed to `inp` - and ``sys.stdout`` changed to `out`. They are restored when `f` - returns. This function returns whatever `f` returns. - """ - - import os - - try: - oldin,sys.stdin = sys.stdin,inp - oldout,sys.stdout = sys.stdout,out - x = f() - finally: - sys.stdin = oldin - sys.stdout = oldout - if os.environ.get('PYPNG_TEST_TMP') and hasattr(out,'getvalue'): - name = mycallersname() - if name: - w = open(name+'.png', 'wb') - w.write(out.getvalue()) - w.close() - return x - -def mycallersname(): - """Returns the name of the caller of the caller of this function - (hence the name of the caller of the function in which - "mycallersname()" textually appears). Returns None if this cannot - be determined.""" - - # http://docs.python.org/library/inspect.html#the-interpreter-stack - import inspect - - frame = inspect.currentframe() - if not frame: - return None - frame_,filename_,lineno_,funname,linelist_,listi_ = ( - inspect.getouterframes(frame)[2]) - return funname - -def seqtobytes(s): - """Convert a sequence of integers to a *bytes* instance. Good for - plastering over Python 2 / Python 3 cracks. - """ - - return strtobytes(''.join(chr(x) for x in s)) - -class Test(unittest.TestCase): - # This member is used by the superclass. If we don't define a new - # class here then when we use self.assertRaises() and the PyPNG code - # raises an assertion then we get no proper traceback. I can't work - # out why, but defining a new class here means we get a proper - # traceback. - class failureException(Exception): - pass - - def helperLN(self, n): - mask = (1 << n) - 1 - # Use small chunk_limit so that multiple chunk writing is - # tested. Making it a test for Issue 20. - w = Writer(15, 17, greyscale=True, bitdepth=n, chunk_limit=99) - f = BytesIO() - w.write_array(f, array('B', map(mask.__and__, range(1, 256)))) - r = Reader(bytes=f.getvalue()) - x,y,pixels,meta = r.read() - self.assertEqual(x, 15) - self.assertEqual(y, 17) - self.assertEqual(list(itertools.chain(*pixels)), - map(mask.__and__, range(1,256))) - def testL8(self): - return self.helperLN(8) - def testL4(self): - return self.helperLN(4) - def testL2(self): - "Also tests asRGB8." - w = Writer(1, 4, greyscale=True, bitdepth=2) - f = BytesIO() - w.write_array(f, array('B', range(4))) - r = Reader(bytes=f.getvalue()) - x,y,pixels,meta = r.asRGB8() - self.assertEqual(x, 1) - self.assertEqual(y, 4) - for i,row in enumerate(pixels): - self.assertEqual(len(row), 3) - self.assertEqual(list(row), [0x55*i]*3) - def testP2(self): - "2-bit palette." - a = (255,255,255) - b = (200,120,120) - c = (50,99,50) - w = Writer(1, 4, bitdepth=2, palette=[a,b,c]) - f = BytesIO() - w.write_array(f, array('B', (0,1,1,2))) - r = Reader(bytes=f.getvalue()) - x,y,pixels,meta = r.asRGB8() - self.assertEqual(x, 1) - self.assertEqual(y, 4) - self.assertEqual(list(pixels), map(list, [a, b, b, c])) - def testPtrns(self): - "Test colour type 3 and tRNS chunk (and 4-bit palette)." - a = (50,99,50,50) - b = (200,120,120,80) - c = (255,255,255) - d = (200,120,120) - e = (50,99,50) - w = Writer(3, 3, bitdepth=4, palette=[a,b,c,d,e]) - f = BytesIO() - w.write_array(f, array('B', (4, 3, 2, 3, 2, 0, 2, 0, 1))) - r = Reader(bytes=f.getvalue()) - x,y,pixels,meta = r.asRGBA8() - self.assertEqual(x, 3) - self.assertEqual(y, 3) - c = c+(255,) - d = d+(255,) - e = e+(255,) - boxed = [(e,d,c),(d,c,a),(c,a,b)] - flat = map(lambda row: itertools.chain(*row), boxed) - self.assertEqual(map(list, pixels), map(list, flat)) - def testRGBtoRGBA(self): - "asRGBA8() on colour type 2 source.""" - # Test for Issue 26 - r = Reader(bytes=_pngsuite['basn2c08']) - x,y,pixels,meta = r.asRGBA8() - # Test the pixels at row 9 columns 0 and 1. - row9 = list(pixels)[9] - self.assertEqual(row9[0:8], - [0xff, 0xdf, 0xff, 0xff, 0xff, 0xde, 0xff, 0xff]) - def testLtoRGBA(self): - "asRGBA() on grey source.""" - # Test for Issue 60 - r = Reader(bytes=_pngsuite['basi0g08']) - x,y,pixels,meta = r.asRGBA() - row9 = list(list(pixels)[9]) - self.assertEqual(row9[0:8], - [222, 222, 222, 255, 221, 221, 221, 255]) - def testCtrns(self): - "Test colour type 2 and tRNS chunk." - # Test for Issue 25 - r = Reader(bytes=_pngsuite['tbrn2c08']) - x,y,pixels,meta = r.asRGBA8() - # I just happen to know that the first pixel is transparent. - # In particular it should be #7f7f7f00 - row0 = list(pixels)[0] - self.assertEqual(tuple(row0[0:4]), (0x7f, 0x7f, 0x7f, 0x00)) - def testAdam7read(self): - """Adam7 interlace reading. - Specifically, test that for images in the PngSuite that - have both an interlaced and straightlaced pair that both - images from the pair produce the same array of pixels.""" - for candidate in _pngsuite: - if not candidate.startswith('basn'): - continue - candi = candidate.replace('n', 'i') - if candi not in _pngsuite: - continue - print 'adam7 read', candidate - straight = Reader(bytes=_pngsuite[candidate]) - adam7 = Reader(bytes=_pngsuite[candi]) - # Just compare the pixels. Ignore x,y (because they're - # likely to be correct?); metadata is ignored because the - # "interlace" member differs. Lame. - straight = straight.read()[2] - adam7 = adam7.read()[2] - self.assertEqual(map(list, straight), map(list, adam7)) - def testAdam7write(self): - """Adam7 interlace writing. - For each test image in the PngSuite, write an interlaced - and a straightlaced version. Decode both, and compare results. - """ - # Not such a great test, because the only way we can check what - # we have written is to read it back again. - - for name,bytes in _pngsuite.items(): - # Only certain colour types supported for this test. - if name[3:5] not in ['n0', 'n2', 'n4', 'n6']: - continue - it = Reader(bytes=bytes) - x,y,pixels,meta = it.read() - pngi = topngbytes('adam7wn'+name+'.png', pixels, - x=x, y=y, bitdepth=it.bitdepth, - greyscale=it.greyscale, alpha=it.alpha, - transparent=it.transparent, - interlace=False) - x,y,ps,meta = Reader(bytes=pngi).read() - it = Reader(bytes=bytes) - x,y,pixels,meta = it.read() - pngs = topngbytes('adam7wi'+name+'.png', pixels, - x=x, y=y, bitdepth=it.bitdepth, - greyscale=it.greyscale, alpha=it.alpha, - transparent=it.transparent, - interlace=True) - x,y,pi,meta = Reader(bytes=pngs).read() - self.assertEqual(map(list, ps), map(list, pi)) - def testPGMin(self): - """Test that the command line tool can read PGM files.""" - def do(): - return _main(['testPGMin']) - s = BytesIO() - s.write(strtobytes('P5 2 2 3\n')) - s.write(strtobytes('\x00\x01\x02\x03')) - s.flush() - s.seek(0) - o = BytesIO() - testWithIO(s, o, do) - r = Reader(bytes=o.getvalue()) - x,y,pixels,meta = r.read() - self.assertTrue(r.greyscale) - self.assertEqual(r.bitdepth, 2) - def testPAMin(self): - """Test that the command line tool can read PAM file.""" - def do(): - return _main(['testPAMin']) - s = BytesIO() - s.write(strtobytes('P7\nWIDTH 3\nHEIGHT 1\nDEPTH 4\nMAXVAL 255\n' - 'TUPLTYPE RGB_ALPHA\nENDHDR\n')) - # The pixels in flat row flat pixel format - flat = [255,0,0,255, 0,255,0,120, 0,0,255,30] - asbytes = seqtobytes(flat) - s.write(asbytes) - s.flush() - s.seek(0) - o = BytesIO() - testWithIO(s, o, do) - r = Reader(bytes=o.getvalue()) - x,y,pixels,meta = r.read() - self.assertTrue(r.alpha) - self.assertTrue(not r.greyscale) - self.assertEqual(list(itertools.chain(*pixels)), flat) - def testLA4(self): - """Create an LA image with bitdepth 4.""" - bytes = topngbytes('la4.png', [[5, 12]], 1, 1, - greyscale=True, alpha=True, bitdepth=4) - sbit = Reader(bytes=bytes).chunk('sBIT')[1] - self.assertEqual(sbit, strtobytes('\x04\x04')) - def testPNMsbit(self): - """Test that PNM files can generates sBIT chunk.""" - def do(): - return _main(['testPNMsbit']) - s = BytesIO() - s.write(strtobytes('P6 8 1 1\n')) - for pixel in range(8): - s.write(struct.pack('<I', (0x4081*pixel)&0x10101)[:3]) - s.flush() - s.seek(0) - o = BytesIO() - testWithIO(s, o, do) - r = Reader(bytes=o.getvalue()) - sbit = r.chunk('sBIT')[1] - self.assertEqual(sbit, strtobytes('\x01\x01\x01')) - def testLtrns0(self): - """Create greyscale image with tRNS chunk.""" - return self.helperLtrns(0) - def testLtrns1(self): - """Using 1-tuple for transparent arg.""" - return self.helperLtrns((0,)) - def helperLtrns(self, transparent): - """Helper used by :meth:`testLtrns*`.""" - pixels = zip([0x00, 0x38, 0x4c, 0x54, 0x5c, 0x40, 0x38, 0x00]) - o = BytesIO() - w = Writer(8, 8, greyscale=True, bitdepth=1, transparent=transparent) - w.write_packed(o, pixels) - r = Reader(bytes=o.getvalue()) - x,y,pixels,meta = r.asDirect() - self.assertTrue(meta['alpha']) - self.assertTrue(meta['greyscale']) - self.assertEqual(meta['bitdepth'], 1) - def testWinfo(self): - """Test the dictionary returned by a `read` method can be used - as args for :meth:`Writer`. - """ - r = Reader(bytes=_pngsuite['basn2c16']) - info = r.read()[3] - w = Writer(**info) - def testPackedIter(self): - """Test iterator for row when using write_packed. - - Indicative for Issue 47. - """ - w = Writer(16, 2, greyscale=True, alpha=False, bitdepth=1) - o = BytesIO() - w.write_packed(o, [itertools.chain([0x0a], [0xaa]), - itertools.chain([0x0f], [0xff])]) - r = Reader(bytes=o.getvalue()) - x,y,pixels,info = r.asDirect() - pixels = list(pixels) - self.assertEqual(len(pixels), 2) - self.assertEqual(len(pixels[0]), 16) - def testInterlacedArray(self): - """Test that reading an interlaced PNG yields each row as an - array.""" - r = Reader(bytes=_pngsuite['basi0g08']) - list(r.read()[2])[0].tostring - def testTrnsArray(self): - """Test that reading a type 2 PNG with tRNS chunk yields each - row as an array (using asDirect).""" - r = Reader(bytes=_pngsuite['tbrn2c08']) - list(r.asDirect()[2])[0].tostring - - # Invalid file format tests. These construct various badly - # formatted PNG files, then feed them into a Reader. When - # everything is working properly, we should get FormatError - # exceptions raised. - def testEmpty(self): - """Test empty file.""" - - r = Reader(bytes='') - self.assertRaises(FormatError, r.asDirect) - def testSigOnly(self): - """Test file containing just signature bytes.""" - - r = Reader(bytes=_signature) - self.assertRaises(FormatError, r.asDirect) - def testExtraPixels(self): - """Test file that contains too many pixels.""" - - def eachchunk(chunk): - if chunk[0] != 'IDAT': - return chunk - data = zlib.decompress(chunk[1]) - data += strtobytes('\x00garbage') - data = zlib.compress(data) - chunk = (chunk[0], data) - return chunk - self.assertRaises(FormatError, self.helperFormat, eachchunk) - def testNotEnoughPixels(self): - def eachchunk(chunk): - if chunk[0] != 'IDAT': - return chunk - # Remove last byte. - data = zlib.decompress(chunk[1]) - data = data[:-1] - data = zlib.compress(data) - return (chunk[0], data) - self.assertRaises(FormatError, self.helperFormat, eachchunk) - def helperFormat(self, f): - r = Reader(bytes=_pngsuite['basn0g01']) - o = BytesIO() - def newchunks(): - for chunk in r.chunks(): - yield f(chunk) - write_chunks(o, newchunks()) - r = Reader(bytes=o.getvalue()) - return list(r.asDirect()[2]) - def testBadFilter(self): - def eachchunk(chunk): - if chunk[0] != 'IDAT': - return chunk - data = zlib.decompress(chunk[1]) - # Corrupt the first filter byte - data = strtobytes('\x99') + data[1:] - data = zlib.compress(data) - return (chunk[0], data) - self.assertRaises(FormatError, self.helperFormat, eachchunk) - def testFlat(self): - """Test read_flat.""" - import hashlib - - r = Reader(bytes=_pngsuite['basn0g02']) - x,y,pixel,meta = r.read_flat() - d = hashlib.md5(seqtobytes(pixel)).digest() - self.assertEqual(_enhex(d), '255cd971ab8cd9e7275ff906e5041aa0') - def testfromarray(self): - img = from_array([[0, 0x33, 0x66], [0xff, 0xcc, 0x99]], 'L') - img.save('testfromarray.png') - def testfromarrayL16(self): - img = from_array(group(range(2**16), 256), 'L;16') - img.save('testL16.png') - def testfromarrayRGB(self): - img = from_array([[0,0,0, 0,0,1, 0,1,0, 0,1,1], - [1,0,0, 1,0,1, 1,1,0, 1,1,1]], 'RGB;1') - o = BytesIO() - img.save(o) - def testfromarrayIter(self): - import itertools - - i = itertools.islice(itertools.count(10), 20) - i = itertools.imap(lambda x: [x, x, x], i) - img = from_array(i, 'RGB;5', dict(height=20)) - f = open('testiter.png', 'wb') - img.save(f) - f.close() - - # numpy dependent tests. These are skipped (with a message to - # sys.stderr) if numpy cannot be imported. - def testNumpyuint16(self): - """numpy uint16.""" - - try: - import numpy - except ImportError: - print >>sys.stderr, "skipping numpy test" - return - - rows = [map(numpy.uint16, range(0,0x10000,0x5555))] - b = topngbytes('numpyuint16.png', rows, 4, 1, - greyscale=True, alpha=False, bitdepth=16) - def testNumpyuint8(self): - """numpy uint8.""" - - try: - import numpy - except ImportError: - print >>sys.stderr, "skipping numpy test" - return - - rows = [map(numpy.uint8, range(0,0x100,0x55))] - b = topngbytes('numpyuint8.png', rows, 4, 1, - greyscale=True, alpha=False, bitdepth=8) - def testNumpybool(self): - """numpy bool.""" - - try: - import numpy - except ImportError: - print >>sys.stderr, "skipping numpy test" - return - - rows = [map(numpy.bool, [0,1])] - b = topngbytes('numpybool.png', rows, 2, 1, - greyscale=True, alpha=False, bitdepth=1) - def testNumpyarray(self): - """numpy array.""" - try: - import numpy - except ImportError: - print >>sys.stderr, "skipping numpy test" - return - - pixels = numpy.array([[0,0x5555],[0x5555,0xaaaa]], numpy.uint16) - img = from_array(pixels, 'L') - img.save('testnumpyL16.png') - -# === Command Line Support === - -def _dehex(s): - """Liberally convert from hex string to binary string.""" - import re - import binascii - - # Remove all non-hexadecimal digits - s = re.sub(r'[^a-fA-F\d]', '', s) - # binscii.unhexlify works in Python 2 and Python 3 (unlike - # thing.decode('hex')). - return binascii.unhexlify(strtobytes(s)) -def _enhex(s): - """Convert from binary string (bytes) to hex string (str).""" - - import binascii - - return bytestostr(binascii.hexlify(s)) - -# Copies of PngSuite test files taken -# from http://www.schaik.com/pngsuite/pngsuite_bas_png.html -# on 2009-02-19 by drj and converted to hex. -# Some of these are not actually in PngSuite (but maybe they should -# be?), they use the same naming scheme, but start with a capital -# letter. -_pngsuite = { - 'basi0g01': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002001000000012c0677 -cf0000000467414d41000186a031e8965f0000009049444154789c2d8d310ec2 -300c45dfc682c415187a00a42e197ab81e83b127e00c5639001363a580d8582c -65c910357c4b78b0bfbfdf4f70168c19e7acb970a3f2d1ded9695ce5bf5963df -d92aaf4c9fd927ea449e6487df5b9c36e799b91bdf082b4d4bd4014fe4014b01 -ab7a17aee694d28d328a2d63837a70451e1648702d9a9ff4a11d2f7a51aa21e5 -a18c7ffd0094e3511d661822f20000000049454e44ae426082 -"""), - 'basi0g02': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002002000000016ba60d -1f0000000467414d41000186a031e8965f0000005149444154789c635062e860 -00e17286bb609c93c370ec189494960631366e4467b3ae675dcf10f521ea0303 -90c1ca006444e11643482064114a4852c710baea3f18c31918020c30410403a6 -0ac1a09239009c52804d85b6d97d0000000049454e44ae426082 -"""), - 'basi0g04': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200400000001e4e6f8 -bf0000000467414d41000186a031e8965f000000ae49444154789c658e5111c2 -301044171c141c141c041c843a287510ea20d441c041c141c141c04191102454 -03994998cecd7edcecedbb9bdbc3b2c2b6457545fbc4bac1be437347f7c66a77 -3c23d60db15e88f5c5627338a5416c2e691a9b475a89cd27eda12895ae8dfdab -43d61e590764f5c83a226b40d669bec307f93247701687723abf31ff83a2284b -a5b4ae6b63ac6520ad730ca4ed7b06d20e030369bd6720ed383290360406d24e -13811f2781eba9d34d07160000000049454e44ae426082 -"""), - 'basi0g08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200800000001211615 -be0000000467414d41000186a031e8965f000000b549444154789cb5905d0ac2 -3010849dbac81c42c47bf843cf253e8878b0aa17110f214bdca6be240f5d21a5 -94ced3e49bcd322c1624115515154998aa424822a82a5624a1aa8a8b24c58f99 -999908130989a04a00d76c2c09e76cf21adcb209393a6553577da17140a2c59e -70ecbfa388dff1f03b82fb82bd07f05f7cb13f80bb07ad2fd60c011c3c588eef -f1f4e03bbec7ce832dca927aea005e431b625796345307b019c845e6bfc3bb98 -769d84f9efb02ea6c00f9bb9ff45e81f9f280000000049454e44ae426082 -"""), - 'basi0g16': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002010000000017186c9 -fd0000000467414d41000186a031e8965f000000e249444154789cb5913b0ec2 -301044c7490aa8f85d81c3e4301c8f53a4ca0da8902c8144b3920b4043111282 -23bc4956681a6bf5fc3c5a3ba0448912d91a4de2c38dd8e380231eede4c4f7a1 -4677700bec7bd9b1d344689315a3418d1a6efbe5b8305ba01f8ff4808c063e26 -c60d5c81edcf6c58c535e252839e93801b15c0a70d810ae0d306b205dc32b187 -272b64057e4720ff0502154034831520154034c3df81400510cdf0015c86e5cc -5c79c639fddba9dcb5456b51d7980eb52d8e7d7fa620a75120d6064641a05120 -b606771a05626b401a05f1f589827cf0fe44c1f0bae0055698ee8914fffffe00 -00000049454e44ae426082 -"""), - 'basi2c08': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002008020000018b1fdd -350000000467414d41000186a031e8965f000000f249444154789cd59341aa04 -210c44abc07b78133d59d37333bd89d76868b566d10cf4675af8596431a11662 -7c5688919280e312257dd6a0a4cf1a01008ee312a5f3c69c37e6fcc3f47e6776 -a07f8bdaf5b40feed2d33e025e2ff4fe2d4a63e1a16d91180b736d8bc45854c5 -6d951863f4a7e0b66dcf09a900f3ffa2948d4091e53ca86c048a64390f662b50 -4a999660ced906182b9a01a8be00a56404a6ede182b1223b4025e32c4de34304 -63457680c93aada6c99b73865aab2fc094920d901a203f5ddfe1970d28456783 -26cffbafeffcd30654f46d119be4793f827387fc0d189d5bc4d69a3c23d45a7f -db803146578337df4d0a3121fc3d330000000049454e44ae426082 -"""), - 'basi2c16': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000201002000001db8f01 -760000000467414d41000186a031e8965f0000020a49444154789cd5962173e3 -3010853fcf1838cc61a1818185a53e56787fa13fa130852e3b5878b4b0b03081 -b97f7030070b53e6b057a0a8912bbb9163b9f109ececbc59bd7dcf2b45492409 -d66f00eb1dd83cb5497d65456aeb8e1040913b3b2c04504c936dd5a9c7e2c6eb -b1b8f17a58e8d043da56f06f0f9f62e5217b6ba3a1b76f6c9e99e8696a2a72e2 -c4fb1e4d452e92ec9652b807486d12b6669be00db38d9114b0c1961e375461a5 -5f76682a85c367ad6f682ff53a9c2a353191764b78bb07d8ddc3c97c1950f391 -6745c7b9852c73c2f212605a466a502705c8338069c8b9e84efab941eb393a97 -d4c9fd63148314209f1c1d3434e847ead6380de291d6f26a25c1ebb5047f5f24 -d85c49f0f22cc1d34282c72709cab90477bf25b89d49f0f351822297e0ea9704 -f34c82bc94002448ede51866e5656aef5d7c6a385cb4d80e6a538ceba04e6df2 -480e9aa84ddedb413bb5c97b3838456df2d4fec2c7a706983e7474d085fae820 -a841776a83073838973ac0413fea2f1dc4a06e71108fda73109bdae48954ad60 -bf867aac3ce44c7c1589a711cf8a81df9b219679d96d1cec3d8bbbeaa2012626 -df8c7802eda201b2d2e0239b409868171fc104ba8b76f10b4da09f6817ffc609 -c413ede267fd1fbab46880c90f80eccf0013185eb48b47ba03df2bdaadef3181 -cb8976f18e13188768170f98c0f844bb78cb04c62ddac59d09fc3fa25dfc1da4 -14deb3df1344f70000000049454e44ae426082 -"""), - 'basi3p08': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020080300000133a3ba -500000000467414d41000186a031e8965f00000300504c5445224400f5ffed77 -ff77cbffff110a003a77002222ffff11ff110000222200ffac5566ff66ff6666 -ff01ff221200dcffffccff994444ff005555220000cbcbff44440055ff55cbcb -00331a00ffecdcedffffe4ffcbffdcdc44ff446666ff330000442200ededff66 -6600ffa444ffffaaeded0000cbcbfefffffdfffeffff0133ff33552a000101ff -8888ff00aaaa010100440000888800ffe4cbba5b0022ff22663200ffff99aaaa -ff550000aaaa00cb630011ff11d4ffaa773a00ff4444dc6b0066000001ff0188 -4200ecffdc6bdc00ffdcba00333300ed00ed7300ffff88994a0011ffff770000 -ff8301ffbabafe7b00fffeff00cb00ff999922ffff880000ffff77008888ffdc -ff1a33000000aa33ffff009900990000000001326600ffbaff44ffffffaaff00 -770000fefeaa00004a9900ffff66ff22220000998bff1155ffffff0101ff88ff -005500001111fffffefffdfea4ff4466ffffff66ff003300ffff55ff77770000 -88ff44ff00110077ffff006666ffffed000100fff5ed1111ffffff44ff22ffff -eded11110088ffff00007793ff2200dcdc3333fffe00febabaff99ffff333300 -63cb00baba00acff55ffffdcffff337bfe00ed00ed5555ffaaffffdcdcff5555 -00000066dcdc00dc00dc83ff017777fffefeffffffcbff5555777700fefe00cb -00cb0000fe010200010000122200ffff220044449bff33ffd4aa0000559999ff -999900ba00ba2a5500ffcbcbb4ff66ff9b33ffffbaaa00aa42880053aa00ffaa -aa0000ed00babaffff1100fe00000044009999990099ffcc99ba000088008800 -dc00ff93220000dcfefffeaa5300770077020100cb0000000033ffedff00ba00 -ff3333edffedffc488bcff7700aa00660066002222dc0000ffcbffdcffdcff8b -110000cb00010155005500880000002201ffffcbffcbed0000ff88884400445b -ba00ffbc77ff99ff006600baffba00777773ed00fe00003300330000baff77ff -004400aaffaafffefe000011220022c4ff8800eded99ff99ff55ff002200ffb4 -661100110a1100ff1111dcffbabaffff88ff88010001ff33ffb98ed362000002 -a249444154789c65d0695c0b001806f03711a9904a94d24dac63292949e5a810 -d244588a14ca5161d1a1323973252242d62157d12ae498c8124d25ca3a11398a -16e55a3cdffab0ffe7f77d7fcff3528645349b584c3187824d9d19d4ec2e3523 -9eb0ae975cf8de02f2486d502191841b42967a1ad49e5ddc4265f69a899e26b5 -e9e468181baae3a71a41b95669da8df2ea3594c1b31046d7b17bfb86592e4cbe -d89b23e8db0af6304d756e60a8f4ad378bdc2552ae5948df1d35b52143141533 -33bbbbababebeb3b3bc9c9c9c6c6c0c0d7b7b535323225a5aa8a02024a4bedec -0a0a2a2bcdcd7d7cf2f3a9a9c9cdcdd8b8adcdd5b5ababa828298982824a4ab2 -b21212acadbdbc1414e2e24859b9a72730302f4f49292c4c57373c9c0a0b7372 -8c8c1c1c3a3a92936d6dfdfd293e3e26262a4a4eaea2424b4b5fbfbc9c323278 -3c0b0ba1303abaae8ecdeeed950d6669a9a7a7a141d4de9e9d5d5cdcd2229b94 -c572716132f97cb1d8db9bc3110864a39795d9db6b6a26267a7a9a98d4d6a6a7 -cb76090ef6f030354d4d75766e686030545464cb393a1a1ac6c68686eae8f8f9 -a9aa4644c8b66d6e1689dcdd2512a994cb35330b0991ad9f9b6b659596a6addd -d8282fafae5e5323fb8f41d01f76c22fd8061be01bfc041a0323e1002c81cd30 -0b9ec027a0c930014ec035580fc3e112bc069a0b53e11c0c8095f00176c163a0 -e5301baec06a580677600ddc05ba0f13e120bc81a770133ec355a017300d4ec2 -0c7800bbe1219c02fa08f3e13c1c85dbb00a2ec05ea0dff00a6ec15a98027360 -070c047a06d7e1085c84f1b014f6c03fa0b33018b6c0211801ebe018fc00da0a -6f61113c877eb01d4ec317a085700f26c130f80efbe132bc039a0733e106fc81 -f7f017f6c10aa0d1300a0ec374780943e1382c06fa0a9b60238c83473016cec0 -02f80f73fefe1072afc1e50000000049454e44ae426082 -"""), - 'basi6a08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200806000001047d4a -620000000467414d41000186a031e8965f0000012049444154789cc595414ec3 -3010459fa541b8bbb26641b8069b861e8b4d12c1c112c1452a710a2a65d840d5 -949041fc481ec98ae27c7f3f8d27e3e4648047600fec0d1f390fbbe2633a31e2 -9389e4e4ea7bfdbf3d9a6b800ab89f1bd6b553cfcbb0679e960563d72e0a9293 -b7337b9f988cc67f5f0e186d20e808042f1c97054e1309da40d02d7e27f92e03 -6cbfc64df0fc3117a6210a1b6ad1a00df21c1abcf2a01944c7101b0cb568a001 -909c9cf9e399cf3d8d9d4660a875405d9a60d000b05e2de55e25780b7a5268e0 -622118e2399aab063a815808462f1ab86890fc2e03e48bb109ded7d26ce4bf59 -0db91bac0050747fec5015ce80da0e5700281be533f0ce6d5900b59bcb00ea6d -200314cf801faab200ea752803a8d7a90c503a039f824a53f4694e7342000000 -0049454e44ae426082 -"""), - 'basn0g01': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002001000000005b0147 -590000000467414d41000186a031e8965f0000005b49444154789c2dccb10903 -300c05d1ebd204b24a200b7a346f90153c82c18d0a61450751f1e08a2faaead2 -a4846ccea9255306e753345712e211b221bf4b263d1b427325255e8bdab29e6f -6aca30692e9d29616ee96f3065f0bf1f1087492fd02f14c90000000049454e44 -ae426082 -"""), - 'basn0g02': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002002000000001ca13d -890000000467414d41000186a031e8965f0000001f49444154789c6360085df5 -1f8cf1308850c20053868f0133091f6390b90700bd497f818b0989a900000000 -49454e44ae426082 -"""), - # A version of basn0g04 dithered down to 3 bits. - 'Basn0g03': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020040000000093e1c8 -2900000001734249540371d88211000000fd49444154789c6d90d18906210c84 -c356f22356b2889588604301b112112b11d94a96bb495cf7fe87f32d996f2689 -44741cc658e39c0b118f883e1f63cc89dafbc04c0f619d7d898396c54b875517 -83f3a2e7ac09a2074430e7f497f00f1138a5444f82839c5206b1f51053cca968 -63258821e7f2b5438aac16fbecc052b646e709de45cf18996b29648508728612 -952ca606a73566d44612b876845e9a347084ea4868d2907ff06be4436c4b41a3 -a3e1774285614c5affb40dbd931a526619d9fa18e4c2be420858de1df0e69893 -a0e3e5523461be448561001042b7d4a15309ce2c57aef2ba89d1c13794a109d7 -b5880aa27744fc5c4aecb5e7bcef5fe528ec6293a930690000000049454e44ae -426082 -"""), - 'basn0g04': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020040000000093e1c8 -290000000467414d41000186a031e8965f0000004849444154789c6360601014 -545232367671090d4d4b2b2f6720430095dbd1418e002a77e64c720450b9ab56 -912380caddbd9b1c0154ee9933e408a072efde25470095fbee1d1902001f14ee -01eaff41fa0000000049454e44ae426082 -"""), - 'basn0g08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200800000000561125 -280000000467414d41000186a031e8965f0000004149444154789c6364602400 -1408c8b30c05058c0f0829f8f71f3f6079301c1430ca11906764a2795c0c0605 -8c8ff0cafeffcff887e67131181430cae0956564040050e5fe7135e2d8590000 -000049454e44ae426082 -"""), - 'basn0g16': _dehex(""" -89504e470d0a1a0a0000000d49484452000000200000002010000000000681f9 -6b0000000467414d41000186a031e8965f0000005e49444154789cd5d2310ac0 -300c4351395bef7fc6dca093c0287b32d52a04a3d98f3f3880a7b857131363a0 -3a82601d089900dd82f640ca04e816dc06422640b7a03d903201ba05b7819009 -d02d680fa44c603f6f07ec4ff41938cf7f0016d84bd85fae2b9fd70000000049 -454e44ae426082 -"""), - 'basn2c08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200802000000fc18ed -a30000000467414d41000186a031e8965f0000004849444154789cedd5c10900 -300c024085ec91fdb772133b442bf4a1f8cee12bb40d043b800a14f81ca0ede4 -7d4c784081020f4a871fc284071428f0a0743823a94081bb7077a3c00182b1f9 -5e0f40cf4b0000000049454e44ae426082 -"""), - 'basn2c16': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000201002000000ac8831 -e00000000467414d41000186a031e8965f000000e549444154789cd596c10a83 -301044a7e0417fcb7eb7fdadf6961e06039286266693cc7a188645e43dd6a08f -1042003e2fe09aef6472737e183d27335fcee2f35a77b702ebce742870a23397 -f3edf2705dd10160f3b2815fe8ecf2027974a6b0c03f74a6e4192843e75c6c03 -35e8ec3202f5e84c0181bbe8cca967a00d9df3491bb040671f2e6087ce1c2860 -8d1e05f8c7ee0f1d00b667e70df44467ef26d01fbd9bc028f42860f71d188bce -fb8d3630039dbd59601e7ab3c06cf428507f0634d039afdc80123a7bb1801e7a -b1802a7a14c89f016d74ce331bf080ce9e08f8414f04bca133bfe642fe5e07bb -c4ec0000000049454e44ae426082 -"""), - 'basn6a08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200806000000737a7a -f40000000467414d41000186a031e8965f0000006f49444154789cedd6310a80 -300c46e12764684fa1f73f55048f21c4ddc545781d52e85028fc1f4d28d98a01 -305e7b7e9cffba33831d75054703ca06a8f90d58a0074e351e227d805c8254e3 -1bb0420f5cdc2e0079208892ffe2a00136a07b4007943c1004d900195036407f -011bf00052201a9c160fb84c0000000049454e44ae426082 -"""), - 'cs3n3p08': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020080300000044a48a -c60000000467414d41000186a031e8965f0000000373424954030303a392a042 -00000054504c544592ff0000ff9200ffff00ff0000dbff00ff6dffb600006dff -b6ff00ff9200dbff000049ffff2400ff000024ff0049ff0000ffdb00ff4900ff -b6ffff0000ff2400b6ffffdb000092ffff6d000024ffff49006dff00df702b17 -0000004b49444154789c85cac70182000000b1b3625754b0edbfa72324ef7486 -184ed0177a437b680bcdd0031c0ed00ea21f74852ed00a1c9ed0086da0057487 -6ed0121cd6d004bda0013a421ff803224033e177f4ae260000000049454e44ae -426082 -"""), - 's09n3p02': _dehex(""" -89504e470d0a1a0a0000000d49484452000000090000000902030000009dffee -830000000467414d41000186a031e8965f000000037342495404040477f8b5a3 -0000000c504c544500ff000077ffff00ffff7700ff5600640000001f49444154 -789c63600002fbff0c0c56ab19182ca381581a4283f82071200000696505c36a -437f230000000049454e44ae426082 -"""), - 'tbgn3p08': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020080300000044a48a -c60000000467414d41000186a031e8965f00000207504c54457f7f7fafafafab -abab110000222200737300999999510d00444400959500959595e6e600919191 -8d8d8d620d00898989666600b7b700911600000000730d007373736f6f6faaaa -006b6b6b676767c41a00cccc0000f30000ef00d51e0055555567670000dd0051 -515100d1004d4d4de61e0038380000b700160d0d00ab00560d00090900009500 -009100008d003333332f2f2f2f2b2f2b2b000077007c7c001a05002b27000073 -002b2b2b006f00bb1600272727780d002323230055004d4d00cc1e00004d00cc -1a000d00003c09006f6f00002f003811271111110d0d0d55554d090909001100 -4d0900050505000d00e2e200000900000500626200a6a6a6a2a2a29e9e9e8484 -00fb00fbd5d500801100800d00ea00ea555500a6a600e600e6f7f700e200e233 -0500888888d900d9848484c01a007777003c3c05c8c8008080804409007c7c7c -bb00bbaa00aaa600a61e09056262629e009e9a009af322005e5e5e05050000ee -005a5a5adddd00a616008d008d00e20016050027270088110078780000c40078 -00787300736f006f44444400aa00c81e004040406600663c3c3c090000550055 -1a1a00343434d91e000084004d004d007c004500453c3c00ea1e00222222113c -113300331e1e1efb22001a1a1a004400afaf00270027003c001616161e001e0d -160d2f2f00808000001e00d1d1001100110d000db7b7b7090009050005b3b3b3 -6d34c4230000000174524e530040e6d86600000001624b474402660b7c640000 -01f249444154789c6360c0048c8c58049100575f215ee92e6161ef109cd2a15e -4b9645ce5d2c8f433aa4c24f3cbd4c98833b2314ab74a186f094b9c2c27571d2 -6a2a58e4253c5cda8559057a392363854db4d9d0641973660b0b0bb76bb16656 -06970997256877a07a95c75a1804b2fbcd128c80b482a0b0300f8a824276a9a8 -ec6e61612b3e57ee06fbf0009619d5fac846ac5c60ed20e754921625a2daadc6 -1967e29e97d2239c8aec7e61fdeca9cecebef54eb36c848517164514af16169e -866444b2b0b7b55534c815cc2ec22d89cd1353800a8473100a4485852d924a6a -412adc74e7ad1016ceed043267238c901716f633a812022998a4072267c4af02 -92127005c0f811b62830054935ce017b38bf0948cc5c09955f030a24617d9d46 -63371fd940b0827931cbfdf4956076ac018b592f72d45594a9b1f307f3261b1a -084bc2ad50018b1900719ba6ba4ca325d0427d3f6161449486f981144cf3100e -2a5f2a1ce8683e4ddf1b64275240c8438d98af0c729bbe07982b8a1c94201dc2 -b3174c9820bcc06201585ad81b25b64a2146384e3798290c05ad280a18c0a62e -e898260c07fca80a24c076cc864b777131a00190cdfa3069035eccbc038c30e1 -3e88b46d16b6acc5380d6ac202511c392f4b789aa7b0b08718765990111606c2 -9e854c38e5191878fbe471e749b0112bb18902008dc473b2b2e8e72700000000 -49454e44ae426082 -"""), - 'Tp2n3p08': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020080300000044a48a -c60000000467414d41000186a031e8965f00000300504c544502ffff80ff05ff -7f0703ff7f0180ff04ff00ffff06ff000880ff05ff7f07ffff06ff000804ff00 -0180ff02ffff03ff7f02ffff80ff0503ff7f0180ffff0008ff7f0704ff00ffff -06ff000802ffffff7f0704ff0003ff7fffff0680ff050180ff04ff000180ffff -0008ffff0603ff7f80ff05ff7f0702ffffff000880ff05ffff0603ff7f02ffff -ff7f070180ff04ff00ffff06ff000880ff050180ffff7f0702ffff04ff0003ff -7fff7f0704ff0003ff7f0180ffffff06ff000880ff0502ffffffff0603ff7fff -7f0702ffff04ff000180ff80ff05ff0008ff7f07ffff0680ff0504ff00ff0008 -0180ff03ff7f02ffff02ffffffff0604ff0003ff7f0180ffff000880ff05ff7f -0780ff05ff00080180ff02ffffff7f0703ff7fffff0604ff00ff7f07ff0008ff -ff0680ff0504ff0002ffff0180ff03ff7fff0008ffff0680ff0504ff000180ff -02ffff03ff7fff7f070180ff02ffff04ff00ffff06ff0008ff7f0780ff0503ff -7fffff06ff0008ff7f0780ff0502ffff03ff7f0180ff04ff0002ffffff7f07ff -ff0604ff0003ff7fff00080180ff80ff05ffff0603ff7f0180ffff000804ff00 -80ff0502ffffff7f0780ff05ffff0604ff000180ffff000802ffffff7f0703ff -7fff0008ff7f070180ff03ff7f02ffff80ff05ffff0604ff00ff0008ffff0602 -ffff0180ff04ff0003ff7f80ff05ff7f070180ff04ff00ff7f0780ff0502ffff -ff000803ff7fffff0602ffffff7f07ffff0680ff05ff000804ff0003ff7f0180 -ff02ffff0180ffff7f0703ff7fff000804ff0080ff05ffff0602ffff04ff00ff -ff0603ff7fff7f070180ff80ff05ff000803ff7f0180ffff7f0702ffffff0008 -04ff00ffff0680ff0503ff7f0180ff04ff0080ff05ffff06ff000802ffffff7f -0780ff05ff0008ff7f070180ff03ff7f04ff0002ffffffff0604ff00ff7f07ff -000880ff05ffff060180ff02ffff03ff7f80ff05ffff0602ffff0180ff03ff7f -04ff00ff7f07ff00080180ffff000880ff0502ffff04ff00ff7f0703ff7fffff -06ff0008ffff0604ff00ff7f0780ff0502ffff03ff7f0180ffdeb83387000000 -f874524e53000000000000000008080808080808081010101010101010181818 -1818181818202020202020202029292929292929293131313131313131393939 -393939393941414141414141414a4a4a4a4a4a4a4a52525252525252525a5a5a -5a5a5a5a5a62626262626262626a6a6a6a6a6a6a6a73737373737373737b7b7b -7b7b7b7b7b83838383838383838b8b8b8b8b8b8b8b94949494949494949c9c9c -9c9c9c9c9ca4a4a4a4a4a4a4a4acacacacacacacacb4b4b4b4b4b4b4b4bdbdbd -bdbdbdbdbdc5c5c5c5c5c5c5c5cdcdcdcdcdcdcdcdd5d5d5d5d5d5d5d5dedede -dededededee6e6e6e6e6e6e6e6eeeeeeeeeeeeeeeef6f6f6f6f6f6f6f6b98ac5 -ca0000012c49444154789c6360e7169150d230b475f7098d4ccc28a96ced9e32 -63c1da2d7b8e9fb97af3d1fb8f3f18e8a0808953544a4dd7c4c2c9233c2621bf -b4aab17fdacce5ab36ee3a72eafaad87efbefea68702362e7159652d031b07cf -c0b8a4cce28aa68e89f316aedfb4ffd0b92bf79fbcfcfe931e0a183904e55435 -8decdcbcc22292b3caaadb7b27cc5db67af3be63e72fdf78fce2d31f7a2860e5 -119356d037b374f10e8a4fc92eaa6fee99347fc9caad7b0f9ebd74f7c1db2fbf -e8a180995f484645dbdccad12f38363dafbcb6a573faeca5ebb6ed3e7ce2c29d -e76fbefda38702063e0149751d537b67ff80e8d4dcc29a86bea97316add9b0e3 -c0e96bf79ebdfafc971e0a587885e515f58cad5d7d43a2d2720aeadaba26cf5a -bc62fbcea3272fde7efafac37f3a28000087c0fe101bc2f85f0000000049454e -44ae426082 -"""), - 'tbbn1g04': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020040000000093e1c8 -290000000467414d41000186a031e8965f0000000274524e530007e8f7589b00 -000002624b47440000aa8d23320000013e49444154789c55d1cd4b024118c7f1 -efbe6419045b6a48a72d352808b435284f9187ae9b098627a1573a19945beba5 -e8129e8222af11d81e3a4545742de8ef6af6d5762e0fbf0fc33c33f36085cb76 -bc4204778771b867260683ee57e13f0c922df5c719c2b3b6c6c25b2382cea4b9 -9f7d4f244370746ac71f4ca88e0f173a6496749af47de8e44ba8f3bf9bdfa98a -0faf857a7dd95c7dc8d7c67c782c99727997f41eb2e3c1e554152465bb00fe8e -b692d190b718d159f4c0a45c4435915a243c58a7a4312a7a57913f05747594c6 -46169866c57101e4d4ce4d511423119c419183a3530cc63db88559ae28e7342a -1e9c8122b71139b8872d6e913153224bc1f35b60e4445bd4004e20ed6682c759 -1d9873b3da0fbf50137dc5c9bde84fdb2ec8bde1189e0448b63584735993c209 -7a601bd2710caceba6158797285b7f2084a2f82c57c01a0000000049454e44ae -426082 -"""), - 'tbrn2c08': _dehex(""" -89504e470d0a1a0a0000000d4948445200000020000000200802000000fc18ed -a30000000467414d41000186a031e8965f0000000674524e53007f007f007f8a -33334f00000006624b474400ff0000000033277cf3000004d649444154789cad -965f68537714c73fd912d640235e692f34d0406fa0c1663481045ab060065514 -56660a295831607df0a1488715167060840a1614e6431e9cb34fd2c00a762c85 -f6a10f816650c13b0cf40612e1822ddc4863bd628a8924d23d6464f9d3665dd9 -f7e977ce3dbff3cd3939bfdfef6bb87dfb364782dbed065ebe7cd93acc78b4ec -a228debd7bb7bfbfbfbbbbfb7f261045311a8d261209405194274f9ea4d3e916 -f15f1c3eb5dd6e4fa5fecce526239184a2b0b8486f6f617171b1f5ae4311381c -8e57af5e5dbd7a351088150a78bd389d44222c2f93cdfe66b7db8f4ee07038b6 -b6b6bebf766d7e7e7e60a06432313b4ba984c3c1c4049a46b95c5a58583822c1 -dbb76f27272733d1b9df853c3030c0f232562b9108cf9eb1b888d7cbf030abab -31abd5fa1f08dc6ef7e7cf9f1f3f7e1c8944745d4f1400c62c001313acad21cb -b8dd2c2c603271eb1640341aad4c6d331aa7e8c48913a150a861307ecc11e964 -74899919bc5e14e56fffc404f1388502f178dceff7ef4bf0a5cfe7abb533998c -e5f9ea2f1dd88c180d64cb94412df3dd57e83a6b3b3c7a84c98420100c72fd3a -636348bae726379fe69e8e8d8dbd79f3a6558b0607079796965256479b918085 -7b02db12712b6181950233023f3f647494ee6e2e5ea45864cce5b8a7fe3acffc -3aebb22c2bd5d20e22d0757d7b7bbbbdbd3d94a313bed1b0aa3cd069838b163a -8d4c59585f677292d0b84d9a995bd337def3fe6bbe5e6001989b9b6bfe27ea08 -36373781542ab56573248b4c5bc843ac4048c7ab21aa24ca00534c25482828a3 -8c9ee67475bbaaaab22cb722c8e57240a150301a8d219de94e44534d7d90e885 -87acb0e2c4f9800731629b6c5ee14a35a6b9887d2a0032994cb9cf15dbe59650 -ff7b46a04c9a749e7cc5112214266cc65c31354d5b5d5d3d90209bcd5616a552 -a95c2e87f2a659bd9ee01c2cd73964e438f129a6aa9e582c363838b80f81d7eb -5555b56a2a8ad2d9d7affd0409f8015c208013fea00177b873831b0282c964f2 -783c1e8fa7582cee5f81a669b5e6eeeeaee58e8559b0c233d8843c7c0b963a82 -34e94b5cb2396d7d7d7db22c8ba258fb0afd43f0e2c58b919191ba9de9b4d425 -118329b0c3323c8709d02041b52b4ea7f39de75d2a934a2693c0a953a76a93d4 -5d157ebf7f6565a5542a553df97c5e10045dd731c130b86113cc300cbd489224 -08422a952a140a95788fc763b1d41558d7a2d7af5f5fb870a1d6a3aaaacd6603 -18802da84c59015bd2e6897b745d9765b99a1df0f97c0daf74e36deaf7fbcd66 -73ad2797cb89a2c839880188a2e8743a8bc5a22ccbba5e376466b3b9bdbdbd21 -6123413a9d0e0402b51e4dd3bababa788eb022b85caeb6b6364551b6b7b76942 -43f7f727007a7a7a04a1ee8065b3595fde2768423299ac1ec6669c3973e65004 -c0f8f878ad69341a33994ced2969c0d0d0502412f9f8f163f3a7fd654b474787 -288ad53e74757535df6215b85cae60302849d2410aecc037f9f2e5cbd5b5c160 -680eb0dbede170381c0e7ff8f0a185be3b906068684892a4ca7a6f6faff69328 -8ad3d3d3f7efdfdfdbdbfb57e96868a14d0d0643381c96242997cbe5f3794010 -84603078fcf8f1d6496bd14a3aba5c2ea7d369341a5555b5582c8140e0fcf9f3 -1b1b1b87cf4eeb0a8063c78e45a3d19e9e1ebfdfdf5a831e844655d18093274f -9e3d7bf6d3a74f3b3b3b47c80efc05ff7af28fefb70d9b0000000049454e44ae -426082 -"""), - 'basn6a16': _dehex(""" -89504e470d0a1a0a0000000d494844520000002000000020100600000023eaa6 -b70000000467414d41000186a031e8965f00000d2249444154789cdd995f6c1c -d775c67ff38fb34b724d2ee55a8e4b04a0ac87049100cab4dbd8c6528902cb4d -10881620592e52d4325ac0905bc98a94025e71fd622cb5065ac98a0c283050c0 -728a00b6e542a1d126885cd3298928891d9a0444037e904434951d4b90b84b2f -c9dde1fcebc33977a95555348f411e16dfce9d3b77ee77eebde77ce78c95a669 -0ad07c17009a13edd898b87dfb1fcb7d2b4d1bff217f33df80deb1e6267df0ff -c1e6e6dfafdf1f5a7fd30f9aef66b6d546dd355bf02c40662e3307f9725a96c6 -744c3031f83782f171c148dbc3bf1774f5dad1e79d6f095a3f54d4fbec5234ef -d9a2f8d73afe4f14f57ef4f42def7b44f19060f06b45bddf1c5534d77fd922be -2973a15a82e648661c6e3240aa3612ead952b604bde57458894f29deaf133bac -13d2766f5227a4a3b8cf08da7adfd6fbd6bd8a4fe9dbb43d35e3dfa3f844fbf8 -9119bf4f7144094fb56333abf8a86063ca106f94b3a3b512343765e60082097f -1bb86ba72439a653519b09f5cee1ce61c897d37eedf5553580ae60f4af8af33a -b14fd400b6a0f34535c0434afc0b3a9f07147527a5fa7ca218ff56c74d74dc3f -155cfd3325fc278acf2ae1cb4a539f5f9937c457263b0bd51234c732a300cdd1 -cc1840f0aaff54db0e4874ed5a9b5d6d27d4bb36746d80de72baa877ff4b275a -d7895ed1897ea4139b5143fcbb1a62560da1ed9662aaed895ec78a91c18795b8 -5e07ab4af8ba128e95e682e0728bf8f2e5ae815a091a53d902ac1920d8e05f06 -589de8d8d66680789f4e454fb9d9ec66cd857af796ee2d902fa73fd5bba775a2 -153580ae44705ed0d37647d15697cb8f14bfa3e3e8fdf8031d47af571503357c -f30d25acedcbbf135c9a35c49766ba07ab255859e8ec03684e66860182dff8f7 -0304bff6ff1c20fc81b7afdd00a71475539a536e36bb5973a19e3b923b02bde5 -e4efd4003ac170eb2d13fe274157afedbd82d6fb3a9a1e85e4551d47cf7078f8 -9671fe4289ebf5f2bf08d63f37c4eb4773c55a0996efeefa0ca011671d8060ca -2f0004c7fcc300e166ef0240f825efe3361f106d57d423d0723f7acacd66376b -2ed47b7a7a7a205f4ef4ac4691e0aad9aa0d41cf13741c3580a506487574ddca -61a8c403c1863ebfbcac3475168b2de28b8b3d77544bb05ce92a02aceced3c0d -d0cc65ea371b201cf1c601c24dde1c4078cedbdeb60322f50126a019bf6edc9b -39e566b39b3517eaf97c3e0fbde5e4491d45bd74537145d155b476aa0176e868 -c6abebf30dbd5e525c54ac8e18e2d56abeb756827a3d970358a97416019a6f64 -f60004fdfe1580d5c98e618070cc1b05887eee7e0d209a70db7d8063029889b4 -c620ead78d7b33a7dc6c76b3e6427ddddbebde867c393aa7845e5403e8ca794a -d0d6fb897af5f03525fe5782f5e7046bdaef468bf88d1debc6ab25583cd17310 -6079b9ab0ba059c914018245bf076075b5a303200c3c1f209a733701444fbbaf -00c4134ebb016c5d0b23614c243701cdf875e3decce9349bddacb9505fbf7dfd -76e82d87736a00f5d2b5ffd4b7dce2719a4d25ae717ee153c1abef18e257cfad -7fa45682da48ef38c052b53b0fd06864b300c151ff08c0ea431de701a287dd5f -004497dc7b01a253ee3e80b8c7f91c20f967fb6fdb7c80ada7d8683723614c24 -3701cdf875e3decc29379bddacb950ef3fd47f08f2e5a61ea4aa2a3eb757cd55 -13345efcfa59c12b2f19e2578ef77fb75a82854ffbee01a83f977b11a031931d -040802df07082b5e11207cc17b1e209a770700e2df0a83e409fb7580f827c230 -99b06fd901fb058d6835dacd481813c94d40337eddb83773cacd66376b2ed437 -bebcf165e82d2f4e4beb7f3fa6e652c2d7ee10bc78c010bfb87fe3c95a09ae9f -bd732740bd2fb700d0f865f64180e059ff044018ca0ca28a5b04883f701e0088 -bfec7c0c909cb71f0448c6ec518074b375012079d9dedf66004bcfbc51eb2dd1 -aadacd481813c94d40337eddb83773cacd66376b2ed487868686205fbe7c49ef -5605a73f34c4a7a787eeab96e0da81bb4e022c15ba27019a5b339300e16bf286 -a8eae601e25866907cdf3e0890acb36f00245fb57f05904e59c300e92561946e -b2e600d209ab7d07f04d458dfb46ad1bd16ab49b913026929b8066fcba716fe6 -949bcd6ed65ca8ef7e7cf7e3d05b7e7c8f217ee6cdddbb6a25a856f37980e0c7 -fe4e80a82623c48193014846ec7180f4acf518409aca0cd28a5504e03b32c374 -de1a00608a0240faaa327a4b19fe946fb6f90054dbb5f2333d022db56eb4966a -3723614c243701cdf8f556bea8a7dc6c76b3e66bd46584ddbbcebc0990cf4b0f -ff4070520c282338a7e26700ec725202b01e4bcf0258963c6f1d4d8f0030cb20 -805549c520930c03584fa522b676f11600ffc03fde3e1b3489a9c9054c9aa23b -c08856a3dd8c843191dc0434e3d78d7b33a75c36fb993761f7ae5a69f72ef97f -e6ad336fed7e1c60e8bee96980bbdebbb60da07b7069062033d9dc0ae03d296f -70ab511ec071640676252902d833c916007b3e1900b0a6d2028035968e025861 -ea01581369fb11488c34d18cbc95989afccca42baad65ba2d5683723614c24d7 -8066fcbab8b7e96918baaf5aaa56219f975fb50a43f7c9bde90fa73f1c1a02d8 -78f2e27e803b77ca08b90519315b6fe400fc1392097a9eccc0ad444500e70199 -a1331f0f00d8934901c07e5d526ceb87c2d07e2579badd005a2b31a5089391b7 -1253358049535a6add8856dd0146c298482e01ede27ed878b256ba7600ee3a09 -c18fc1df09fe01084ec25defc1b56db0f1a4f4bd78e0e2818d2f0334e7330300 -7df7c888b917e50dd9c1c60c80efcb0cbc63e1f700bce7c31700dccbd1060027 -8add9b0de06c8e2f00d84962b7d7030e2a61538331b98051f92631bd253f336a -dd8856a3dd44c25c390efddfad96ae9f853b77c25201ba27c533b8bdf28b6ad0 -3d084b33d2e7fa59099e9901b8f2d29597fa0f01848f78e70082117f1ca07b76 -6910209b9519f895a008d031bbba05c09d8f06005c5b18b8fba25300cea6780e -c03e911c6ccf06d507b48a4fa606634a114609de929f9934c5a87511ad57cfc1 -fa476aa5854fa1ef1e3910b905686e85cc24c40138198915f133d2d6dc2a7dea -7df2ccc2a752faf2cec1d577aebeb37e3b4034eeee0008dff3be0e6b923773b4 -7904c0ef9119767cb4fa1500ef1361e08e452500f71561e84cc4ed3e20fab6a2 -c905f40cb76a3026bf3319b91ac2e46792a6dcd801ebc6aba5da08f48ecb81c8 -bd088d5f42f6417191de93908c803d0e76199292b485af41b60e8d9c3c537f0e -8211f0c7211a077707dc18b931b2ee6d80a4d7ae024491ebc24d4a708ff70680 -7f25e807e8785f1878e322d6ddaf453f0770ff2dfa769b01423dbbad72a391b6 -5a7c3235985629423372494cab55c8f7d64a8b27a0e7202c55a13b0f8d19c80e -4ae9ca3f015115dc3ca467c17a4c7ee95970ab10e5a54ff0ac3cd39881ee5958 -1a84f03df0be0e492fd855a8d6aa35d10b4962dbb0a604a3d3ee5e80a8eee600 -a24977f8660378bf0bbf00e01d0a8fb7f980f04b8aa6ce6aca8d5a7533c52753 -839152c4e222f4dc512dd5eb90cbc981e8ea12cf90cd8a8bf47d89159e2741d3 -7124f65b96fcd254dae258fa84a13c13043246a32129574787e49eae2b49b86d -c3e2e78b9ff7f4002415bb08907c66df0d103b4e0c104db90500ff70700c203a -ee1e82dba4c3e16e256c0acca6ceaae9afd1f612d7eb472157ac95962bd05594 -7dd1598466053245088e827f44628657942a825b84e4fb601f84b4025611aca3 -901e01bb024911dc0a4445f08e41f83df02b10142173149ab71baf027611ea95 -7a257704201d14cd9af4d90b00f194530088cb4e09c0df1c5c0088f7393f6833 -c0aa3ac156655de3bca9b34ab9716906ba07aba5e5bba1eb3358d90b9da7c533 -64f6888bf47b60f521e8380fe10be03d2feac17900927560df40f4e48f805960 -50328d648bf4893f9067c217a0631656b7c898c122847bc07b03a2d3e0ee85e4 -33b0ef867450c4fad2ecd26cf7168074c0ba0c904cdac300c9cfec4701924df6 -1cdca61e10685c6f7d52d0caba1498972f43d740adb4b2009d7d7220b20e3473 -90a943d00ffe959bb6eac3e0fe42ea49ee00c45f06e76329b1dabf127d690d80 -5581b408f63c2403e0cc433c00ee658836803b0fd100747c04ab5f917704fd10 -d5c1cd41ec801343d207f602a403605d86e5f9e5f9ae0d00e994556833806685 -c931fb709b0f08b4e869bea5c827859549e82c544b8d29c816a0390999613920 -7e610d5727a16318c2003c1fa24be0de2b32caf92224e7c17e5004b6350c4c01 -05601218066b0ad28224e149019c086257ca315102de2712903bde97b8144d82 -3b2c6ac52d403c054e019249b087f53d0558995a99ea946c70cc927458b3c1ff -550f30050df988d4284376b4566a8e416654cc921985e037e0df0fc131f00f4b -acf0c6211c036f14a239703741740adc7da227edd7e56b833d0ae92549b4d357 -25dfb49ed2ff63908e6adf27d6d0dda7638d4154d2778daca17f58e61297c129 -41f233b01f5dc3740cac51688c35c6b22580f48224fee9b83502569a66b629f1 -09f3713473413e2666e7fe6f6c6efefdfafda1f56f6e06f93496d9d67cb7366a -9964b6f92e64b689196ec6c604646fd3fe4771ff1bf03f65d8ecc3addbb5f300 -00000049454e44ae426082 -"""), -} - -def test_suite(options, args): - """ - Create a PNG test image and write the file to stdout. - """ - - # Below is a big stack of test image generators. - # They're all really tiny, so PEP 8 rules are suspended. - - def test_gradient_horizontal_lr(x, y): return x - def test_gradient_horizontal_rl(x, y): return 1-x - def test_gradient_vertical_tb(x, y): return y - def test_gradient_vertical_bt(x, y): return 1-y - def test_radial_tl(x, y): return max(1-math.sqrt(x*x+y*y), 0.0) - def test_radial_center(x, y): return test_radial_tl(x-0.5, y-0.5) - def test_radial_tr(x, y): return test_radial_tl(1-x, y) - def test_radial_bl(x, y): return test_radial_tl(x, 1-y) - def test_radial_br(x, y): return test_radial_tl(1-x, 1-y) - def test_stripe(x, n): return float(int(x*n) & 1) - def test_stripe_h_2(x, y): return test_stripe(x, 2) - def test_stripe_h_4(x, y): return test_stripe(x, 4) - def test_stripe_h_10(x, y): return test_stripe(x, 10) - def test_stripe_v_2(x, y): return test_stripe(y, 2) - def test_stripe_v_4(x, y): return test_stripe(y, 4) - def test_stripe_v_10(x, y): return test_stripe(y, 10) - def test_stripe_lr_10(x, y): return test_stripe(x+y, 10) - def test_stripe_rl_10(x, y): return test_stripe(1+x-y, 10) - def test_checker(x, y, n): return float((int(x*n) & 1) ^ (int(y*n) & 1)) - def test_checker_8(x, y): return test_checker(x, y, 8) - def test_checker_15(x, y): return test_checker(x, y, 15) - def test_zero(x, y): return 0 - def test_one(x, y): return 1 - - test_patterns = { - 'GLR': test_gradient_horizontal_lr, - 'GRL': test_gradient_horizontal_rl, - 'GTB': test_gradient_vertical_tb, - 'GBT': test_gradient_vertical_bt, - 'RTL': test_radial_tl, - 'RTR': test_radial_tr, - 'RBL': test_radial_bl, - 'RBR': test_radial_br, - 'RCTR': test_radial_center, - 'HS2': test_stripe_h_2, - 'HS4': test_stripe_h_4, - 'HS10': test_stripe_h_10, - 'VS2': test_stripe_v_2, - 'VS4': test_stripe_v_4, - 'VS10': test_stripe_v_10, - 'LRS': test_stripe_lr_10, - 'RLS': test_stripe_rl_10, - 'CK8': test_checker_8, - 'CK15': test_checker_15, - 'ZERO': test_zero, - 'ONE': test_one, - } - - def test_pattern(width, height, bitdepth, pattern): - """Create a single plane (monochrome) test pattern. Returns a - flat row flat pixel array. - """ - - maxval = 2**bitdepth-1 - if maxval > 255: - a = array('H') - else: - a = array('B') - fw = float(width) - fh = float(height) - pfun = test_patterns[pattern] - for y in range(height): - fy = float(y)/fh - for x in range(width): - a.append(int(round(pfun(float(x)/fw, fy) * maxval))) - return a - - def test_rgba(size=256, bitdepth=8, - red="GTB", green="GLR", blue="RTL", alpha=None): - """ - Create a test image. Each channel is generated from the - specified pattern; any channel apart from red can be set to - None, which will cause it not to be in the image. It - is possible to create all PNG channel types (L, RGB, LA, RGBA), - as well as non PNG channel types (RGA, and so on). - """ - - i = test_pattern(size, size, bitdepth, red) - psize = 1 - for channel in (green, blue, alpha): - if channel: - c = test_pattern(size, size, bitdepth, channel) - i = interleave_planes(i, c, psize, 1) - psize += 1 - return i - - def pngsuite_image(name): - """ - Create a test image by reading an internal copy of the files - from the PngSuite. Returned in flat row flat pixel format. - """ - - if name not in _pngsuite: - raise NotImplementedError("cannot find PngSuite file %s (use -L for a list)" % name) - r = Reader(bytes=_pngsuite[name]) - w,h,pixels,meta = r.asDirect() - assert w == h - # LAn for n < 8 is a special case for which we need to rescale - # the data. - if meta['greyscale'] and meta['alpha'] and meta['bitdepth'] < 8: - factor = 255 // (2**meta['bitdepth']-1) - def rescale(data): - for row in data: - yield map(factor.__mul__, row) - pixels = rescale(pixels) - meta['bitdepth'] = 8 - arraycode = 'BH'[meta['bitdepth']>8] - return w, array(arraycode, itertools.chain(*pixels)), meta - - # The body of test_suite() - size = 256 - if options.test_size: - size = options.test_size - options.bitdepth = options.test_depth - options.greyscale=bool(options.test_black) - - kwargs = {} - if options.test_red: - kwargs["red"] = options.test_red - if options.test_green: - kwargs["green"] = options.test_green - if options.test_blue: - kwargs["blue"] = options.test_blue - if options.test_alpha: - kwargs["alpha"] = options.test_alpha - if options.greyscale: - if options.test_red or options.test_green or options.test_blue: - raise ValueError("cannot specify colours (R, G, B) when greyscale image (black channel, K) is specified") - kwargs["red"] = options.test_black - kwargs["green"] = None - kwargs["blue"] = None - options.alpha = bool(options.test_alpha) - if not args: - pixels = test_rgba(size, options.bitdepth, **kwargs) - else: - size,pixels,meta = pngsuite_image(args[0]) - for k in ['bitdepth', 'alpha', 'greyscale']: - setattr(options, k, meta[k]) - - writer = Writer(size, size, - bitdepth=options.bitdepth, - transparent=options.transparent, - background=options.background, - gamma=options.gamma, - greyscale=options.greyscale, - alpha=options.alpha, - compression=options.compression, - interlace=options.interlace) - writer.write_array(sys.stdout, pixels) - -def read_pam_header(infile): - """ - Read (the rest of a) PAM header. `infile` should be positioned - immediately after the initial 'P7' line (at the beginning of the - second line). Returns are as for `read_pnm_header`. - """ - - # Unlike PBM, PGM, and PPM, we can read the header a line at a time. - header = dict() - while True: - l = infile.readline().strip() - if l == strtobytes('ENDHDR'): - break - if not l: - raise EOFError('PAM ended prematurely') - if l[0] == strtobytes('#'): - continue - l = l.split(None, 1) - if l[0] not in header: - header[l[0]] = l[1] - else: - header[l[0]] += strtobytes(' ') + l[1] - - required = ['WIDTH', 'HEIGHT', 'DEPTH', 'MAXVAL'] - required = [strtobytes(x) for x in required] - WIDTH,HEIGHT,DEPTH,MAXVAL = required - present = [x for x in required if x in header] - if len(present) != len(required): - raise Error('PAM file must specify WIDTH, HEIGHT, DEPTH, and MAXVAL') - width = int(header[WIDTH]) - height = int(header[HEIGHT]) - depth = int(header[DEPTH]) - maxval = int(header[MAXVAL]) - if (width <= 0 or - height <= 0 or - depth <= 0 or - maxval <= 0): - raise Error( - 'WIDTH, HEIGHT, DEPTH, MAXVAL must all be positive integers') - return 'P7', width, height, depth, maxval - -def read_pnm_header(infile, supported=('P5','P6')): - """ - Read a PNM header, returning (format,width,height,depth,maxval). - `width` and `height` are in pixels. `depth` is the number of - channels in the image; for PBM and PGM it is synthesized as 1, for - PPM as 3; for PAM images it is read from the header. `maxval` is - synthesized (as 1) for PBM images. - """ - - # Generally, see http://netpbm.sourceforge.net/doc/ppm.html - # and http://netpbm.sourceforge.net/doc/pam.html - - supported = [strtobytes(x) for x in supported] - - # Technically 'P7' must be followed by a newline, so by using - # rstrip() we are being liberal in what we accept. I think this - # is acceptable. - type = infile.read(3).rstrip() - if type not in supported: - raise NotImplementedError('file format %s not supported' % type) - if type == strtobytes('P7'): - # PAM header parsing is completely different. - return read_pam_header(infile) - # Expected number of tokens in header (3 for P4, 4 for P6) - expected = 4 - pbm = ('P1', 'P4') - if type in pbm: - expected = 3 - header = [type] - - # We have to read the rest of the header byte by byte because the - # final whitespace character (immediately following the MAXVAL in - # the case of P6) may not be a newline. Of course all PNM files in - # the wild use a newline at this point, so it's tempting to use - # readline; but it would be wrong. - def getc(): - c = infile.read(1) - if not c: - raise Error('premature EOF reading PNM header') - return c - - c = getc() - while True: - # Skip whitespace that precedes a token. - while c.isspace(): - c = getc() - # Skip comments. - while c == '#': - while c not in '\n\r': - c = getc() - if not c.isdigit(): - raise Error('unexpected character %s found in header' % c) - # According to the specification it is legal to have comments - # that appear in the middle of a token. - # This is bonkers; I've never seen it; and it's a bit awkward to - # code good lexers in Python (no goto). So we break on such - # cases. - token = strtobytes('') - while c.isdigit(): - token += c - c = getc() - # Slight hack. All "tokens" are decimal integers, so convert - # them here. - header.append(int(token)) - if len(header) == expected: - break - # Skip comments (again) - while c == '#': - while c not in '\n\r': - c = getc() - if not c.isspace(): - raise Error('expected header to end with whitespace, not %s' % c) - - if type in pbm: - # synthesize a MAXVAL - header.append(1) - depth = (1,3)[type == strtobytes('P6')] - return header[0], header[1], header[2], depth, header[3] - -def write_pnm(file, width, height, pixels, meta): - """Write a Netpbm PNM/PAM file.""" - - bitdepth = meta['bitdepth'] - maxval = 2**bitdepth - 1 - # Rudely, the number of image planes can be used to determine - # whether we are L (PGM), LA (PAM), RGB (PPM), or RGBA (PAM). - planes = meta['planes'] - # Can be an assert as long as we assume that pixels and meta came - # from a PNG file. - assert planes in (1,2,3,4) - if planes in (1,3): - if 1 == planes: - # PGM - # Could generate PBM if maxval is 1, but we don't (for one - # thing, we'd have to convert the data, not just blat it - # out). - fmt = 'P5' - else: - # PPM - fmt = 'P6' - file.write('%s %d %d %d\n' % (fmt, width, height, maxval)) - if planes in (2,4): - # PAM - # See http://netpbm.sourceforge.net/doc/pam.html - if 2 == planes: - tupltype = 'GRAYSCALE_ALPHA' - else: - tupltype = 'RGB_ALPHA' - file.write('P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\n' - 'TUPLTYPE %s\nENDHDR\n' % - (width, height, planes, maxval, tupltype)) - # Values per row - vpr = planes * width - # struct format - fmt = '>%d' % vpr - if maxval > 0xff: - fmt = fmt + 'H' - else: - fmt = fmt + 'B' - for row in pixels: - file.write(struct.pack(fmt, *row)) - file.flush() - -def color_triple(color): - """ - Convert a command line colour value to a RGB triple of integers. - FIXME: Somewhere we need support for greyscale backgrounds etc. - """ - if color.startswith('#') and len(color) == 4: - return (int(color[1], 16), - int(color[2], 16), - int(color[3], 16)) - if color.startswith('#') and len(color) == 7: - return (int(color[1:3], 16), - int(color[3:5], 16), - int(color[5:7], 16)) - elif color.startswith('#') and len(color) == 13: - return (int(color[1:5], 16), - int(color[5:9], 16), - int(color[9:13], 16)) - - -def _main(argv): - """ - Run the PNG encoder with options from the command line. - """ - - # Parse command line arguments - from optparse import OptionParser - import re - version = '%prog ' + re.sub(r'( ?\$|URL: |Rev:)', '', __version__) - parser = OptionParser(version=version) - parser.set_usage("%prog [options] [imagefile]") - parser.add_option('-r', '--read-png', default=False, - action='store_true', - help='Read PNG, write PNM') - parser.add_option("-i", "--interlace", - default=False, action="store_true", - help="create an interlaced PNG file (Adam7)") - parser.add_option("-t", "--transparent", - action="store", type="string", metavar="color", - help="mark the specified colour (#RRGGBB) as transparent") - parser.add_option("-b", "--background", - action="store", type="string", metavar="color", - help="save the specified background colour") - parser.add_option("-a", "--alpha", - action="store", type="string", metavar="pgmfile", - help="alpha channel transparency (RGBA)") - parser.add_option("-g", "--gamma", - action="store", type="float", metavar="value", - help="save the specified gamma value") - parser.add_option("-c", "--compression", - action="store", type="int", metavar="level", - help="zlib compression level (0-9)") - parser.add_option("-T", "--test", - default=False, action="store_true", - help="create a test image (a named PngSuite image if an argument is supplied)") - parser.add_option('-L', '--list', - default=False, action='store_true', - help="print list of named test images") - parser.add_option("-R", "--test-red", - action="store", type="string", metavar="pattern", - help="test pattern for the red image layer") - parser.add_option("-G", "--test-green", - action="store", type="string", metavar="pattern", - help="test pattern for the green image layer") - parser.add_option("-B", "--test-blue", - action="store", type="string", metavar="pattern", - help="test pattern for the blue image layer") - parser.add_option("-A", "--test-alpha", - action="store", type="string", metavar="pattern", - help="test pattern for the alpha image layer") - parser.add_option("-K", "--test-black", - action="store", type="string", metavar="pattern", - help="test pattern for greyscale image") - parser.add_option("-d", "--test-depth", - default=8, action="store", type="int", - metavar='NBITS', - help="create test PNGs that are NBITS bits per channel") - parser.add_option("-S", "--test-size", - action="store", type="int", metavar="size", - help="width and height of the test image") - (options, args) = parser.parse_args(args=argv[1:]) - - # Convert options - if options.transparent is not None: - options.transparent = color_triple(options.transparent) - if options.background is not None: - options.background = color_triple(options.background) - - if options.list: - names = list(_pngsuite) - names.sort() - for name in names: - print name - return - - # Run regression tests - if options.test: - return test_suite(options, args) - - # Prepare input and output files - if len(args) == 0: - infilename = '-' - infile = sys.stdin - elif len(args) == 1: - infilename = args[0] - infile = open(infilename, 'rb') - else: - parser.error("more than one input file") - outfile = sys.stdout - - if options.read_png: - # Encode PNG to PPM - png = Reader(file=infile) - width,height,pixels,meta = png.asDirect() - write_pnm(outfile, width, height, pixels, meta) - else: - # Encode PNM to PNG - format, width, height, depth, maxval = \ - read_pnm_header(infile, ('P5','P6','P7')) - # When it comes to the variety of input formats, we do something - # rather rude. Observe that L, LA, RGB, RGBA are the 4 colour - # types supported by PNG and that they correspond to 1, 2, 3, 4 - # channels respectively. So we use the number of channels in - # the source image to determine which one we have. We do not - # care about TUPLTYPE. - greyscale = depth <= 2 - pamalpha = depth in (2,4) - supported = map(lambda x: 2**x-1, range(1,17)) - try: - mi = supported.index(maxval) - except ValueError: - raise NotImplementedError( - 'your maxval (%s) not in supported list %s' % - (maxval, str(supported))) - bitdepth = mi+1 - writer = Writer(width, height, - greyscale=greyscale, - bitdepth=bitdepth, - interlace=options.interlace, - transparent=options.transparent, - background=options.background, - alpha=bool(pamalpha or options.alpha), - gamma=options.gamma, - compression=options.compression) - if options.alpha: - pgmfile = open(options.alpha, 'rb') - format, awidth, aheight, adepth, amaxval = \ - read_pnm_header(pgmfile, 'P5') - if amaxval != '255': - raise NotImplementedError( - 'maxval %s not supported for alpha channel' % amaxval) - if (awidth, aheight) != (width, height): - raise ValueError("alpha channel image size mismatch" - " (%s has %sx%s but %s has %sx%s)" - % (infilename, width, height, - options.alpha, awidth, aheight)) - writer.convert_ppm_and_pgm(infile, pgmfile, outfile) - else: - writer.convert_pnm(infile, outfile) - - -if __name__ == '__main__': - try: - _main(sys.argv) - except Error, e: - print >>sys.stderr, e |