6Dh; ^ S r SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK
r
SSK r SSK J r / SQr
\R " SSSS S
S S S
S 5 rSrS r\R$ " SS5 rS rS rS rS rS r " S S\5 r " S S\5 r " S S \5 r " S S \5 r " S S 5 r " S! S"5 r S>S# jr S$ r!S% r"S& r#S' r$S( r%S) r&\RN " S*\RP S+9r)S0 4S, jr*\*r+ " S- S.5 r, " S/ S05 r-S1 r.S2 r/S3 r0S4 r1S5 r2S6 r3S7 r4S8 r5S9 r6S: r7S; r8S< r9S= r:g)?a
The ``png`` module can read and write PNG files.
Installation and Overview
-------------------------
``pip install pypng``
For help, type ``import png; help(png)`` in your python interpreter.
A good place to start is the :class:`Reader` and :class:`Writer` classes.
Coverage of PNG formats is fairly complete;
all allowable bit depths (1/2/4/8/16/24/32/48/64 bits per pixel) and
colour combinations are supported:
- 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).
Interlaced images,
which support a progressive display when downloading,
are supported for both reading and writing.
A number of optional chunks can be specified (when writing)
and understood (when reading): ``tRNS``, ``bKGD``, ``gAMA``.
The ``sBIT`` chunk can be used to specify precision for
non-native bit depths.
Requires Python 3.5 or higher.
Installation is trivial,
but see the ``README.txt`` file (with the source distribution) for details.
Full use of all features will need some reading of the PNG specification
http://www.w3.org/TR/2003/REC-PNG-20031110/.
The package also comes with command line utilities.
- ``pripamtopng`` converts
`Netpbm `_ PAM/PNM files to PNG;
- ``pripngtopam`` converts PNG to file PAM/PNM.
There are a few more for simple PNG manipulations.
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.
Colour Models
-------------
The major colour models supported by PNG (and hence by PyPNG) are:
- greyscale;
- greyscale--alpha;
- RGB;
- RGB--alpha.
Also referred to using the abbreviations: L, LA, RGB, RGBA.
Each letter codes a single channel:
*L* is for Luminance or Luma or Lightness (greyscale images);
*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);
*R*, *G*, *B* stand for Red, Green, Blue (colour image).
Lists, arrays, sequences, and so on
-----------------------------------
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.
The preferred format is a sequence of *rows*,
which each row being a sequence of *values*.
In this format, the values are in pixel order,
with all the values from all the pixels in a row
being concatenated into a single sequence for that row.
Consider an image that is 3 pixels wide by 2 pixels high, and each pixel
has RGB components:
Sequence of rows::
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 preferred 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 (``bytearray`` or ``array.array``).
To allow streaming the outer list is sometimes
an iterator rather than an explicit list.
An alternative format is a single array holding all the values.
Array of values::
[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.
The top row comes first,
and within 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 another format, which should only be used with caution.
It is 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 the same as a sequence of rows;
when the bit depth is less than 8 (1, 2 and 4),
several pixels are packed into each byte;
when the bit depth is 16 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).
z0.0.20 Narray)ImageReaderWriter write_chunks
from_array8B P N G
))r r r ) r r r )r r r r ) r r r )r r r r ) r r r )r r r r c # v ^^# [ H) u mnmnTU : a M UU4S j[ X!U5 5 v M+ g7f)aU
Generate the coordinates for the reduced scanlines
of an Adam7 interlaced image
of size `width` by `height` pixels.
Yields a generator for each pass,
and each pass generator yields a series of (x, y, xstep) triples,
each one identifying a reduced scanline consisting of
pixels starting at (x, y) and taking every xstep pixel to the right.
c 3 . ># U H
nTUT4v M g 7fN ).0yxstartxsteps C/var/www/html/env/lib/python3.13/site-packages/_plotly_utils/png.py !adam7_generate.. s H+Ga5!+Gs N)adam7range)widthheightystartystepr r s @@r adam7_generater' s7 ).$u U? H5+GHH ).s 59 _Resolutionzx y unit_is_meterc > [ [ [ U 5 /U- 6 5 $ r )listzipiter)sns r groupr/ s d1gY]# $$ c " [ U [ 5 $ r )
isinstancer )xs r isarrayr4 s a r0 c U c g[ U 5 nS[ U5 s=: a S:: d
O [ S5 eSn[ U5 H u p4[ U5 S; a [ SU- 5 e[ U5 S:X a S nU( a [ U5 S
:X a [ S U- 5 eU H/ n[ U5 U:w d SUs=:: a S :: a M! O [ S
U- 5 e M U$ )z
Check a palette argument (to the :class:`Writer` class) for validity.
Returns the palette as a list if okay;
raises an exception otherwise.
Nr zTa palette must have between 1 and 256 entries, see https://www.w3.org/TR/PNG/#11PLTEF) r z1palette entry %d: entries must be 3- or 4-tuples.r7 Tr z8palette entry %d: all 4-tuples must precede all 3-tuples z7palette entry %d: values must be integer: 0 <= x <= 255)r* len
ProtocolError enumerateint)palettep seen_tripleitr3 s r
check_paletterB s W
A
A #
5
K! q6 SVW WX X q6Q; K 3q6Q; JQN
A1v{1=S=#PSTT
Hr0 c U ( d X4$ [ U 5 S:w a [ S5 eUb XS :w a [ SU S < SU< S35 eUb X S :w a [ SU S < S U< S35 eU $ )
zY
Check that these arguments, if supplied, are consistent.
Return a (width, height) pair.
r z.size argument should be a pair (width, height)r z size[0] (z
) and width (z") should match when both are used.r z size[1] (z) and height ()r9 r: )sizer# r$ s r check_sizesrE s }
4yA~ LMM U1g -Aw
fQ /Aw
Kr0 c U c U $ U( aM [ U 5 [ U 5 S:w a [ SU- 5 e[ U S 5 ( d [ SU- 5 e U $ [ U 5 S:X a9 [ U S 5 ( a& [ U S 5 ( a [ U S 5 ( d [ SU- 5 eU $ ! [ a U 4n Nf = f)z
Checks that a colour argument for transparent or background options
is the right form.
Returns the colour
(which, if it's a bare integer, is "corrected" to a 1-tuple).
r z %s for greyscale must be 1-tupler z'%s colour for greyscale must be integerr7 r z&%s colour must be a triple of integers)r9 TypeErrorr:
is_natural)c greyscalewhichs r check_colorrL - s y F q6Q; BU JK K!A$ IE QR R
H
FaKJqt , ,AaD1A1AjQRSTQUFVFV H5 PQ Q H A s B2 2
CCc \ rS rSrS rSrg)ErroriH c l U R R S- SR U R 5 - $ )Nz: ) __class____name__joinargsselfs r __str__
Error.__str__I s) ~~&&-0CCCr0 r N)rR
__module__ __qualname____firstlineno__rW __static_attributes__r r0 r rN rN H s Dr0 rN c \ rS rSrSrSrg) FormatErroriM z|
Problem with input file format.
In other words, PNG file does not conform to
the specification in some way and is invalid.
r NrR rY rZ r[ __doc__r\ r r0 r r^ r^ M s r0 r^ c \ rS rSrSrSrg)r: iU z\
Problem with the way the programming interface has been used,
or the data presented to it.
r Nr_ r r0 r r: r: U s r0 r: c \ rS rSrSrg)
ChunkErrori\ r N)rR rY rZ r[ r\ r r0 r rc rc \ s r0 rc c \ rS rSrSrSrg)Defaulti` z'The default for the greyscale paramter.r Nr_ r r0 r re re ` s 1r0 re c r \ rS rSrSrSSS\SSSSSSSSSSSSSSS4S jrS rS rS
r S r
S r S
r S r
Srg)r id z
PNG encoder in pure Python.
NFr i c . [ X1U5 u pA[ U5 ( a [ U5 ( d [ S5 eUS:: d US:: a [ S5 eUS: d US: a [ S5 eU( a Ub [ S5 e [ U5 U HA n[ U5 =( a SUs=:* =( a S :* Os nU( a M3 [ S
U< S 35 e [ U5 n[
U5 n[
U5 nU[ L a U( a S n[
U5 nU( a SnSn
O
S
U nUU- n
[ U5 S:X a Xm- n[ XvXU5 u o`l US: a U( d U( d eU( a eUS: a U( a e[ XS5 n[ XS5 n Xl X l Xl
Xl Xl X@l XPl Xl [' U5 U l Xl UU l [
U 5 U l Xpl UU l UU l [
U5 U l SU R" - SU( + - - SU R$ - - U l U R8 S; d eUU l Xl U R( S- U R< - U l g! [ a U4n GN f = f)a
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
Pixels are greyscale, not RGB.
alpha
Input data has alpha channel (RGBA or LA).
bitdepth
Bit depth: from 1 to 16 (for each channel).
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: 0 (none) to 9 (more compressed);
default: -1 or None.
interlace
Create an interlaced image.
chunk_limit
Write multiple ``IDAT`` chunks to save memory.
x_pixels_per_unit
Number of pixels a unit along the x axis (write a
`pHYs` chunk).
y_pixels_per_unit
Number of pixels a unit along the y axis (write a
`pHYs` chunk). Along with `x_pixel_unit`, this gives
the pixel size ratio.
unit_is_meter
`True` to indicate that the unit (for the `pHYs`
chunk) is metre.
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*).
The `greyscale` argument indicates whether input pixels
are greyscale (when true), or colour (when false).
The default is true unless `palette=` is used.
The `alpha` argument (a boolean) specifies
whether input pixels have an alpha channel (or not).
`bitdepth` specifies the bit depth of the source pixel values.
Each channel may have a different bit depth.
Each source pixel must have values that are
an integer between 0 and ``2**bitdepth-1``, where
`bitdepth` is the bit depth for the corresponding channel.
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 (the same for all channels).
When `bitdepth` is not one of these values or where
channels have different bit depths,
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 PNG file format supports many bit depth / colour model
combinations, but not all.
The details are somewhat arcane
(refer to the PNG specification for full details).
Briefly:
Bit depths < 8 (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 use the `bitdepth` argument 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 true; `alpha` must not be true;
`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.
All the 4-tuples (if present) 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 one element for each channel in the image.
Either a 3-tuple of integer (RGB) values for a colour image, or
a 1-tuple of a single integer 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.
Values from 1 to 9 (highest) specify compression.
0 means no compression.
-1 and ``None`` both mean that the ``zlib`` module uses
the default level of compession (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 passed in,
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.
z!width and height must be integersr z*width and height must be greater than zeroz&width and height cannot exceed 2**31-1Nz1transparent colour not allowed with alpha channelr zeach bitdepth z! must be a positive integer <= 16Fr7 r r transparent
backgroundr r r r r7 r ) rE rH r: r9 rG rB boolre check_bitdepth_rescalerescalerL r# r$ rk rl gammarJ alphacolormapr< bitdepth compression chunk_limit interlacer= x_pixels_per_unity_pixels_per_unit
unit_is_meter
color_type color_planesplanespsize)rV r# r$ rD rJ rs ru r= rk rl rr rv rx r~ rt maxvalrw ry rz r{ bvalidr} s r __init__Writer.__init__i sv d $D8
%
6(:(: CD D A:1 LM M 9 2 HI I [, ST T # M A qM2a1lllE5#KSU (U = G IO LF!),L!E)F x=A H!7 {9"
, a< '' 9 a< ;!+-H E
&$
"
H
&& i !2 !2 !- 0djj.1I
+>>T]]ARR/111 ( mma'4;;6
G # {H #s ? J
JJc p ^ U R U R - mU4S jnU R ( aF SU R S: n[ U[
R " U" U5 6 5 nU R X5 $ U R X" U5 5 nX`R :w a [ SX`R 4- 5 eg)a
Write a PNG image to the output file.
`rows` should be an iterable that yields each row
(each row is a sequence of values).
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 requires the entire image to be in working memory.
c 3 ># [ U 5 H9 u p [ U5 T:g nU( a [ ST[ U5 U4- 5 eUv M; g! [ a Sn N8f = f7f)zG
Yield each row in rows,
but check each row first (for correct width).
Fz/Expected %d values but got %d values, in row %dN)r; r9 rG r: )rowsr@ row wrong_lengthvprs r
check_rows Writer.write..check_rows sp
$D/)#&s8s?L 'I C!,- * ! ) $)L )s' A A
*A
A A A A BHr z-rows supplied (%d) does not match height (%d)N) r# r~ rx ru r itertoolschain write_array write_passesr$ r: )rV outfiler r fmtanrowsr s @r write Writer.writer s & jj4;;& * >>t}}q()Cc9??Jt,<=>A##G/ /!!':d+;< KK ?5++BVV
r0 c U R ( a [ X R 5 nU R S: a [ X R 5 nOU R S:X a [ U5 nU R X5 $ )a
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.
For interlaced images the rows should have been interlaced before
passing them to this function.
`rows` should be an iterable that yields each row
(each row being a sequence of values).
r ri )rq rescale_rowsru pack_rows unpack_rows write_packed)rV r r s r r Writer.write_passes sZ ( << ll3D ==1 T==1D
]]b
t$D //r0 c U R U5 U R b! [ R " U R 5 nO[ R " 5 n[ 5 n[ U5 Hz u pVUR
S5 UR U5 [ U5 U R : d MB UR U5 n[ U5 ( a
[ USU5 [ 5 nM| UR [ U5 5 nUR 5 n[ U5 ( d [ U5 ( a [ USXx- 5 [ US5 WS- $ )a%
Write PNG file to `outfile`.
`rows` should be an iterator that yields each packed row;
a packed row being a sequence of packed bytes.
The rows have a filter byte prefixed and
are then compressed into one or more IDAT chunks.
They are not processed any further,
so if bitdepth is other than 1, 2, 4, 8, 16,
the pixel values should have been scaled
before passing them to this method.
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.
r IDAT IENDr )write_preamblerv zlib compressobj bytearrayr; appendextendr9 rw compress write_chunkbytesflush) rV r r
compressordatar@ r
compressedflusheds r r Writer.write_packed s $
G$ ' ))$*:*:;J ))+J { oFA
KKN KK 4y4+++ ' 0 0 6
z?? *= { & ((t5
""$ z??c'll **> ?GW%1u r0 c UR [ 5 [ US[ R " SU R
U R U R U R SSU R 5 5 U R bA [ US[ R " S[ [ U R S- 5 5 5 5 U R ( aL [ US[ R " SU R - /U R Vs/ s H o"S PM snQ76 5 U R ( a8 [! U R 5 u p4[ US U5 U( a
[ US
U5 U R" bB U R$ ( a S nOS n[ US
[ R " U/U R" Q76 5 U R& bB U R$ ( a S nOS n[ US
[ R " U/U R& Q76 5 U R( b] U R* bO U R( U R* [ U R, 5 4n[ US[ R " S/UQ76 5 g g g s snf )Ns IHDR!2I5Br s gAMA!L j@s sBIT%dBs PLTEs tRNSz!1Hz!3Hs bKGDs pHYs!LLB)r signaturer structpackr# r$ ru r| rx rr r< roundrq r~ r= make_palette_chunksrk rJ rl ry rz r{ )rV r r- r> rA r tups r r Writer.write_preamble s
i KK
" :: ! &++dCdjj3>N8O4P"Q
<< EDKK /O 2N AQ4 2NO
<<&t||4DA ! , GWa0 '~~ &++c*MD>F|u$4==1,- s+ g'E'Ef'M N g';';F'C Dr0 c # # U R U R - nSn[ U R 5 H nUnXR- nXU v M g7f)zK
Generates rows (each a sequence of values) from
a single array of values.
r N)r# r~ r" r$ )rV r r stopr starts r r Writer.array_scanlinesU sH jj4;;&t{{#AE;Dt$ $ $s AAc
# ~ # SU R S: nU R U R - n[ U R U R 5 H nU H u pVn[ [ R " U R U-
[ U5 - 5 5 nXR - n US:X a Xc- n
XX- v M` [ U5 n U R USU 5 Xc- XPR - - n
US- U- n U R U- n
[ U R 5 H nXU- X2 XSU R 2' M U v M M g7f)z
Generator for interlaced scanlines from an array.
`pixels` is the full source image as a single array of values.
The generator yields each scanline of the reduced passes in turn,
each scanline being a sequence of values.
r r r r N) ru r# r~ r' r$ r< mathceilfloatr r r" )rV r r r linesr3 r r pprreduced_row_lenoffsetr
end_offsetskipr@ s r r Writer.array_scanlines_interlacec s& 4==1$%jj4;;& $DJJ . s 1AQ4s r r c 3 X ># U H n[ [ TT U- 5 5 v M! g 7fr r< r )r r3 fsr@ s r r r s& &Vos5A+;'<' SnU H nUT- U- nM
U$ )zGTake a block of (2, 4, or 8) values,
and pack them into a single byte.
r r )blockresvru s r make_byte pack_rows..make_byte s'
A(?a'C
r0 c 3 4 ># U H
nT" U5 v M g 7fr r )r r r s r r pack_rows.. s =fU %((fs N)r< r r r9 r r r r/ ) r ru spbr r r. extrablocksr s ` @r r r s
a<< x<1 a(l
C cN
#a&M !'"S(1, !s5z!" q =f=== s B/B3c # ~ # U H3 nS[ U5 - n[ [ R " U/UQ76 5 v M5 g7f)zLUnpack each row from being 16-bits per value,
to being a sequence of bytes.
!%dHN)r9 r r r )r r r s r r r s8 s3x C.#.// s ;=c [ 5 n[ 5 nU H< nUR USS 5 [ U5 S: d M( UR US 5 M> U( a X4$ US4$ )z
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.
r r7 N)r r r9 r )r= r> rA r3 s r r r s] A A
1Q q6A:
HHQqTN t d7Nr0 c U ( ae [ U5 S:w a [ S5 eUu nUS; a [ S5 eUb [ S5 eU( a [ S5 eU( a [ S5 eUS4$ U( a7 U( d0 Uu nUS ; a US4$ US
: a S nOUS :X a S
nO
US; d eS
nXQU4/4$ U( d U( a e[ [ U5 5 nUS; a Uu nUS4$ S[ U5 S
: nXQ Vs/ s H owU4PM sn4$ s snf )z#
Returns (bitdepth, rescale) pair.
r z0with palette, only a single bitdepth may be used)r r r r z,with palette, bitdepth must be 1, 2, 4, or 8Nz&transparent and palette not compatiblez alpha and palette not compatiblez$greyscale and palette not compatibler r r r ri r ri r7 r ) rn ))r )ri )r ri )r9 r: tupler max)r= ru rk rs rJ targetbitdepth depth_setr s r rp rp s6
x=A RS S < ' NO O " HI I BC C FG G~ ' 'T> ! a< N
] Ny( (( N > : ;;; ! !c(m$IM! ~ S]Q ./N BA /B BBBs 2
Dz(LA?|RGBA?);?([0-9]*))flagsc [ U5 n[ R U5 nU( d [ S5 eUR 5 u pU( a [ U5 nSU; a [
US 5 SU; :w a [ S5 eSU; US' SU; nSU; a [
US 5 U:w a [ S5 eXRS' U( a4 UR S5 ( a XBS :w a [ S XBS 4- 5 eXBS' [ UR S
5 UR S 5 UR S 5 5 u pgU( a XbS ' U( a XrS ' S U; a [ U 5 US ' [ U5 nSU; a US U:w a [ S5 e[ R " U 5 u p [ U 5 n
A U
n S U; a [ U
5 U- nXbS ' SU; a4 U R n U R S:X a SnOSU R" - n XBS' S H
n
X; a M
e [' X5 $ ! [ a [ S
5 ef = f! [$ a& SU R" - n NT! [$ a Sn Ncf = ff = f)a
Create a PNG :class:`Image` object from a 2-dimensional array.
One application of this function is easy PIL-style saving:
``png.from_array(pixels, 'L').save('foo.png')``.
Unless they are specified using the *info* parameter,
the PNG's height and width are taken from the array size.
The first axis is the height; the second axis is the
ravelled width and channel index.
The array is treated is a sequence of rows,
each row being a sequence of values (``width*channels`` in number).
So an RGB image that is 16 pixels high and 8 wide will
occupy 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.
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,
like the above example where it is a plain Python list of lists,
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'``.
z1mode string should be 'RGB' or 'L;16' or similar.rJ Lz$info['greyscale'] should match mode.Ars z info['alpha'] should match mode.ru z1bitdepth (%d) should match bitdepth of info (%d).rD r# r$ z4len(a) does not work, supply info['height'] instead.r~ z!info['planes'] should match mode.r r r )r# r$ ru rJ rs )dictRegexModeDecodematchrN groupsr< ro r: getrE r9 rG r teenextdtypekinditemsizeAttributeErrorr )r modeinfor ru rs r# r$ r~ rA r testelementr
things r r r 5 s j :D
! !$ 'E GHH\\^NDx= d [! "sd{ 3 FG Gt D 4KE$ W
% ' BC CM 88J HZ0@$@ C* -./
$Z 0$((72CTXXhEWXME W
Xt X VDN YF4 >V #;< <
== DA
q'C KdCF" W
. %%E zzS u~~-#ZF} } G >Y X VW W X0
{ 3 33!
s6 H = H$ H!$
I/I I IIIc * \ rS rSrSrS rS rS rSrg)r i zA 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.
c Xl X l g)zF
.. note ::
The constructor is not public. Please do not call it.
N)r r )rV r r s r r Image.__init__ s r0 c [ S0 U R D6n[ US5 nUR X0R 5 SSS5 g! , ( d f g= f)a Save the image to the named *file*.
See `.write()` if you already have an open file object.
In general, you can only call this method once;
after it has been called the first time the PNG image is written,
the source data will have been streamed, and
cannot be streamed again.
wbNr )r r openr r )rV filewfds r save
Image.save s=
TYY
$
GGB "
s A
Ac d [ S0 U R D6nUR XR 5 g)a
Write the image to the open file object.
See `.save()` if you have a filename.
In general, you can only call this method once;
after it has been called the first time the PNG image is written,
the source data will have been streamed, and
cannot be streamed again.
Nr )r r r r )rV r r s r r Image.write s%
TYY ii r0 )r r N) rR rY rZ r[ r` r r r r\ r r0 r r r s
# !r0 r c \ rS rSrSrS!S jrS"S jrS rS rS r S r
S#S
jr S r S r
S"S
jrS rS"S jrS rS rS rS rS rS rS rS"S jrS rS$S jrS rS r S r S r S r S r S r!g)%r i z)
Pure Python PNG decoder in pure Python.
Nc USLUSL- USL- USL- nUS:w a [ S5 eSU l SU l SU l Ub> [ U5 ( a UnO+[ U[ 5 ( a UnO[ US5 ( a UnUb [ R " U5 U l
gUb [ US5 U l
gUb X0l
g[ S5 e)aH
The constructor expects exactly one keyword argument.
If you supply a positional argument instead,
it will guess the input type.
Choose from the following keyword arguments:
filename
Name of input file (a PNG file).
file
A file-like object (object with a read() method).
bytes
``bytes`` or ``bytearray`` with PNG data.
Nr z!Reader() takes exactly 1 argumentreadrbz'expecting filename, file or bytes array)
rG r rk atchunkr4 r2 strhasattrioBytesIOr r r: )rV _guessfilenamer r keywords_supplieds r r Reader.__init__ s 4
t#
%4
! D
" ! ?@ @
v FC((!((
5)DI
! Xt,DI
I IJ Jr0 c : U R 5 U R ( d U R 5 U l U R ( d [ S5 eU R u p#SU l U R R U5 n[
U5 U:w a [ SX24- 5 eU R R S5 n[
U5 S:w a [ SU- 5 e[ R " U5 n[ R " XF5 n[ R " SU5 nXV:w ay [ R " SU5 u n[ R " SU5 u nSUR S5 UU4- n U( a [ R " U [ 5 X44$ [ U 5 eX44$ ) aQ
Read the next PNG chunk from the input file;
returns a (*type*, *data*) tuple.
*type* is the chunk's type as a byte string
(all PNG chunk types are 4 bytes long).
*data* is the chunk's data content, as a byte string.
If the optional `lenient` argument evaluates to `True`,
checksum failures will raise warnings rather than exceptions.
zNo more chunks.Nz*Chunk %s too short for required %i octets.r z Chunk %s too short for checksum.r z-Checksum error in %s chunk: 0x%08X != 0x%08X.ascii)validate_signaturer# _chunk_len_typerc r r! r9 r r r r unpackdecodewarningswarnRuntimeWarning)
rV lenientlengthr r r verifyr r messages
r r Reader.chunkN s^
! || //1DL|| ./ /|| yy~~f% t9 <~M
99>>!$ x=A ?$ FG GD!D)T6* ==x0DQ==v.DQE G$I G
g~6 z !))zr0 c # L # U R 5 u pX4v US:X a gM 7f)zRReturn an iterator that will yield each chunk as a
(*chunktype*, *content*) pair.
r N)r )rV rA r s r r
Reader.chunks} s-
::A: 6M6 WF/3fv|, Wq;; 6F"#a%3 J ;;.D "4;; /<@AQdkkAQ U R S:X a [ U5 $ U R S:X a0 [ S[ R " S[ U5 S- - U5 5 $ U R S: d eUc U R nSU R - n[ 5 nSU R - S-
n[ [ [ U5 5 5 Vs/ s H o`R U- PM nnU H) nUR U Vs/ s H oeX- - PM sn5 M+ USU $ s snf s snf )z}Convert a packed row of bytes into a row of values.
Result will be a freshly allocated object,
not shared with the argument.
r ri rJ r r Nr ) ru r r r r0 r9 r# reversedr* r" r ) rV bsr# r r maskr@ shiftsos r rK Reader._bytes_to_values s ==A R= ==B fmmFc"gl,CR HI I}}q =JJE4== k$-- !#-5d5:6F-GH-G--!#-GHA JJ8A8 9 6E{ I8s D5D
c # l # U R n[ 5 nSnU Hg nUR U5 [ U5 US- : d M( US nUSUS- nUSUS- 2 U R XgU5 nUv [ U5 US- : a M? Mi [ U5 S:w a [ S5 e[ U5 S:X d eg7f)zIterator that undoes the effect of filtering;
yields each row as a sequence of packed bytes.
Assumes input is straightlaced.
`byte_blocks` should be an iterable that yields the raw bytes
in blocks of arbitrary size.
Nr r z'Wrong size for decompressed IDAT chunk.) row_bytesr r r9 rG r^ )rV byte_blocksr" r rO
some_bytesrA rB s r _iter_straight_packed Reader._iter_straight_packed s ^^ K %J
HHZ a&BF" d Qa=hQhK ((F a&BF" & q6Q; GH H1v{{s ?B4=B40B4c U R ( a gU R R S5 U l U R [ :w a [ S5 eg)zZ
If signature (header) has not been read then read and
validate it; otherwise do nothing.
Nr z PNG file has invalid signature.)r r r! r^ rU s r r. Reader.validate_signature2 s? >> * >>Y & ?@ @ 'r0 c U R 5 U R ( d- U R 5 U l U R c [ S5 eU R S S:X a gU R US9 Mc )aN
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.
If the optional `lenient` argument evaluates to `True`,
checksum failures will raise warnings rather than exceptions.
Nz!This PNG file has no IDAT chunks.r r r5 )r. r# r/ r^
process_chunk)rV r5 s r preambleReader.preamble> si
!<< # 3 3 5 <<'%&IJJ||A') w / r0 c U R R S5 nU( d g[ U5 S:w a [ S5 e[ R
" SU5 u p#US: a [ SX24- 5 e[
[ U5 5 nU[
[ SS5 5 [
[ S S
5 5 - :: d [ S [ U5 - 5 eX#4$ ) z
Reads just enough of the input to
determine the next chunk's length and type;
return a (*length*, *type*) pair where *type* is a byte sequence.
If there are no more chunks, ``None`` is returned.
r Nz1End of file whilst reading chunk length and type.z!I4srh zChunk %s is too large: %d.A [ a { z Chunk %r has invalid Chunk Type.)
r r! r9 r^ r r0 r r r" r* )rV r3 r6 r
type_bytess r r/ Reader._chunk_len_typeU s
IINN1 q6Q; QR R }}VQ/ I :d^ KL L 4 )
c%B- 03uR~3F FF @4: MN N|r0 c U R US9u p#SUR S5 - n[ XS5 nU( a U" U5 gg)a5
Process the next chunk and its data.
This only processes the following chunk types:
``IHDR``, ``PLTE``, ``bKGD``, ``tRNS``, ``gAMA``, ``sBIT``, ``pHYs``.
All other chunk types are ignored.
If the optional `lenient` argument evaluates to `True`,
checksum failures will raise warnings rather than exceptions.
rh _process_r- N)r r1 getattr)rV r5 r r methodms r ri Reader.process_chunkl sD ZZZ0
t{{7 33 D$ '
dG
r0 c @ [ U5 S:w a [ S5 e[ R " SU5 u U l U l U l U l U l U l U l
[ U R U R 5 U R S:w a [ SU R - 5 eU R S:w a [ SU R - 5 eU R S; a [ SU R - 5 e[ U R S - 5 nU R S
- ( + n[ U R S - 5 nS U=( d U nXT- nX l
X0l X@l XPl X`l [% U R 5 [% S
5 - U- U l [) U R& 5 U R& :X a [) U R& 5 U l [) [* R, " U R U R& - 5 5 U l S U l S U l S U l g )Nr z IHDR chunk has incorrect length.r r z Unknown compression method %dzTUnknown filter method %d, see http://www.w3.org/TR/2003/REC-PNG-20031110/#9Filters .)r r z`Unknown interlace method %d, see http://www.w3.org/TR/2003/REC-PNG-20031110/#8InterlaceMethods .r r r rj r )r9 r^ r r0 r# r$ ru r| rv filterrx check_bitdepth_colortypero rt rJ rs r} r~ r r r< r r r` pltetrnssbit)rV r rt rJ rs r} r~ s r
_process_IHDRReader._process_IHDR} s t9? @A A
MM'4 (
J K M O K N ! @ q =@P@P PQ Q ;;! N++
>> ' ~~&
!+, 1,- T__q() i 384 %
"
( 4==)E!H4v=
tzz?djj ( TZZ DJ TYYtzzDJJ'> ?@ r0 c U R ( a [ R " S5 Xl [ U5 S- S:w a [ S5 e[ U5 SU R
- S- : a [ S5 e[ U5 S:X a [ S5 eg )Nz Multiple PLTE chunks present.r7 r z.PLTE chunk's length should be a multiple of 3.r zPLTE chunk is too long.zEmpty PLTE is not allowed.)r| r2 r3 r9 r^ ru rV r s r
_process_PLTEReader._process_PLTE sy 99 MM9 : t9q=A NO O t94==(A- - 78 8 t9> :; ; r0 c H U R ( aD U R ( d [ R " S5 [ R
" SU5 U l g [ R
" SU R - U5 U l g ! [ R a [ S5 ef = f)Nz)PLTE chunk is required before bKGD chunk.Br z bKGD chunk has incorrect length.)
rt r| r2 r3 r r0 rl r} errorr^ r s r
_process_bKGDReader._process_bKGD ss B}}yy MM"MN"(--T":"(--9J9J0JD"Q|| B @A A Bs AB )B B!c Xl U R ( aY U R ( d [ R " S5 g [ U5 [ U R 5 S- : a [
S5 eg U R ( a [
SU R - 5 e [ R " SU R - U5 U l g ! [ R a [
S5 ef = f)Nz)PLTE chunk is required before tRNS chunk.r7 ztRNS chunk is too long.z,tRNS chunk is not valid with colour type %d.r z tRNS chunk has incorrect length.)r} rt r| r2 r3 r9 r^ rs r| r r0 r} rk r r s r
_process_tRNSReader._process_tRNS s ==99
IJt9s499~ 11 &&?@@ 2
zz!BT__T
F#)==$:K:K1KT#R <<
F!"DEE
Fs )C C%c [ R " SU5 S S- U l g ! [ R a [ S5 ef = f)Nr r r z gAMA chunk has incorrect length.)r r0 rr r r^ r s r
_process_gAMAReader._process_gAMA sE B tT215@DJ|| B @A A Bs "% Ac Xl U R ( a [ U5 S:w d* U R ( d% [ U5 U R :w a [ S5 eg g )Nr7 z sBIT chunk has incorrect length.)r~ rt r9 r~ r^ r s r
_process_sBITReader._process_sBIT sF MMD Q==D T[[( @A A ) !r0 c Xl Sn[ U5 [ R " U5 :w a [ S5 e[ R
" X!5 u U l U l n[ U5 U l g )Nr z pHYs chunk has incorrect length.)
physr9 r calcsizer^ r0 ry rz ro r{ )rV r r units r
_process_pHYsReader._process_pHYs sT t9, , @A A?E}}S?W< 6 !$Zr0 c ^ ^^ UU 4S jnT R TS9 [ U" 5 5 mT R ( a UU 4S jnU" 5 nO T R T R T5 5 n[ 5 nSR
5 H n[ T U5 XV' M T R T R 4US' SR
5 H n[ T US5 nUc M XuU' M [ T SS5 ( a. [ T R T R T R 5 US ' T R ( a T R 5 US
' T R T R XE4$ ) a
Read the PNG file and decode it.
Returns (`width`, `height`, `rows`, `info`).
May use excessive memory.
`rows` is a sequence of rows;
each row is a sequence of values.
If the optional `lenient` argument evaluates to True,
checksum failures will raise warnings rather than exceptions.
c 3 ># TR TS9u pU S:X a gU S:w a M! TR ( a' TR ( d [ R " S5 Uv M^ 7f)z8Iterator that yields all the ``IDAT`` chunks as strings.rh r r z(PLTE chunk is required before IDAT chunkN)r rt r| r2 r3 )r r r5 rV s r iteridat Reader.read..iteridat sU !ZZZ 8
7?7? == MM"LM
s A A#rh c 3 ># [ [ R " T6 5 n STR S: nTR U 5 nTR
TR - n[ S[ U5 U5 H n[ XXDU- 5 nUv M g7f)z&Yield each row from an interlaced PNG.r r r N)
r r r ru rR r# r~ r" r9 r )rZ arraycodevaluesr r@ r rL rV s r rows_from_interlace(Reader.read..rows_from_interlace s y 45 !2 3 **2.jj4;;. q#f+s3A !#g+>?C I 4s B Bz)greyscale alpha planes bitdepth interlacerD z gamma transparent backgroundNry physicalr= )rj
decompressrx rV rc r splitru r# r$
Resolutionry rz r{ r| r= ) rV r5 r r r r attrr rL s `` @r r! Reader.read s(
g
&$ >>
'(D--d.H.H.MNDv?EEGD t,DJ H
DKK0V 288:DdD)A} T
; 4,d 3 3 )&&(>(>@R@R D 99 "llnDOzz4;;22r0 c U R 5 u pp4SUS S: n[ U[ R " U6 5 nXX44$ )a
Read a PNG file and decode it into a single array of values.
Returns (*width*, *height*, *values*, *info*).
May use excessive memory.
`values` is a single array.
The :meth:`read` method is more stream-friendly than this,
because it returns a sequence of rows.
r ru r )r! r r r )rV r3 r pixelr r s r read_flatReader.read_flat> sH !IIKej)A-. i %!89U r0 c
U R ( d [ S5 e[ [ SU R 5 S5 nU R ( d US:X aw [ SU R =( d / 5 nUR S/[
U5 [
U5 -
- 5 [ [ [ R U[ US5 5 5 nU$ )a%
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.
z6Required PLTE chunk is missing in colour type 3 image.r r7 forcer8 r ) r| r^ r/ r r} r r9 r* mapoperatoradd)rV rs r| r} s r r= Reader.paletteP s " yy VW WU3 *A. 99(diio2.D KKTSY!67 8HLL$dA?@D r0 c ^
^ ^ ^
^^ U R 5 U R ( d2 U R ( d! U R ( d U R 5 $ U R 5 u pp4U R ( a\ SUS' [ U R 5 US' SUS' S[ U R 5 - US' U R
5 m
U
4S jnU" U5 nO[U R ( aJ U R m
S US - S
-
m US m S US' US== S
-
ss' S US S: mU
U U U4S
jnU" U5 nSnU R ( a [ R " S[ U R 5 - U R 5 n[ U5 nXtS : a [ SXR 4- 5 e[ U5 S:: a [ SU- 5 eU( a US U-
mXtS' U4S jn U " U5 nXX44$ )aK
Returns the image data as a direct representation of
an ``x * y * planes`` array.
This removes 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*, *rows*, *info*)
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 *info* 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 start with ``planes=3`` and ``alpha=False`` for the
source image,
but the *info* dictionary returned by this method
will have ``planes=4`` and ``alpha=True`` because
an alpha channel is synthesized and added.
*rows* is a sequence of rows;
each row being a sequence of values
(like the :meth:`read` method).
All the other aspects of the image data are not changed.
Frt rs r ru r7 r~ c 3 ># U H7 nU Vs/ s H nTU PM
nn[ S[ R " U6 5 v M9 g s snf 7f)Nr )r r r )r r r3 r| s r iterpal Reader.asDirect..iterpal sA !C,/0Cq47CC0 Y__c%:;; "0s
AA+Ar r Tr c 3 & ># U H n[ UT5 n[ TR U5 n[ TR U5 n[ [ U5 5 n[
T[ R " [ [ R X5 6 5 v M g 7fr ) r/ r __ne____mul__r* r+ r r r r r )r r opaitr r~ r s r itertrns!Reader.asDirect..itertrns sl !C V,C bii-C fnnc2C s3x.C )//3x||S;V*WXX "s BBNr z!sBIT chunk %r exceeds bitdepth %dr zsBIT chunk %r has a 0-entryc 3 X ># U H nU Vs/ s H o"T- PM snv M g s snf 7fr r )r r r> shifts r itershift"Reader.asDirect..itershift s* !C/23s!:s33 "3s
*%*)rj rt r} r~ r! ro r= rk r r0 r9 r rN ru min)rV r3 r r r r r r r~ r r r r~ r| r r s @@@@@@r asDirectReader.asDirectj s Z
}}TYYtyy99; !YY[f == $D ODM D dii 0DN<<>D
<
V_F
YY !!B$z**Q.F(^F DM Na ND ,q 01H
Y
Y f%F 99==TYY !7CD YN Z 00 ?4 BW WXX4yA~ 9D @AA $~5E -
4 v&FV!!r0 c ^ ^
U" 5 u p4m
nSUS - S-
nSU- S-
n[ U5 [ U5 - m X%S' U U
4S jnXg:X a X4T
U4$ X4U" 5 U4$ )z2Helper used by :meth:`asRGB8` and :meth:`asRGBA8`.r ru r c
3 ~ ># T H- n U Vs/ s H n[ [ UT- 5 5 PM snv M/ g s snf 7fr r )r r3 factorr s r iterscale%Reader._as_rescale..iterscale s6 7:;s!s5V,-s;; ;s
=!8=)r ) rV r r r# r$ r r targetmaxvalr r r s @@r _as_rescaleReader._as_rescale sz '*e#vtd:&&*.(1, |$uV}4)Z < !&$. .)+t3 3r0 c : U R U R S5 $ )a
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*, *rows*, *info*).
*width*, *height*, *info* are as per the :meth:`read` method.
*rows* is the pixel data as a sequence of rows.
r )r asRGBrU s r asRGB8
Reader.asRGB8 s *
A..r0 c : U R U R S5 $ )a!
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).
r )r asRGBArU s r asRGBA8Reader.asRGBA8 s Q//r0 c ^^^ U R 5 u mnmnUS ( a [ S5 eUS ( d TUTU4$ SUS' SUS' US S: a S mOS
mUUU4S jnTX" 5 U4$ ) a
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 *info* reflect the returned pixels, not the source image.
In particular,
for this method ``info['greyscale']`` will be ``False``.
rs z0will not convert image with alpha channel to RGBrJ Fr7 r~ ru r c [ SS/5 $ )NrJ r r r r0 r newarray Reader.asRGB..newarray* s S1#&r0 c [ S/5 $ )Nr r r r0 r r r / s !~%r0 c 3 t ># T H- n T" 5 S- T- n[ S5 H
nXUS S2' M Uv M/ g 7f)Nr7 r" )r r r@ r r r# s r iterrgb Reader.asRGB..iterrgb2 s@ JNU* qA !addG " s 58)r rN )rV r$ r r r r r# s @@@r r Reader.asRGB s '+mmo#vvt =JK KK &&$. . ![X
a
'
& fgi--r0 c ^^^ U R 5 u pm nUS ( a US ( d XT U4$ SUS S: nSUS - S-
n[ R " SU- U5 S - U- mUS S: a U4S
jmOU4S jmUS ( a US ( a UU 4S jnO/US ( a UU 4S
jnO US ( d
US ( a eUU 4S jnSUS' SUS' S US' XU" 5 U4$ )af
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 *info* reflect the returned pixels, not the source image.
In particular, for this method
``info['greyscale']`` will be ``False``, and
``info['alpha']`` will be ``True``.
rs rJ r ru r r r =r c > [ ST 5 $ )NrJ r maxbuffers r r Reader.asRGBA..newarrayP s S),,r0 c > [ T 5 $ r r r s r r r U s ++r0 c 3 L ># T H n T" 5 n[ X5 Uv M g 7fr )convert_la_to_rgbar r r r s r convert Reader.asRGBA..convertZ s& !C !
A&s.G
" !$c 3 L ># T H n T" 5 n[ X5 Uv M g 7fr )convert_l_to_rgbar s r r r e s$ !C
A%c-G "r c 3 L ># T H n T" 5 n[ X5 Uv M g 7fr )convert_rgb_to_rgbar s r r r o s$ !C
A'/G "r TFr~ )r r r )
rV r# r$ r r r r r r r s
@@@r r
Reader.asRGBA; s '+mmo#vt =k!2&$. .Z(1,-d:&&*KKh7!;eC
a
-
, =T+ .
+
G}T+-> >>
W
![Xgi--r0 )rs r# rl ru r} r| rt rv r rz rr rJ r$ rx r r~ r| r r` r~ r rk r} r{ r# ry rz )NNNN)Fr )natural)"rR rY rZ r[ r` r r r rG rR rV rK rc r. rj r/ ri r r r r r r r r! r r= r r r r r r r\ r r0 r r r s 0Kd-^ 6p1f -.:
A0. ."7r
< BF*B B(A3F!$4p"d4$/.
0(.T=.r0 r c # # [ R " 5 nU H n[ UR U5 5 v M! [ UR 5 5 v g7f)z
`data_blocks` should be an iterable that
yields the compressed data (from the ``IDAT`` chunks).
This yields decompressed byte strings.
N)r
decompressobjr r r ) data_blocksdr s r r r { sH
A T*++ AGGI
s AAc U S; a [ SU - 5 eUS; a [ SU- 5 eUS- ( a U S: a [ SX4- 5 eU S: a US; a [ S X4- 5 eg
g
) z
Check that `bitdepth` and `colortype` are both valid,
and specified in a valid combination.
Returns (None) if valid, raise an Exception if not valid.
r zinvalid bit depth %drm zinvalid colour type %dr r zIndexed images (colour type %d) cannot have bitdepth > 8 (bit depth %d). See http://www.w3.org/TR/2003/REC-PNG-20031110/#table111 .)r r7 zvIllegal combination of bit depth (%d) and colour type (%d). See http://www.w3.org/TR/2003/REC-PNG-20031110/#table111 .N)r^ )ru colortypes r r{ r{ s ''08;<<'2Y>?? 1}A
J #
$
!| /
J #
$
0|r0 c h [ U 5 U :H nU=( a U S: $ ! [ [ 4 a gf = f)zA non-negative integer.Fr )r< rG
ValueError)r3
is_integers r rH rH s> Vq[
!q&
z " s 11c l Sn[ U [ U5 5 H nX nX4 nXg- S- X5' US-
nM g)zUndo sub filter.r r8 r Nr" r9 ) filter_unitrB rC rD air@ r3 r s r r= r= sD
B ;F
, K JUdN
a -r0 c \ [ [ U5 5 H nX nX$ nXV- S- X4' M g)Undo up filter.r8 Nr )r rB rC rD r@ r3 r s r r> r> s2 3v;
K KUdN r0 c U * n[ [ U5 5 H, nX nUS: a SnOX4 nX% nXgU- S- - S- X5' US-
nM. g)r r r r8 Nr ) r rB rC rD r r@ r3 r r s r r? r? s_ B
3v;
K
6A
A Kq5Q,'4/
a r0 c U * n[ [ U5 5 Hp nX nUS: a S=pxOX4 nX$ nX% n Xy- U-
n
[ X-
5 n [ X-
5 n [ X-
5 n
X:: a X:: a UnO
X:: a U nOUnXn- S- X5' US-
nMr g)zUndo Paeth filter.r r8 r N)r" r9 abs)r rB rC rD r r@ r3 r rI r r> papbpcprs r r@ r@ s B
3v;
K
6IA
A A K
EAI
Z
Z
Z
8B
XBBVtO
a' r0 c ^ [ S5 H nU SS S2 XS S2' M U SS S2 USS S2' g )Nr7 r r r r r r rD r@ s r r r s@
1X14a4yt!t qt!t9F14a4Lr0 c 6 [ S5 H
nXUSS2' M g)zv
Convert a grayscale image to RGBA.
This method assumes the alpha channel in result is
already correctly initialized.
r7 Nr r r s r r r s 1Xqt!t r0 c @ [ S5 H nXSS2 XSS2' M g)zq
Convert an RGB image to RGBA.
This method assumes the alpha channel in result is
already correctly initialized.
r7 Nr r r s r r r s' 1X4a4yt!t r0 c 6 [ R R $ )z!
A sys.stdin that returns bytes.
)sysstdinbufferr r0 r binary_stdinr s
99 r0 c [ R R n [ R S:X a@ SSKnSSKnUR
[ R R 5 UR 5 U $ )z"
A sys.stdout that accepts bytes.
win32r N) r
stdoutr platformmsvcrtossetmodefilenoO_BINARY)r r r s r
binary_stdoutr sK
ZZ
F ||w szz((*BKK8 Mr0 c : U S:X a
[ 5 $ [ U S5 $ )N-r" )r r )paths r cli_openr + s s{~ d r0 )r0 );r` __version__ collectionsr& r r r rer r
r2 r r __all__r r r! r'
namedtupler r/ r4 rB rE rL ExceptionrN r^ r: rc re r r r r r r r rp compile
IGNORECASEr r fromarrayr r r r{ rH r= r> r? r@ r r r r r r r r0 r r( s DIV
F
KKc2r2r2r2 > I&
#
#M3F
G
%
F0
6DI D
% E 2 2e eP/"!< >D0(,C` ** 4BMMJ " l`
,! ,!^a
. a
.H &
<! # 6 ! " r0