Pillow

-------------------------------

- Fixed the tobitmap() method to work properly for small bitmaps.

- Added RMS and standard deviation to the ImageStat.Stat class. Also
modified the constructor to take an optional feature mask, and also
to accept either an image or a list containing the histogram data.

- The BitmapImage code in ImageTk can now use a special bitmap
decoder, which has to be patched into Tk. See the "Tk/pilbitmap.txt"
file for details. If not installed, bitmaps are transferred to Tk as
XBM strings.

- The PhotoImage code in ImageTk now uses a Tcl command ("PyImagingPaste")
instead of a special image type. This gives somewhat better performance,
and also allows PIL to support transparency.
**WARNING: TKAPPINIT MUST BE MODIFIED**

- ImageTk now honours the alpha layer in RGBA images. Only fully
transparent pixels are made transparent (that is, the alpha layer
is treated as a mask). To treat the alpha laters as a matte, you
must paste the image on the background before handing it over to
ImageTk.

- Added McIdas reader (supports 8-bit images only).

- PIL now preloads drivers for BMP, GIF, JPEG, PPM, and TIFF. As
long as you only load and save these formats, you don't have to
wait for a full scan for drivers. To force scanning, call the
Image.init() function.

- The "seek" and "tell" methods are now always available, also for
single-frame images.

- Added optional mask argument to histogram method. The mask may
be an "1" or "L" image with the same size as the original image.
Only pixels where the mask is non-zero are included in the
histogram.

- The "paste" method now allows you to specify only the lower left
corner (a 2-tuple), instead of the full region (a 4-tuple).

- Reverted to old plugin scanning model; now scans all directory
names in the path when looking for plugins.

- Added PIXAR raster support. Only uncompressed ("dumped") RGB
images can currently be read (based on information provided
by Greg Coats).

- Added FlashPix (FPX) read support. Reads all pixel formats, but
only the highest resolution is read, and the viewing transform is
currently ignored.

- Made PNG encoding somewhat more efficient in "optimize" mode; a
bug in 0.2b4 didn't enable all predictor filters when optimized
storage were requested.

- Added Microsoft Image Composer (MIC) read support. When opened,
the first sprite in the file is loaded. You can use the seek method
to load additional sprites from the file.

- Properly reads "P" and "CMYK" PSD images.

- "pilconvert" no longer optimizes by default; use the -o option to
make the file as small as possible (at the expense of speed); use
the -q option to set the quality when compressing to JPEG.

- Fixed "crop" not to drop the palette for "P" images.

- Added and verified FLC support.

- Paste with "L" or "RGBA" alpha is now several times faster on most
platforms.

- Changed Image.new() to initialize the image to black, as described
in the handbook. To get an uninitialized image, use None as the
colour.

- Fixed the PDF encoder to produce a valid header; Acrobat no longer
complains when you load PDF images created by PIL.

- PIL only scans fully-qualified directory names in the path when
looking for plugins.
**WARNING: MAY BREAK EXISTING CODE**

- Faster implementation of "save" used when filename is given,
or when file object has "fileno" and "flush" methods.

- Don't crash in "crop" if region extends outside the source image.

- Eliminated a massive memory leak in the "save" function.

- The GIF decoder doesn't crash if the code size is set to an illegal
value. This could happen since another bug didn't handle local
palettes properly if they didn't have the same size as the
global palette (not very common).

- Added predictor support (TIFF 6.0 section 14) to the TIFF decoder.

- Fixed palette and padding problems in BMP driver. Now properly
writes "1", "L", "P" and "RGB" images.

- Fixed getpixel()/getdata() to return correct pixel values.

- Added PSD (PhotoShop) read support. Reads both uncompressed
and compressed images of most types.

- Added GIF write support (writes "uncompressed" GIF files only,
due to unresolvable licensing issues). The "gifmaker.py" script
can be used to create GIF animations.

- Reads 8-bit "L" and "P" TGA images. Also reads 16-bit "RGB"
images.

- Added FLI read support. This driver has only been tested
on a few FLI samples.

- Reads 2-bit and 4-bit PCX images.

- Added MSP read and write support. Both version 1 and 2 can be
read, but only version 1 (uncompressed) files are written.

- Fixed a bug in the FLI/FLC identification code that caused the
driver to raise an exception when parsing valid FLI/FLC files.

- Improved performance when loading file format plugins, and when
opening files.

- Added GIF animation support, via the "seek" and "tell" methods.
You can use "player.py" to play an animated GIF file.

- Removed MNG support, since the spec is changing faster than I
can change the code. I've added support for the experimental
ARG format instead. Contact me for more information on this
format.

- Added keyword options to the "save" method. The following options
are currently supported:

.. list-table::
:widths: 25 25 50
:header-rows: 1

* - Format
- Option
- Description
* - JPEG
- optimize
- Minimize output file at the expense of compression speed.
* - JPEG
- progressive
- Enable progressive output. The option value is ignored.
* - JPEG
- quality
- Set compression quality (1-100). The default value is 75.
* - JPEG
- smooth
- Smooth dithered images. Value is strength (1-100). Default is off (0).
* - PNG
- optimize
- Minimize output file at the expense of compression speed.

Expect more options in future releases. Also note that
file writers silently ignore unknown options.

- Plugged memory leaks in the PNG and TIFF decoders.

- Added PNG write support.

- (internal) RGB unpackers and converters now set the pad byte
to 255 (full opacity).

- Properly handles the "transparency" property for GIF, PNG
and XPM files.

- Added a "putalpha" method, allowing you to attach a "1" or "L"
image as the alpha layer to an "RGBA" image.

- Various improvements to the sample scripts:

.. list-table::
:widths: 25 75

* - pilconvert
- Carries out some extra tricks in order to make
the resulting file as small as possible.
* - explode
- (NEW) Split an image sequence into individual frames.
* - gifmaker
- (NEW) Convert a sequence file into a GIF animation.
Note that the GIF encoder create "uncompressed" GIF
files, so animations created by this script are
rather large (typically 2-5 times the compressed
sizes).
* - image2py
- (NEW) Convert a single image to a python module. See
comments in this script for details.
* - player
- If multiple images are given on the command line,
they are interpreted as frames in a sequence. The
script assumes that they all have the same size.
Also note that this script now can play FLI/FLC
and GIF animations.

This player can also execute embedded Python
animation applets (ARG format only).
* - viewer
- Transparent images ("P" with transparency property,
and "RGBA") are superimposed on the standard Tk background.

- Fixed colour argument to "new". For multilayer images, pass a
tuple: (Red, Green, Blue), (Red, Green, Blue, Alpha), or (Cyan,
Magenta, Yellow, Black).

- Added XPM (X pixmap) read support.

-----

- Added MNG (multi-image network graphics) read support. "Ming"
is a proposed animation standard, based on the PNG file format.

You can use the "player" sample script to display some flavours
of this format. The MNG standard is still under development,
as is this driver. More information, including sample files,
can be found at <ftp://swrinde.nde.swri.edu/pub/mng>

- Added a "verify" method to images loaded from file. This method
scans the file for errors, without actually decoding the image
data, and raises a suitable exception if it finds any problems.
Currently implemented for PNG and MNG files only.

- Added support for interlaced GIF images.

- Added PNG read support -- if linked with the ZLIB compression library,
PIL reads all kinds of PNG images, except interlaced files.

- Improved PNG identification support -- doesn't mess up on unknown
chunks, identifies all possible PNG modes, and verifies checksum
on PNG header chunks.

- Added an experimental reader for placable Windows Meta Files (WMF).
This reader is still very incomplete, but it illustrates how PIL's
drawing capabilities can be used to render vector and metafile
formats.

- Added restricted drivers for images from Image Tools (grayscale
only) and LabEye/IFUNC (common interchange modes only).

- Some minor improvements to the sample scripts provided in the
"Scripts" directory.

- The test images have been moved to the "Images" directory.

-----------------------------------------------

- Fixed filling of complex polygons. The ImageDraw "line" and
"polygon" methods also accept Path objects.

- The ImageTk "PhotoImage" object can now be constructed directly
from an image. You can also pass the object itself to Tkinter,
instead of using the "image" attribute. Finally, using "paste"
on a displayed image automatically updates the display.

- The ImageTk "BitmapImage" object allows you to create transparent
overlays from 1-bit images. You can pass the object itself to
Tkinter. The constructor takes the same arguments as the Tkinter
BitmapImage class; use the "foreground" option to set the colour
of the overlay.

- Added a "putdata" method to the Image class. This can be used to
load a 1-layer image with data from a sequence object or a string.
An optional floating point scale and offset can be used to adjust
the data to fit into the 8-bit pixel range. Also see the "getdata"
method.

- Added the EXTENT method to the Image "transform" method. This can
be used to quickly crop, stretch, shrink, or mirror a subregion
from another image.

- Adapted to Python 1.4.

- Added a project makefile for Visual C++ 4.x. This allows you to
easily build a dynamically linked version of PIL for Windows 95
and NT.

- A Tk "booster" patch for Windows is available. It gives dramatic
performance improvements for some displays. Has been tested with
Tk 4.2 only, but is likely to work with Tk 4.1 as well. See the Tk
subdirectory for details.

- You can now save 1-bit images in the XBM format. In addition, the
Image class now provides a "tobitmap" method which returns a string
containing an XBM representation of the image. Quite handy to use
with Tk.

- More conversions, including "RGB" to "1" and more.

-----

- Where earlier versions accepted lists, this version accepts arbitrary
Python sequences (including strings, in some cases). A few resource
leaks were plugged in the process.

- The Image "paste" method now allows the box to extend outside
the target image. The size of the box, the image to be pasted,
and the optional mask must still match.

- The ImageDraw module now supports filled polygons, outlined and
filled ellipses, and text. Font support is rudimentary, though.

- The Image "point" method now takes an optional mode argument,
allowing you to convert the image while translating it. Currently,
this can only be used to convert "L" or "P" images to "1" images
(creating thresholded images or "matte" masks).

- An Image "getpixel" method has been added. For single band images,
it returns the pixel value at a given position as an integer.
For n-band images, it returns an n-tuple of integers.

- An Image "getdata" method has been added. It returns a sequence
object representing the image as a 1-dimensional array. Only len()
and [] can be used with this sequence. This method returns a
reference to the existing image data, so changes in the image
will be immediately reflected in the sequence object.

- Fixed alignment problems in the Windows BMP writer.

- If converting an "RGB" image to "RGB" or "L", you can give a second
argument containing a colour conversion matrix.

- An Image "getbbox" method has been added. It returns the bounding
box of data in an image, considering the value 0 as background.

- An Image "offset" method has been added. It returns a new image
where the contents of the image have been offset the given distance
in X and/or Y direction. Data wraps between edges.

- Saves PDF images. The driver creates a binary PDF 1.1 files, using
JPEG compression for "L", "RGB", and "CMYK" images, and hex encoding
(same as for PostScript) for other formats.

- The "paste" method now accepts "1" masks. Zero means transparent,
any other pixel value means opaque. This is faster than using an
"L" transparency mask.

- Properly writes EPS files (and properly prints images to PostScript
printers as well).

- Reads 4-bit BMP files, as well as 4 and 8-bit Windows ICO and CUR
files. Cursor animations are not supported.

- Fixed alignment problems in the Sun raster loader.

- Added "draft" and "thumbnail" methods. The draft method is used
to optimize loading of JPEG and PCD files, the thumbnail method is
used to create a thumbnail representation of an image.

- Added Windows display support, via the ImageWin class (see the
handbook for details).

- Added raster conversion for EPS files. This requires GNU or Aladdin
Ghostscript, and probably works on UNIX only.

- Reads PhotoCD (PCD) images. The base resolution (768x512) can be
read from a PhotoCD file.

- Eliminated some compiler warnings. Bindings now compile cleanly in C++
mode. Note that the Imaging library itself must be compiled in C mode.

- Added "bdf2pil.py", which converts BDF fonts into images with associated
metrics. This is definitely work in progress. For info, see description
in script for details.

- Fixed a bug in the "ImageEnhance.py" module.

- Fixed a bug in the netpbm save hack in "GifImagePlugin.py"

- Fixed 90 and 270 degree rotation of rectangular images.

- Properly reads 8-bit TIFF palette-color images.

- Reads plane separated RGB and CMYK TIFF images.

- Added driver debug mode. This is enabled by setting Image.DEBUG
to a non-zero value. Try the -D option to "pilfile.py" and see what
happens.

- Don't crash on "atend" constructs in PostScript files.

- Only the Image module imports _imaging directly. Other modules
should refer to the binding module as "Image.core".

-----------------

- Modified "fromstring" and "tostring" methods to use file codecs.
Also added "fromstring" factory method to create an image directly
from data in a string.

- Added support for 32-bit floating point images (mode "F"). You
can convert between "L" and "F" images, and apply a subset of the
available image processing methods on the "F" image. You can also
read virtually any data format into a floating point image memory;
see the section on "Decoding Floating Point Data" in the handbook
for more information.

---------------

- A handbook is available (distributed separately).

- The coordinate system is changed so that (0,0) is now located
in the upper left corner. This is in compliance with ISO 12087
and 90% of all other image processing and graphics libraries.

- Modes "1" (bilevel) and "P" (palette) have been introduced. Note
that bilevel images are stored with one byte per pixel.

- The Image "crop" and "paste" methods now accepts None as the
box argument, to refer to the full image (self, that is).

- The Image "crop" method now works properly.

- The Image "point" method is now available. You can use either a
lookup table or a function taking one argument.

- The Image join function has been renamed to "merge".

- An Image "composite" function has been added. It is identical
to copy() followed by paste(mask).

- An Image "eval" function has been added. It is currently identical
to point(function); that is, only a single image can be processed.

- A set of channel operations has been added. See the "ImageChops"
module, test_chops.py, and the handbook for details.

- Added the "pilconvert" utility, which converts image files. Note
that the number of output formats are still quite restricted.

- Added the "pilfile" utility, which quickly identifies image files
(without loading them, in most cases).

- Added the "pilprint" utility, which prints image files to PostScript
printers.

- Added a rudimentary version of the "pilview" utility, which is
simple image viewer based on Tk. Only File/Exit and Image/Next
works properly.

- An interface to Tk has been added. See "Lib/ImageTk.py" and README
for details.

- An interface to Jack Jansen's Img library has been added (thanks to
Jack). This allows you to read images through the Img extensions file
format handlers. See the file "Lib/ImgExtImagePlugin.py" for details.

- PostScript printing is provided through the PSDraw module. See the
handbook for details.