<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <meta name="verify-v1" content="g222frIIxcQTrvDR3NBRUSKP3AnMNoqxOkIniCEkV7U=" />
  <link rel="meta" type="application/rdf+xml" title="ICI" href="http://imagemagick.org/ici.rdf" />
  <style type="text/css" media="screen,projection"><!--
    @import url("../www/magick.css");
  --></style>
  <link rel="shortcut icon" href="../images/wand.ico"  type="images/vnd.microsoft.icon"/>
  <title>ImageMagick: Changelog</title>
  <meta http-equiv="Content-Language" content="en-US"/>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  <meta http-equiv="Reply-to" content="magick-users@imagemagick.org"/>
  <meta name="Generator" content="PHP"/>
  <meta name="Keywords" content="changelog, ImageMagick, ImageMagic, MagickCore, MagickWand, PerlMagick, Magick++, RMagick, PythonMagick, JMagick, TclMagick, Image, Magick, Magic, Wand, ImageMagickObject, Swiss, Army, Knife, Image, Processing"/>
  <meta name="Description" content="ImageMagick® is a software suite to create, edit, and compose bitmap images. It can read, convert and write images in a variety of formats (about 100) including GIF, JPEG, JPEG-2000, PNG, PDF, PhotoCD, TIFF, and DPX. Use ImageMagick to translate, flip, mirror, rotate, scale, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.  ImageMagick is free software delivered as a ready-to-run binary distribution or as source code that you can freely use, copy, modify, and distribute. Its license is compatible with the GPL. It runs on all major operating systems.  The functionality of ImageMagick is typically utilized from the command line or you can use the features from programs written in your favorite programming language. Choose from these interfaces: MagickCore (C), MagickWand (C), ChMagick (Ch), Magick++ (C++), JMagick (Java), L-Magick (Lisp), PascalMagick (Pascal), PerlMagick (Perl), MagickWand for PHP (PHP), PythonMagick (Python), RMagick (Ruby), or TclMagick (Tcl/TK). With a language interface, use ImageMagick to modify or create images automagically and dynamically."/>
  <meta name="Rating" content="GENERAL"/>
  <meta name="Robots" content="INDEX, FOLLOW"/>
  <meta name="Generator" content="ImageMagick Studio LLC"/>
  <meta name="Author" content="ImageMagick Studio LLC"/>
  <meta name="Revisit-after" content="2 DAYS"/>
  <meta name="Resource-type" content="document"/>
  <meta name="Copyright" content="Copyright (c) 1999-2009 ImageMagick Studio LLC"/>
  <meta name="Distribution" content="Global"/>
</head>

<body id="www-imagemagick-org">
<div class="titlebar">
<a href="../index.html">
  <img src="../images/script.png" alt="[ImageMagick]"
  style="width: 350px; height: 60px; margin: 28px auto; float: left;" /></a>
<a href="http://www.networkredux.com">
  <img src="../images/networkredux.png" alt="[sponsor]"
  style="margin: 45px auto; border: 0px; float: left;" /></a>
<a href="http://www.imagemagick.org/discourse-server/">
  <img src="../images/logo.jpg" alt=""
  style="width: 114px; height: 118px; border: 0px; float: right;" /></a>
<a href="../index.html">
  <img src="../images/sprite.jpg" alt=""
  style="width: 114px; height: 118px; border: 0px; float: right;" /></a>
</div>

<div class="eastbar">

<div class="menu">
  <a href="../index.html">About ImageMagick</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a href="../www/command-line-tools.html">Command-line Tools</a>
</div>
<div class="sub">
    <a href="../www/command-line-processing.html">Processing</a>
</div>
<div class="sub">
    <a href="../www/command-line-options.html">Options</a>
</div>
<div class="sub">
    <a href="http://www.imagemagick.org/Usage/">Usage</a>
</div>
<div class="menu">
  <a href="../www/api.html">Program Interfaces</a>
</div>
<div class="sub">
    <a href="../www/magick-wand.html">MagickWand</a>
</div>
<div class="sub">
    <a href="../www/magick-core.html">MagickCore</a>
</div>
<div class="sub">
    <a href="../www/perl-magick.html">PerlMagick</a>
</div>
<div class="sub">
    <a href="../Magick++/">Magick++</a>
</div>
<div class="menu">
  <a href="../www/architecture.html">Architecture</a>
</div>
<div class="sep"></div>
<div  class="menu">
   <a href="../www/install-source.html">Install from Source</a>
</div>
<div class="sub">
    <a href="../www/install-source.html#unix">Unix</a>
</div>
<div class="sub">
    <a href="../www/install-source.html#windows">Windows</a>
 </div>
<div class="menu">
  <a href="../www/binary-releases.html">Binary Releases</a>
</div>
<div class="sub">
    <a href="../www/binary-releases.html#unix">Unix</a>
</div>
<div class="sub">
    <a href="../www/binary-releases.html#macosx">Mac OS X</a>
</div>
<div class="sub">
    <a href="../www/binary-releases.html#windows">Windows</a>
</div>
<div class="menu">
  <a href="../www/resources.html">Resources</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a href="../www/download.html">Download</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a href="http://www.imagemagick.org/script/search.php">Search</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a href="../www/sitemap.html">Site Map</a>
</div>
<div  class="sub">
    <a href="../www/links.html">Links</a>
</div>
<div class="sep"></div>
<div  class="menu">
  <a href="../www/sponsors.html">Sponsors:</a>

<div class="sponsbox">
<div  class="sponsor">
   <a href="http://www.buerodruck.de/stempel-service/index.html">Stempel bestellen</a><!-- 200910000035+ -->
</div>
<div  class="sponsor">
   <a href="http://www.goyax.de">Börse</a><!-- 201001000240 Gewiese digital-finance.de -->
</div>
<div  class="sponsor">
   <a href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012001200 allesdruck.de-->
</div>
<div  class="sponsor">
  <a href="http://www.blumenversender.com">Blumenversand</a><!-- 200911010120 -->
</div>
<div  class="sponsor">
  <a href="http://www.print24.de/">Druckerei</a><!-- 200911010480 -->
</div>
<div  class="sponsor">
  <a href="http://www.who-sells-it.com/">Free Catalogs</a><!-- 201002010000 -->
</div>
<div  class="sponsor">
  <a href="http://www.online-kredit-index.de">Kredit</a><!-- 201002010120 Buchhorn -->
</div>
</div>
</div>


</div>

<div class="main">

<ul><dt>2009-09-21  6.5.6-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Deprecate LevelImageColors(), replace with LevelColorsImage().</li><br />
<dt>2009-09-17  6.5.6-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Optimize copy composite operator.</li><br />
<dt>2009-09-15  6.5.6-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use -define jpeg:size to scale a JPEG image to the specified size.</li><br />
<dt>2009-09-13  6.5.6-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix ICON alpha mask scanline pad.</li><br />
<dt>2009-09-11  6.5.5-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Return the global maximum threads to avoid the rare cache view assertions.</li>
  <li> Throw an end-of-file exception for truncated raw gray images.</li><br />
<dt>2009-09-10  6.5.5-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Do not include last line of text in the interline spacing computation.</li><br />
<dt>2009-09-07  6.5.5-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Check that quantum_info is defined before destroying it in the PNG coder.</li>
  <li> Add -interline-spacing option to convert.</li><br />
<dt>2009-09-03  6.5.5-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support multi-page transparent Postscript and PDF.</li><br />
<dt>2009-09-01  6.5.5-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> A union is required when converting a thread ID to an unsigned long.</li><br />
<dt>2009-08-28  6.5.5-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for TIFF 3.9.1.</li><br />
<dt>2009-08-27  6.5.5-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Validate with the netscape: reference image.</li><br />
<dt>2009-08-26  6.5.5-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix memory leak for threaded PerlMagick scripts.</li><br />
<dt>2009-08-24  6.5.5-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> SVG compile error when if MAGICKCORE_CAIRO_DELEGATE is not defined.</li><br />
<dt>2009-08-23  6.5.5-1 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Bug Fix for transparency handling in Composite Variable Blur</li>
  <li> Addition of -auto-level and -auto-gamma  image enhancements    (under trial not yet final)</li>
  <li> Addition of a special -channel flag 'sync' which means that the specified    channels are to be modified together by the same amount.  The flag is    enabled by default.  This replaces the current 'channels not modified'    type handling thought IM.</li>
  <li> Modified -channel parsing to continue looking for words, after handling    any shorthand channel options.  For example:  -channel RGB,sync</li><br />
<dt>2009-08-10  6.5.5-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> identify -format %c logo.png returns the image comment as expected.</li>
  <li> Clone ImageInfo members scene and number_scenes (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=14437).</li>
  <li> Fix memory leak with the -remote option of the animate program (bug report    from Anthony).</li>
  <li> If a grayscale TIFF image has a colormap write it as a colormapped image.</li>
  <li> MVG partial opacity not set properly (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=6&t=14442).</li>
  <li> Black channel was not blurring properly (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=14473).</li><br />
<dt>2009-08-06  6.5.4-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The display program honors -loop.</li>
  <li> (ab) of Lab colorspace was not offset correctly.</li>
  <li> Scale mag/phase and real/imaginary the same for HDRI and non-HDRI builds.</li>
  <li> SVG permits multiple arc paths with an omitted 'A' (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=6&t=14377).</li>
  <li> The 'skewY' MVG attribute produced incorrect angles (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=6&t=14144).</li><br />
<dt>2009-08-02  6.5.4-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Optimize GammaImage() method.</li><br />
<dt>2009-08-02  6.5.4-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> OpenMP-enable GetSimilarityMetric().</li><br />
<dt>2009-07-30  6.5.4-7 Bernhard Rosenkraenzer &lt;bero@arkli...&gt;</dt>
  <li> Structure trans_values was renamed to trans_color. in PNG version 1.4.</li><br />
<dt>2009-07-29  6.5.4-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Replace color blending in DrawGradientImage() to use Composite Blend.    this makes Gradients handle transparency correctly!</li><br />
<dt>2009-07-28  6.5.4-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -thumbnail option no longer removes color profiles (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=14312).</li>
  <li> Do not scale real / imaginary FFT / IFT.</li>
  <li> Check for localtime() NULL return.</li>
  <li> import --help requires an X server (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=14323).</li>
  <li> Fails to load MS Windows icons with compressed PNG elements (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=14324).</li><br />
<dt>2009-07-25  6.5.4-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support the new JPEG version 7 delegate library.</li><br />
<dt>2009-07-24  6.5.4-6 Alexander E. Patrakov &lt;patrakov@gmail...&gt; </dt>
  <li> Incorrect use of setjmp in coders/png.c.</li><br />
<dt>2009-07-23  6.5.4-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> We broke -scene when we fixed the -dispose option.  Try again.</li><br />
<dt>2009-07-21  6.5.4-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Update autoconf support files.</li>
  <li> More than one -dispose setting overwrote previous settings (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=14252).</li>
  <li> Don't use JPEG's color reduction algorithm for less than 8 colors.</li><br />
<dt>2009-07-13  6.5.4-3 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Final testing and bug fixes for all mathematical compose methods    Including non-overlapping regions bugs found in in operators Divide,    ColorDodge,  VividLight.  And the handling of transparency to follow    standard 'Over' Blending in Divide.  Only math methods not looked at are    the addition methods Plus, Add, Minus, and Subtract, which do not follow    normal 'Over' alpha blending behaviour, for the purposes of mask handling.</li><br />
<dt>2009-07-12  6.5.4-3 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Addition of user diffinable 'Mathematics' compose method      -compose Mathematics -set option:compose:args A,B,C,D -composite    Will implement the formula    f(Sc,Dc) = A*Sc*Dc + B*Sc + C*Dc + D    this lets you implement most smooth polynomal compose methods.    (requested by Fred WienHaus)</li><br />
<dt>2009-07-11  6.5.4-3 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Finished the recoding of Composite methods to allow easier debugging    and faster access.</li>
  <li> Added PegtopLight compose method as an alturnative simplier Softlight    alturnative.  See notes and comparision to SoftLight in...       http://www.pegtop.net/delphi/articles/blendmodes/softlight.htm</li>
  <li> From the notes on Photoshop blend modes at       http://www.simplefilter.de/en/basics/mixmods.html    Added extra composition modes:       VividLight, PinLight, LinearBurn, LinearDodge    NOTE: 'LinearBurn' the same as 'Plus' but with the normal 'Over' blending.</li><br />
<dt>2009-07-10  6.5.4-3 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Re-coding of Composte methods HardLight, SoftLight, Overlay, LinearLight,    ColorBurn, ColorDodge, Multiply, Screen  to make it more readable, easier    to debug, and directly comparable to SVG specifications.</li>
  <li> Specifications changed for  SoftLight, ColorBurn, ColorDodge    Though only SoftLight changed to significantly.</li>
  <li> However implementation errors were found for  ColorBurn, LinearLight</li><br />
<dt>2009-07-01  6.5.4-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add -blue-shift option.</li>
  <li> Add compression flag for each channel of a PSD layer.</li>
  <li> Implement experimental forward and inverse fourier transforms (contributed    by Sean Burke and Fred Weinhaus).  The -fft / -ifft option is not ready for    prime time just yet.</li>
  <li> Support -cdl (color decision list) option.</li>
  <li> Support breaks in Chinese characters which traditionally do not include    spaces.</li>
  <li> Don't process directories as filenames when using wildcard paths    (i.e. logo[1]/png).</li><br />
<dt>2009-07-01  6.5.4-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Can't bit shift a float.</li><br />
<dt>2009-06-25  6.5.4-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Off by one error for multi-frame raw grayscale images.</li>
  <li> Can't stat() a Zip or Bzip opaque structure.</li>
  <li> DPX user bits are no longer truncated.</li>
  <li> Return image colorspace for -format [%colorspace] option.</li>
  <li> ThumbnailImage(): don't subsample if image is already thumbnail size.</li><br />
<dt>2009-06-23  6.5.4-0 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Automatic determination of B from C and C from B for a 'Keys Filter'    when using the B,C Cubic Filter Expert options was broken.    See http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=14037</li><br />
<dt>2009-06-19  6.5.4-0 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Added -compose 'Blur', variable blur mapping to CompositeImages    Arguments   X_scale x Y_scale + angle   of the blurring ellipse.</li>
  <li> Added "-blur" special compose option to "composite"</li>
  <li> Cleanup of "composite" compose argument handling</li><br />
<dt>2009-06-18  6.5.3-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Clone pixel cache when cloning image to prevent RMagick semaphore lock.</li>
  <li> Set compare similarity image to NULL to prevent double free.</li><br />
<dt>2009-06-16  6.5.3-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Set camera formats to require a seekable stream.</li>
  <li> Do not let display program image window exceed the screen size.</li><br />
<dt>2009-06-14  6.5.3-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Improve FITS keyword parser.</li><br />
<dt>2009-06-14  6.5.3-7 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Cleanup of compose 'displace' of old useless code that is not used.</li>
  <li> Implement a compose 'distort' mapping method,    This is basically exactly like 'displace' but relative to a fixed point    which may be user supplied as +X+Y</li>
  <li> Default scaling to width/2 and height/2 of overlay (100% scale)    with a distortion 'center' to the middle of the overlay image</li>
  <li> If a '%' flag given scale displacement relative to image size</li>
  <li> If a '!' flag given make scale and center relative to 'background' image     instead of the overlay map.</li>
  <li> If no 'height' scale given, use the X scale.</li><br />
<dt>2009-06-13  6.5.3-6 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fixed bug for compose methods, Hue, Saturate, Luminize</li><br />
<dt>2009-06-11  6.5.3-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Report the correct transparent pixel values in the display program    magnify windows.</li>
  <li> Do not advance when finalizing image settings in the mogrify program.</li><br />
<dt>2009-06-11  6.5.3-5 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fixed "convert" to merge the third 'mask' image into the 'source' image    for correct handling of 2 dimensional -compose "displace".</li>
  <li> Fixed PerlMagick Composite() for the same thing.</li>
  <li> Modified compose "Displace" so displacement image's alpha channel can be    used to mask the transparency of the overlay area.</li><br />
<dt>2009-06-07  6.5.3-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Added the HALD image Color LUT, and a no-op HALD: image generator.    See Introduction at  http://www.quelsolaar.com/technology/clut.html</li><br />
<dt>2009-06-07  6.5.3-4 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Changed CompositeImageChannel() so that extra compose arguments are    now passed in the ImageArtifact "compose:args". This can be assigned to    images using   -set "option:compose:args" 'args'  where args are defined    using 'geometry' style or 'comma separated numbers'.</li>
  <li> Declared the special flag needed for Composite Tiling as the ImageArtifact    "compose:outside-overlay".</li>
  <li> Documentation update for CompositeImageChannel() in Core Library to    reflect these changes.</li>
  <li> Documentation update for DistortImage() in Core Library with the extra    ImageArtifact controls it can use.</li>
  <li> Bug correction in normalization of GetOptimalKernelWidth2D() of gem.c</li><br />
<dt>2009-06-06  6.5.3-3 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Documentation update for CompositeImageChannel() in Core Library.    This adds the information on how extra compose arguments needed for    specific compose methods are actually passed to the library function.    Compose methods such as Blend, Dissolve and Displace.</li><br />
<dt>2009-06-01  6.5.3-3 Priya Hariharan &lt;priya.hariharan@globa...&gt;</dt>
  <li> The target profile in ProfileImage() is no longer accessed after it is    freed.</li><br />
<dt>2009-06-01  6.5.3-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Bug fix for -page.</li><br />
<dt>2009-05-31  6.5.3-1 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Minor change to -function Arctan to make first argument match slope</li><br />
<dt>2009-05-29  6.5.3-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Do not treat -page as a global option (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13864).</li><br />
<dt>2009-05-28  6.5.2-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Create thread set for pseudo-random number generator.</li><br />
<dt>2009-05-25  6.5.2-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Do not change opacity value for the -alpha background option.</li>
  <li> Rebuild automake / autoconf scripts.</li><br />
<dt>2009-05-23  6.5.2-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Check for XMakeImage() integer overflow vulnerability (Secunia Advisory    SA35216).</li><br />
<dt>2009-05-23  6.5.2-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Permit reading a specific frame of a multi-page TIFF with blobs.</li><br />
<dt>2009-05-22  6.5.2-8 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Added new -function methods  Arcsin  and Arctan</li><br />
<dt>2009-05-19  6.5.2-8 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Fixed a regression with PNG8: format.</li><br />
<dt>2009-05-19  6.5.2-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -geometry option was improperly applied twice.</li><br />
<dt>2009-05-18  6.5.2-6 Richard Oehlinger &lt;richard.oehlinger@celum...&gt;</dt>
  <li> Set image colorspace to YCbCrColorspace if JPEG color space is JCS_YCbCr.</li><br />
<dt>2009-05-14  6.5.2-5 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Updated help output and command-line options documentation to bring    the -alpha options up to date with what's actually in the code.</li><br />
<dt>2009-05-13  6.5.2-5 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Change "depreciated" to "deprecated" in several files.</li><br />
<dt>2009-05-10  6.5.2-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Change OpenMP schedule from dynamic to static for RenderFreeType().</li>
  <li> Recognize unicode strings when computing caption word wrapping.</li>
  <li> New -alpha background option to set fully-transparent pixels to the    background color.</li><br />
<dt>2009-05-08  6.5.2-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Combined layer of transparent PSD image was not being read properly.</li><br />
<dt>2009-05-06  6.5.2-3 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Progress on "-define png:bit-depth=value" and "-define png:color-type=value"    It is now able to write an opaque black-and-white image in any of the 15    valid combinations of PNG color-type and bit-depth.</li>
  <li> Fixed a regression with writing sub-8-bit grayscale PNGs.</li><br />
<dt>2009-05-06  6.5.2-2 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Create 8-bit TIFF images if -depth is set to 8 and HDRI-enable ImageMagick.</li><br />
<dt>2009-05-04  6.5.2-1 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Accept file lists on the command line (e.g. echo "rose: rose.png" | <dt>	  convert @- ...).</dt>
  <li> Duplicate line in tiff.c breaking read of zip compressed tif (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13688).</li>
  <li> Support policies to permit or deny any coder, delegate, filter, or file    path (see policy.xml).</li><br />
<dt>2009-05-02  6.5.2-0 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> The mogrify -crop option returns multiple images if an x/y offset is not    specified (e.g. -crop 100x100).</li>
  <li> Generate a proper file path for -path @filelist.txt (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13671).</li><br />
<dt>2009-05-01  6.5.2-0 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Accept "-define png:bit-depth=value" and "-define png:color-type=value"    options.  This is work-in-progress with the objective of being able to    precisely specify the type of PNG file to be written.  The previously-used    internal attribute "png:bit-depth" that was used to communicate between    the PNG writer and the JNG writer is changed to "png:bit-depth-written".    This feature needs testing.  It is important to note that this feature    cannot be used to force the PNG to use a bit-depth or color-type that    does not losslessly represent the image.  You can, however, cause    the writer to use a larger depth or to use the RGB colorspace when    grayscale or indexed would have been sufficent.</li><br />
<dt>2009-05-01  6.5.1-10 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fixed the Rmin usage in Depolar and Polar distortions</li>
  <li> The 6th argument (Ato) for Polar/Depolar is now optional and defaults    to Afrom + 360 degrees (or a fill circle from the given start angle)</li><br />
<dt>2009-04-30  6.5.1-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Do not return a black image for -channel RGBA -gaussian (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13669).</li><br />
<dt>2009-04-28  6.5.1-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix 'conflicting types for Huffman2DEncodeImage' compile exception.</li><br />
<dt>2009-04-25  6.5.1-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Generate BMP 32-bit ARGB format for images with transparency (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13633).</li><br />
<dt>2009-04-24  6.5.1-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Grok 'image.psd[0]' and 'image.mpg[0]' (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13609).</li>
  <li> Normalize similarity based on reconstruction not the original (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13626).</li>
  <li> Support multiple JPEG images encapsulated within DICOM.</li><br />
<dt>2009-04-23  6.5.1-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Msys does not understand NAME_MAX.</li><br />
<dt>2009-04-22  6.5.1-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Check for valid linked list before assigning next / previous pointers.</li><br />
<dt>2009-04-21  6.5.1-4 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Check error return from CompressColormapTransFirst() in coders/png.c</li><br />
<dt>2009-04-21  6.5.1-4 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Refrain from modifying image struct members (color, depth, matte)    while writing PNG datastreams.</li><br />
<dt>2009-04-21  6.5.1-4 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Sometimes the PNG8: format would produce 1-, 2-, or 4-bit PNG datastreams.    Now it always produces 8-bit datastreams as users probably expect.</li><br />
<dt>2009-04-21  6.5.1-4 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Suppressed "shadowed declaration" warnings in coders/jpeg.c and    coders/png.c that are triggered by "-Wshadow" gcc compiler flag.</li><br />
<dt>2009-04-17  6.5.1-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The display program now returns a 0 exit code on success (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13579).</li><br />
<dt>2009-04-14  6.5.1-3 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Folded some long lines and made other cosmetic changes.in coders/png.c</li><br />
<dt>2009-04-13  6.5.1-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> MVG autodetection failing (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13542).</li><br />
<dt>2009-04-11  6.5.1-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Image not properly placed when displaying to the X server root (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13532).</li>
  <li> fmax() is not support on some platforms (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13533).</li><br />
<dt>2009-04-11  6.5.1-2 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Rename existing "Bilinear" distortion as  "BilinearReverse"</li>
  <li> Added forward mapped bilinear distort as  "BilinearForward"</li>
  <li> The "Bilinear" distort is temporarily obsoleted but will eventually    be added as a  "BilinearReverse" and "BilinearForward" combination    mapping though a unit square.</li>
  <li> Sparse Gradient internally uses "BilinearReverse" for its "Bilinear"    gradient function as that method is the direct use of such equations.</li><br />
<dt>2009-04-01  6.5.1-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Default to min-is-white Photometric for fax / group4 compression (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13468).</li>
  <li> Respect image resolution when setting PDF MediaBox (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13350).</li>
  <li> Add SimilarityImage() to return how similar one image is to another.</li><br />
<dt>2009-03-28  6.5.1-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Graceful exit in djvu coder when EOF is thrown.</li>
  <li> Support -unsharp option for the montage program. </li><br />
<dt>2009-03-28  6.5.0-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Reduce deskew blurring: use AffineTransformImage() rather than    RotateImage().</li>
  <li> Unexpected end-of-file @ xwd.c/ReadXWDImage/252 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13430).</li><br />
<dt>2009-03-26  6.5.0-10 Markus Dahms &lt;markus.dahms@progr...&gt;</dt>
  <li> Support for -density & -units options in PSD writer.</li><br />
<dt>2009-03-26  6.5.0-10 Samuel Thibault  &lt;samuel.thibault@ens-l...&gt;</dt>
  <li> Fix bug in the braille coder which makes it always segfault.</li><br />
<dt>2009-03-25  6.5.0-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Enhance the compare program to locate a template image within a larger    image.</li>
  <li> Eliminate assertion when generating a PDF thumbnail.</li><br />
<dt>2009-03-25  6.5.0-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix assertion in IntegralRotateImage (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13410).</li><br />
<dt>2009-03-24  6.5.0-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Referenced counted blob was incremented incorrectedly in CloneImage().</li><br />
    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13410).<dt>2009-03-23  6.5.0-6 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Assertion failure reading PSD image (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13397).</li><br />
<dt>2009-03-21  6.5.0-5 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Change -selective-blur to use gaussian kernel.</li><br />
<dt>2009-03-21  6.5.0-4 ERB  &lt;entropy@xebec...&gt;</dt>
  <li> Missing locks in blob - race condition (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13385).</li><br />
<dt>2009-03-19  6.5.0-3 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Use default SVG resolution unless resolution is explicitly set (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13373).</li>
  <li> Add support for -selective-blur option.</li><br />
<dt>2009-03-19  6.5.0-3 ragesteel  &lt;iimagemagic-org-iapied0o@gt2.r...&gt;</dt>
  <li> ImageToBlob() no longer faults if Jasper compression is wrong (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13372).</li><br />
<dt>2009-03-19  6.5.0-3 ERB  &lt;entropy@xebec...&gt;</dt>
  <li> Check the 8BIM profile resource block length (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13368).</li>
  <li> Unlocked read in DeleteNodeByValueFromSplayTree (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13370).</li><br />
<dt>2009-03-18  6.5.0-2 ERB  &lt;entropy@xebec...&gt;</dt>
  <li> Eliminate race condition when acquiring a wand (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13357).</li>
  <li> Use of "localtime" in FormatMagickTime not thread-safe (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13358).</li><br />
<dt>2009-03-18  6.5.0-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix the image compose operator at OverCompositeOP for shadows (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13330).</li><br />
<dt>2009-03-14  6.5.0-1 Paul Smedley  &lt;paul@smedl...&gt;</dt>
  <li> Patches to get ImageMagick working under OS2.</li><br />
<dt>2009-03-10  6.5.0-1 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Expansion of Virtual-Pixel (Cache) handling, to include corrected Mirror,    plus addition of  CheckerTile, HorizontalTileEdge and VerticalTileEdge</li><br />
<dt>2009-03-10  6.5.0-0 John Cupitt  &lt;jcupitt@gmail...&gt;,</dt>
  <li>                    Glenn Randers-Pehrson <glennrp@image...></li>
  <li> DICOM reader not handling signed pixels properly.</li><br />
<dt>2009-03-09  6.4.9-10 Alexander E. Patrakov &lt;patrakov@gmail...&gt; </dt>
  <li> Don't call GetValueFromSplayTree() if image properties is NULL.</li><br />
<dt>2009-03-09  6.4.9-10 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fix minor size issue with bestfit +distort operation.</li>
  <li> Enable listing of -distort Polynomial</li>
  <li> Minor tweeks and center fixes for Polar/Depolar</li><br />
<dt>2009-03-01  6.4.9-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Convert returns MagickFalse for the -version option (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=13230).</li>
  <li> Don't set pixel opacity unless the image alpha channel is active (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13189).</li><br />
<dt>2009-02-27  6.4.9-8 Anthony Thyssen &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fix old -clut bug for re-coloring gray images using transparent and    semi-transparent colors.</li><br />
<dt>2009-02-22  6.4.9-7 Rick Mabry  &lt;rick.mabry@anony...&gt;</dt>
  <li> Changes have been made to scores of the files that generate the    documentation. The most noticeable cosmetic changes are to the command-line    examples and command-line snippets, which now have a new look: dark blue    boxes with white/yellow text to indicate sample input/output.  Inclusion of    current version and release dates in appropriate places are now    automatically generated. Also, many changes have been made to begin to    bring the pages into strict W3C compliance with respect to both HTML and    CSS.</li><br />
<dt>2009-02-21  6.4.9-7 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> The identify program reads the image pixels when the -format option is    asking for image statistics.</li>
  <li> Much improved ImageMagick validation suite (exercise with 'make check').</li><br />
<dt>2009-02-18  6.4.9-5 Jon  &lt;jon@brick...&gt;</dt>
  <li> Processing the arg list -tile is replaced by -sans0 which is 1 char longer    and which overwrites the allocated area.</li><br />
<dt>2009-02-16  6.4.9-5 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Add section to license to alert users to third-party licenses in the    NOTICE file.</li><br />
<dt>2009-02-11  6.4.9-3 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Replaced geometry string parsing using ParseGravityGeometry() in    "composite" with more direct use of GravityAdjustGeometry();</li><br />
<dt>2009-02-10  6.4.9-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support file descriptors (e.g. convert image.jpg fd:3 ...).</li>
  <li> The stream utility no longer go into an infinite loop (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=13102).</li><br />
<dt>2009-02-04  6.4.9-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> JPEG to PDF was not always reversible (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13020).</li><br />
<dt>2009-01-30  6.4.9-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Stroking when annotating failed for stroks widths > 2 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=13009).</li><br />
<dt>2009-01-24  6.4.8-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> TransformImageColorspace() returns GRAYColorspace when set (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12990).</li>
  <li> Don;t assume CMYK unless document process colors include Cyan, Magenta,    or Yellow.</li><br />
<dt>2009-01-23  6.4.8-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Increase random angle range for +polaroid from -7..7 to -15..15 degrees.</li><br />
<dt>2009-01-22  6.4.8-8 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Fixed a -evaluate AddModulus 'patch' for correct 'negative' handling</li><br />
<dt>2009-01-20  6.4.8-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Removed previous patches for -shear directions.</li><br />
<dt>2009-01-20  6.4.8-8 Thomas Stegemann  &lt;Thomas.Stegemann@mater...&gt;</dt>
  <li> SVG with resolutions other than 72.0 dpi, text is no longer transformed    twice.</li><br />
<dt>2009-01-20  6.4.8-8 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Renamed -evaluate methods 'sin' and 'cos' to math C math library names</li>
  <li> Added  "-function polynomial  a,b,c,...."   Eg:  a*x^2 + b*x + c</li>
  <li> Added  "-function sinusoid freq,phase,amplitude,bias  (all optional)</li><br />
<dt>2009-01-18  6.4.8-7 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Removed "annotate" patches, which causes no end of problems.    Original coding worked perfectly fine.  Annotate isn't part of SVG!</li><br />
<dt>2009-01-18  6.4.8-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Respect mouse wheel movements for display program (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=12938).</li>
  <li> Grab button in Display Open menu now works consistently (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12942).</li>
  <li> Patch for problem with opacity in MVG (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12946).</li><br />
<dt>2009-01-14  6.4.8-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Don't accept discontinuous shear angles for the -annotate option.    -- REMOVED</li><br />
<dt>2009-01-14  6.4.8-6 Mark Freeman &lt;mark.freeman@porci...&gt;</dt>
  <li> Apply patch so ImageMagick compiles with Visual Studio 6.</li><br />
<dt>2009-01-12  6.4.8-5 Alexander E. Patrakov &lt;patrakov@gmail...&gt; </dt>
  <li> Fix small memory leak on truncated PNG images.</li>
  <li> Do not allocate pixels when pinging a PNG image.</li><br />
<dt>2009-01-11  6.4.8-6 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Set the stroke opacity for "opacity" SVG element (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10594).</li><br />
<dt>2009-01-10  6.4.8-5 Matthew Litwin &lt;mlitwin@sonic...&gt;</dt>
  <li> Convert to windows .ico format no longer inverts alpha channel.</li><br />
<dt>2009-01-10  6.4.8-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Interpret geometry correctly for negative angles (-shear 30x-10).</li><br />
<dt>2009-01-08  6.4.8-4 Eberhard Mattes  &lt;eberhard.mattes@web.d...&gt;</dt>
  <li> Fix GetMagickToken() to accept locales that use "," as radix character.</li><br />
<dt>2009-01-08  6.4.8-4 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Add (and Fix) -evaluate methods   Sine, Cosine, AddModulus</li><br />
<dt>2009-01-05  6.4.8-4 Rick Mabry  &lt;rick.mabry@anony...&gt;</dt>
  <li> Check for negative offsets (bevel widths) for the -frame option.</li><br />
<dt>2009-01-04  6.4.8-4 Alexander E. Patrakov &lt;patrakov@gmail...&gt; </dt>
  <li> Patch for a memory leak and a logical bug in coders/gif.c.</li>
  <li> CopyMagickString() now returns the minimum of the source string length    or the length parameter.</li>
  <li> Properly set alpha channel in PNGs with palette and tRNS.</li><br />
<dt>2009-01-01  6.4.8-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support %[] embedded filename tag (e.g. convert rose: -set area "%wx%h"<dt>	  'rose-%[area].png').</dt>
  <li> Do not set the fill element when 'opacity' is set (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10594).</li>
  <li> Restore support for decoding the DVI format.</li>
  <li> Add perl and math lib reference to PerlMagick Makefile (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12840).</li>
  <li> Fix crash on invalid JPEG XML profile.</li>
  <li> Export libtool symbols in MagickCore.sym and MagickWand.sym.</li>
  <li> Support sine and cosine as arguments to the -evaluate option.</li><br />
<dt>2008-12-31  6.4.8-4 Amartyo Banerjee" &lt;amartyo@gmail...&gt;</dt>
  <li> Calculate the kurtosis and skewness of image channels (reference    http://amartyosscrapbook.blogspot.com/2008/12/formulas-used-to-calculate-kurtosis-and.html).</li><br />
<dt>2008-12-28  6.4.8-4 Rick Mabry  &lt;rick.mabry@anony...&gt;</dt>
  <li> Patch magick/display.c and PerlMagick/ContrastStretchImage() to return the    same results as the -contrast-stretch option.</li>
  <li> ContrastStretchImageChannel() no longer interpretted as Contast() by    MogrifyRegion() in PerlMagick.</li><br />
<dt>2008-12-28  6.4.8-3 Rick Mabry  &lt;rick.mabry@anony...&gt;</dt>
  <li> Reverse argument and option in Throw*InvalidArgumentException()    macro for proper exception message.</li>
  <li> Recognize negative geometries for -shear and -annotate (.e.g. 45x-30).</li>
  <li> Fix Y shear angle for -shear option.</li><br />
<dt>2008-12-26  6.4.8-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use GetImageArtifact() to retrieve -attentuate option value for +noise.</li>
  <li> Support reading FITS test files (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12799).</li>
  <li> Replace input.ttf with the public domain Tuffy.ttf font.</li>
  <li> MagickNewImage() no longer faults when parameters are incorrect (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12817).</li>
  <li> Allocate strings returned by XGetResourceInstance() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12818).</li>
  <li> The -append gravity is relative to the container (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=12821).</li><br />
<dt>2008-12-19  6.4.8-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Reference cache rather than acquiring when cloning an image.</li><br />
<dt>2008-12-19  6.4.8-0 Cashish Kulkarni &lt;ashkulz@redif...&gt;</dt>
  <li> Cross-compilation failure using MinGW on Linux for ImageMagick trunk</li><br />
<dt>2008-12-19  6.4.8-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add -interword-spacing option to convert.</li>
  <li> Initialize the black channel when testing the CMY colorspace (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12685).</li>
  <li> remove calls to exit() in MagickWand (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=12772).</li>
  <li> Validate -affine arguments.</li>
  <li> Accept -attentuate as an option for convert.</li>
  <li> Properly create RGBA image if colormapped image has transparency.</li>
  <li> Support X11 geometry like this: +-4+-4;  wierd but X11 supports it.</li><br />
<dt>2008-12-17  6.4.7-10 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Fix off-by-one problem with -shear.</li>
  <li> Clone pixel cache method when cloning an image.</li><br />
<dt>2008-12-16  6.4.7-9 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Make "-layers Coalesce" work as it should.</li><br />
<dt>2008-12-16  6.4.7-9 Sam Fisher &lt;fisher@image...?</dt>
  <li> Support > 2GB TIFF under Windows.</li><br />
<dt>2008-12-12  6.4.7-8 mootools &lt;help@mooto...&gt;</dt>
  <li> FormatMagickTime() checks to ensure the provided time is valid.</li><br />
<dt>2008-12-12  6.4.7-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add -kerning option to convert.</li>
  <li> Remove halo effect for the -scale option.</li><br />
<dt>2008-12-11  6.4.7-7 Alan Wright  &lt;alanwright.atex@google...&gt;</dt>
  <li> Fix a 1 byte overrun in Postscript coder.</li><br />
<dt>2008-12-10  6.4.7-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix small memory leak in ExpandFilenames().</li><br />
<dt>2008-12-09  6.4.7-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix small memory leak in LoadLocaleList().</li>
  <li> Fix small memory leak in GetProfilesFromResourceBlock().</li>
  <li> Don't forget to scale grayscale values when quanum min-is-white is set.</li><br />
<dt>2008-12-08  6.4.7-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Include delegate libraries in MagickCore-config script.</li><br />
<dt>2008-12-07  6.4.7-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix off-by-one error for -chop 0x50%.</li>
  <li> Performance improvement bilinear interpolation.</li><br />
<dt>2008-12-06  6.4.7-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support absolute paths in the include directive within a configuration    file.</li><br />
<dt>2008-12-05  6.4.7-1 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Assume Log colorspace if DPX transfer is LogarithmicColorimetric.</li>
  <li> Another attempt at properly extracting the IPTC profile from a 8BIM    resource block.</li><br />
<dt>2008-12-04  6.4.7-1 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> AppendImage() re-written to respect gravity properly!    Routine simplified to a single loop for both styles of append</li><br />
<dt>2008-12-03  6.4.6-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> AppendImage() respects gravity.</li>
  <li> Protect against circular image list when cropping.</li>
  <li> The index variable must be long rather than unsigned long for the DCM<dt>	  coder.</dt>
  <li><dt>2008-12-02  6.4.6-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use ScaleQuantumToMap() to prevent fault in SetGrayscaleImage() when    quantum depth is 32.</li><br />
<dt>2008-12-01  6.4.6-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Global replaced accidently renamed MagickGetImagePixelColor().</li><br />
<dt>2008-11-29  6.4.6-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed transient bug in the -white-threshold option.</li>
  <li> -extent x256+100+100 no longer returns an exception (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=7&t=12583).</li><br />
<dt>2008-11-27  6.4.6-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> TIFF pad is relative to bits-per-sample (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=12563).</li><br />
<dt>2008-11-27  6.4.6-5 Koshiji Masayuki  &lt;kosiji.masayuki@da.mi...&gt;</dt>
  <li> Support GBR raw image files.</li><br />
<dt>2008-11-26  6.4.6-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> DPX 10 bit YUV 4:2:2 are now processed properly (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=12443).</li>
  <li> Default PDF compression to that of the image unless overwritten by    the -compress option.</li><br />
<dt>2008-11-25  6.4.6-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Numerous pixel cache improvements including embeded support for    OpenMP in a transparent manner.</li><br />
<dt>2008-11-20  6.4.6-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Transient bug in encipher / decipher operation (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12540).</li><br />
<dt>2008-11-14  6.4.6-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> MPC image files working again.</li>
  <li> coders/wmf.c/lite_font_stringwidth() returns string width (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12528).</li><br />
<dt>2008-11-10  6.4.6-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix temporary file leak.</li><br />
<dt>2008-11-18  6.4.5-9 Koshiji Masayuki  &lt;kosiji.masayuki@da.mi...&gt;</dt>
  <li> Fix bug for RGBO image @ line, plane and partition interlace.</li><br />
<dt>2008-11-18  6.4.5-9 Chris Madison  &lt;madisonblu@gmail...&gt;</dt>
  <li> Deprecate pixel methods: AcquireImagePixels(), GetImagePixels(), etc.</li>
  <li> New pixel methods: GetVirtualPixels(), GetAuthenticPixels(), etc.</li><br />
<dt>2008-11-15  6.4.5-7 Alexander E. Patrakov &lt;patrakov@gmail...&gt; </dt>
  <li> GPS and multivalued EXIF properties support</li><br />
<dt>2008-11-14  6.4.5-6 Manish Aggarwal &lt;manish@circu...&gt;</dt>
  <li> Add TransparentPaintImageChroma() to MagickCore and transparentChroma()    to Magick++.</li><br />
<dt>2008-11-10  6.4.5-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Correct DPX frame position property label (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12440).</li>
  <li> Textures are no longer painted as the background color.</li>
  <li> Update both fields of an EXIF resolution.</li>
  <li> Support query-font-metrics MSL tag.</li><br />
<dt>2008-11-01  6.4.5-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Do not set image colorspace for the MSL modulate tag.</li><br />
<dt>2008-11-01  6.4.5-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Off by one error when computing affine in DrawAffineImage() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12391.</li><br />
<dt>2008-10-30  6.4.5-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed local adaptive thresholding  when using an offset (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12371.</li>
  <li> Set SetImagePixels() rather than SyncImagePixelCache() to update    the pixel cache morphology.</li><br />
<dt>2008-10-26  6.4.5-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Set explicit image format for BlobToImage() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=12340).</li>
  <li> p_thread_t is an aggregate under MinGW.</li><br />
<dt>2008-10-20  6.4.5-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> pthread_t can be aggregate so stop treating it like its atomic.</li>
  <li> default the WPG image size to 1 top avoid "no pixels defined in cache"    exceptions.</li><br />
<dt>2008-10-17  6.4.4-8 Anthony  &lt;A.Thyssen@griffith...&gt;</dt>
  <li> slight modification of the added "radial-gradient:" image generator    so the radius goes to an edge rather than the corner, allowing more user    control based on image size.</li>
  <li> fix -raise N to mean -raise NxN</li><br />
<dt>2008-10-15  6.4.4-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for inline images.</li><br />
<dt>2008-10-10  6.4.4-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> MinGW supports both Posix threads and Windows critical sections.</li><br />
<dt>2008-10-06  6.4.4-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> pthread_self() can be an aggregate value.</li>
  <li> Scale pixel quantum to match PNG tRNS range (i.e. 0-255).</li><br />
<dt>2008-10-06  6.4.4-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Set sentinel byte for MVG coder.</li>
  <li> fx:standard_deviation returns standard deviation now instead of mean.</li><br />
<dt>2008-10-01  6.4.4-1 Florent Monnier  &lt;monnier.florent@gmail...&gt;</dt>
  <li> Support radial gradients in DrawGradientImage().</li><br />
<dt>2008-09-26  6.4.4-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix memory leak when XMP profile is corrupt.</li>
  <li> Support filename references (e.g. convert image-%d.jpg[1-5] ...).</li><br />
<dt>2008-09-25  6.4.4-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use -remap rather than -affinity.</li>
  <li> Don't unregister a module for an image coder signature exception.</li>
  <li> Don't assume a monochrome image is colormapped.</li><br />
<dt>2008-09-25  6.4.4-0 Anthony &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Attempt to fix three image "composite -displace" while also allowing use    of seperate X, Y grayscale displacement maps, or a merged X=red Y=green    (later transparency mask will also be added) as discussed in IM Examples,    'distortion maps', but for -displace.</li><br />
<dt>2008-09-24  6.4.3-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix pixel cache race condition.</li><br />
<dt>2008-09-23  6.4.3-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed an OTB coder bug (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12119).</li><br />
<dt>2008-09-23  6.4.3-8 Peter Fales &lt;psfales@alcat...&gt;</dt>
  <li> Add NULL terminator to options list to in MontageImageCommand().</li><br />
<dt>2008-09-23  6.4.3-8 Anthony &lt;A.Thyssen@griffith...&gt;</dt>
  <li> Added -layers TrimBounds  which will adjust the offsets and canvas bounds    to fit the current sequence of layered/animated images. The images    themselves are not modified only the 'page' meta-data.  As a side-effect    all offsets will become positive, with a minimal canvas width/height.</li><br />
<dt>2008-09-22  6.4.3-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Define _FILE_OFFSET_BITS from MAGICKCORE_FILE_OFFSET_BITS.</li><br />
<dt>2008-09-10  6.4.3-7 Anthony &lt;A.Thyssen@griffith...&gt;</dt>
  <li> String Memory leak from InterpretImageProperties() in "annotate"    for Command line handling in mogrify.c</li>
  <li> Allow percent escapes in both -sparse-color and -distort argument strings.</li>
  <li> Fix -alpha to allow Set, Copy, and Extract from command line</li>
  <li> Fix -alpha Set so it only clears the alpha when it was previously off</li>
  <li> Changed 'AllChannels' to be just the 'real' channels (including K).</li>
  <li> Special handling if  +level-colors is given one color, and no seperator.</li>
  <li> Fix 'matte' flag in DisposeImages() (for -layer dispose)</li><br />
<dt>2008-09-01  6.4.3-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix -interpolate / -compose settings.</li>
  <li> No need to specify -endian for native floating point format.</li>
  <li> Remove small memory leak when cloning image properties (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11981).</li>
  <li> The scan delegate requires a device name, not a symbolic link.</li>
  <li> Report alpha instead of opacity for the TXT image format (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12002).</li>
  <li> Add channel support to -motion-blur.</li>
  <li> Set the SVG affine matrix *before* we compute the scale (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12030).</li>
  <li> Rely on 'omp critical' in the rare case where OpenMP is enabled but    ImageMagick distribution is built without thread support.</li>
  <li> Return the correct number of unique colors for colormapped image (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12055).</li>
  <li> SVG depends on MagickWand for parallel make (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=12099).</li><br />
<dt>2008-09-02 6.4.3-7</dt>
  <li> Addition of 'BarrelInverse' Distortion</li><br />
<dt>2008-08-27  6.4.3-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Extract / embed namespace for JPEG XMP profiles (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11832).</li>
  <li> Deprecate -map and replace with -affinity which supports dither methods.</li>
  <li> Set image depth when -depth is fired.</li>
  <li> Fix small memory leak in TIFF coder (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11968).</li><br />
<dt>2008-08-24  6.4.3-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Parallelize the colorspace transforms.</li>
  <li> Honor gravity for -extent option (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11944).</li><br />
<dt>2008-08-22  6.4.3-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed a memory leak in the TransparentPaintImage() method.</li><br />
<dt>2008-08-20  6.4.3-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Treat -compose as a setting.</li>
  <li> Check for depth == 0 in GetQuantumScale() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11921).</li>
  <li> Fix CIN coder scanline length (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11922).</li><br />
<dt>2008-08-20  6.4.3-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add $(MAGICKWAND_LIBS) dependency to the PerlMagick Makefile (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11908).</li>
  <li> Fix configure script to configure the JBIG delegate library (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11907).</li>
  <li> Error in indexed PNG output if number of colors &lt;= 16 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11905).</li><br />
<dt>2008-08-18  6.4.3-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Always reinterpret %[fx:] properties.</li>
  <li> Composite based on the composite image compose operator.</li><br />
<dt>2008-08-14  6.4.2-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add --coder-path and --filter-path options to MagickCore-config to    support the Magick Coder and Image Filter kits.</li><br />
<dt>2008-08-17  6.4.2-9 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> -sparse-color option completed with inital set of methods.</li>
  <li> -distort Barrel arguments expanded.</li><br />
<dt>2008-08-14  6.4.2-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -draw option no longer returns an error when for # like .6 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11879).</li><br />
<dt>2008-08-14  6.4.2-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> New dithering selection option, -dither Floyd-Steinberg or    -dither Riemersma.</li><br />
<dt>2008-08-10  6.4.2-8 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added new distort "Polar" and "DePolar" due to Forum Discussions</li><br />
<dt>2008-08-07  6.4.2-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Change MPEG delegate from mpeg2decode/mpeg2encode to ffmpeg (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11827).</li>
  <li> Extract embedded XMP and EXIF profiles froma Photoshop resource block.</li>
  <li> Support -compose option in the compare program.</li><br />
<dt>2008-08-04  6.4.2-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support -fx scientific-notation (e.g. '2.0*3.81469e-06').</li>
  <li> Substitute DistortImage() with 'AffineProjectionDistortion' for    the older DrawAffineImage() in AffineTransformImage().</li>
  <li> Apply Sam Hocevar's patch to replace  Hilbert-Peano curve dithering with    Floyd Steinberg.</li>
  <li> Added -virtual-pixel method VerticalTile as a complement to HorizontalTile</li><br />
<dt>2008-08-02  6.4.2-6 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added -virtual-pixel method HorizontalTile suitable for generating 360    degree Arcs and Polar Distorts.</li><br />
<dt>2008-07-31  6.4.2-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Patch -fx to properly recognize maxima and minima.</li>
  <li> Add channel specifier to -fx depth, mean, maxima, minima, and    standard_deviation (e.g. depth.r).</li>
  <li> Properly append .magick to the USERPROFILES path (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11806).</li><br />
<dt>2008-07-30  6.4.2-6 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added a  "-set option:distort:scale"  which scales the output 'view'    by the amount given.  This is directly useful for doing 'super-sampled'    distorts, just set this, the scale the result back to a normal size.</li><br />
<dt>2008-07-27  6.4.2-5 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Rewrite on coefficent handlig for DistortImages so allow for generation    by other operators (SparseColor), and addition of verbose output of    equivelent -fx functions for DistortImages to report of the internal    coefficents that was calculated, and who they are used.</li>
  <li> Initial implementation of SparseColor for interpolated gradients from    sparsely seperated points of color (or posibily other forms of arguments)</li>
  <li> New distortion Barrel as defined by Helmut Dersch options A,B,C,D    on his web page  http://www.all-in-one.ee/~dersch/barrel/barrel.html    And as developed by Fred WeinHaus in his PinBarrel script</li><br />
<dt>2008-07-20  6.4.2-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Certain corrupt GIF images no longer hang (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11723).</li>
  <li> Read more than one image (if they exist) from DJVU image files.</li>
  <li> Don't set image depth in histogram coder (references    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11752).</li><br />
<dt>2008-07-17  6.4.2-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed cache nexus threading problem to avoid spurious assertions when    calling the DistortImage() method.</li><br />
<dt>2008-07-17  6.4.2-4 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> New distortion  Shepards which provide semi-localized distorts of control    points within an image, as first developed for IM by Frew Weinhaus in his    ShapeMorph script.   http://www.fmwconcepts.com/imagemagick/shapemorph/    It's almost like taffy pulling!</li><br />
<dt>2008-07-12  6.4.2-2 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Separate coefficient calculation from DistortImages (future development)</li>
  <li> Perspective and Bilinear Distortions fallback to Affine    when less than 4 point pairs are provided.</li>
  <li> Affine Distortion now handles 2 point pairs (SRT of a single line)    and a simple translation if only a single point pair is provided.</li>
  <li> Added 'verbose' output of some of the distortion equations generated</li>
  <li> Initial addition of polynomal distortion (incomplete - not working yet)</li><br />
<dt>2008-06-29  6.4.2-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add log2 and round as -fx operators.</li>
  <li> Add log and round as -evaluate operator.</li>
  <li> Add -deskew option to straighten an image.</li><br />
<dt>2008-06-22  6.4.2-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use the source image interpolation method when drawing an affine image.</li><br />
<dt>2008-06-24  6.4.2-1 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added new operator  +/-level-colors which will 'level' images based    on colors to use for the black and white points. This lets to adjust    the image in terms of mapping the given colors from/to black and white    respectivally.</li><br />
<dt>2008-06-23  6.4.2-0 Christian Lackas &lt;christian@lacka...&gt;</dt>
  <li> Fix a problem with calling mpeg2encode with parameters (%o/%i) in wrong    order.</li><br />
<dt>2008-06-22  6.4.2-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Refactor additional ImageMagick algorithms for OpenMP support.</li><br />
<dt>2008-06-25  6.4.1-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add pow as an -evaluate operation, using normalized values</li><br />
<dt>2008-06-18  6.4.1-9 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added a  LevelizeImageChannels() which is simular to LevelImageChannels()    Function maps black and white values to the given level values.    Rather than mapping the given level values to black and white.    Bacically a 'reverse-level' function, with different input args.</li>
  <li> Set  +level  or a '!' flag in -level or LevelImage() to call    the new 'reverse-level' function LevelizeImageChannels().</li>
  <li> More work on IsMagickColorSimular() to fix relationship between    transparent-black and opaque-black, which was matched as 'simular'.    Also attempts to fix 'K' channel handling for CMYK colorspace.    More work on this to come.</li><br />
<dt>2008-06-25  6.4.1-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The TXT format correctly reports alpha channel (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11478).</li>
  <li> MONOTCHROME1 Dicom images are not longer inverted (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11492).</li><br />
<dt>2008-06-13  6.4.1-8 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Fixed IsMagickColorSimular() as used by -opauqe and -transparent    so as to understand that the Hue Channel is cyclic by nature</li><br />
<dt>2008-06-08  6.4.1-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -sketch option is working again (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11454).</li><br />
<dt>2008-06-08  6.4.1-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> More algorithms refactored to support a threaded cache view.</li>
  <li> EPS2 output only 1/3 of image when using LZW or rle compress (reference    http://www.imagemagick.org/discourse-server/viewforum.html?f=3).</li>
  <li> ISO C++ 1998 does not support 'long long' (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11405).</li>
  <li> Patch GetMagickMemoryHandlers() to return the properly return the memory    handler addresses.</li>
  <li> Generate histogram comment if # unique colors exceed 1024 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11434).</li><br />
<dt>2008-06-03  6.4.1-6 Marton Bokor  &lt;marton.bokor@gfthu....&gt;</dt>
  <li> Reading EMF files containing non-ascii characters no longer fails for          UTF8 encoded paths on Windows XP.</li><br />
<dt>2008-06-03  6.4.1-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -colorspace option is an operator, not a setting.</li><br />
<dt>2008-05-31  6.4.1-5 rsnel &lt;rik@snel....&gt;</dt>
  <li> gif.c misreads Gifs in which LZW codes are split across three datablocks.</li><br />
<dt>2008-05-31  6.4.1-4 Matthew Clark &lt;mclark@gorge...&gt;</dt>
  <li> Patches to the JPEG and DCM coders to fix a few problems reading    certain DCM image types.</li><br />
<dt>2008-05-15  6.4.1-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Interpreting the -set option is no longer delayed.</li>
  <li> Add AcquireCacheViews() and DestroyCachewViews() to the API.</li>
  <li> Call DrawAffineImage() instead of CompositeImage() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11288).</li>
  <li> Throw exception for TIFF compression not support (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11289).</li>
  <li> The +opaque option now recognizes its required argument (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11298).</li>
  <li> The -background and -virtual-pixel settings are now applied correctly    across parenthesis.</li>
  <li> Only reset the exception signature if the relinquish memory is MagickTrue.</li>
  <li> Correct recolor equation for computing opacity (referencee    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11346).</li>
  <li> Set midpoint when scaling JP2 images.</li>
  <li> Semaphores must be passed by reference when destroyed for reliable thread    locks.</li>
  <li> Updated Matlab coder (thanks to Jaroslav Fojtik).</li><br />
<dt>2008-05-13  6.4.1-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> MagickGetResource(): resources are MagickSizeType not unsigned long.</li><br />
<dt>2008-05-11  6.4.1-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Import: properly handle a hierarchy of subwindows under X11.</li>
  <li> Refactor quantum pixel processor to inprove ease of use and speed.</li><br />
<dt>2008-05-09  6.4.1-2 Leonardo de Paula Rosa Piga &lt;lpiga@terra...&gt;</dt>
  <li> OpenMP patch for sepia-tone effect.</li><br />
<dt>2008-05-08  6.4.1-2 Bruno Cardoso Lopes &lt;bruno.cardoso@gmail...&gt;</dt>
  <li> OpenMP patch for NormalizeImage() & TintImage()</li><br />
<dt>2008-05-06  6.4.1-2 &lt;cristiannomartins@gmail...&gt;</dt>
  <li> OpenMP patch for GetImageChannelDepth().</li>
  <li> Set depth to 32 when saving MIFF HDRI image files.</li><br />
<dt>2008-05-05  6.4.1-2 &lt;joao.vita@gmail...&gt;</dt>
  <li> OpenMP patch for OilPaintImage Function</li><br />
<dt>2008-05-05  6.4.1-2 Sean Patrick Burke  &lt;seanburk@gmail...&gt;</dt>
  <li> Update IPLab coder (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=11200).</li><br />
<dt>2008-05-02  6.4.1-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Return correct result for -fx luminence.</li>
  <li> Restore missing break so that PGM images remain PGM.</li>
  <li> Speed up the processing of ASCII PNM files.</li>
  <li> Return the correct number of MNG images for PingImage().</li><br />
<dt>2008-05-01  6.4.1-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Remove C++ style comments from source.</li>
  <li> Center motion blur kernel.</li>
  <li> Reenable dithering for -monochrome option.</li><br />
<dt>2008-04-24  6.4.0-11 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> For color reduction, use maximum tree depth if image has 1024 or less    unique colors.</li>
  <li> Use a uniform convolution filter for motion blur (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11122).</li>
  <li> Add 'mean' and 'std' symbols to the Fx expression parser.</li><br />
<dt>2008-04-20  6.4.0-10 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> Updated to the latest autoconf/automake/libtool scripts.</li>
  <li> Default to HSL colorspace when modulating (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=11073).</li>
  <li> The -regard-warnings option properly returns a program status of 1 if and    only if a warning or error exception is thrown.</li>
  <li> Report 'no clip path defined' exception for -clip-path option (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11098).</li><br />
<dt>2008-04-16  6.4.0-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Distinquish between pre and post processing of image list options.</li>
  <li> Return MagickTrue if InvokeDynamicImageFilter() does not generate an    exception (reference                http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=11065).</li><br />
<dt>2008-04-16  6.4.0-7 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Instead of masking the PNG tRNS values when reducing from 16-bit,    set image-&gt;matte to MagickFalse and emit a warning.  This will produce    behavior similar to that of libpng-1.2.27 (and libpng-1.2.19 and earlier).</li><br />
<dt>2008-04-12  6.4.0-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix fault for animate -window root image.gif.</li>
  <li> Use GetImagePixels() rather than SetImagePixels() when making multiple    passes and setting image pixels (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=11022).</li><br />
<dt>2008-04-10  6.4.0-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Compile error in coders/avi.c when JPEG delegate library is unavailable.</li><br />
<dt>2008-04-09  6.4.0-5 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Mask the PNG tRNS values when reducing from 16-bit, in accordance with    the PNG specification, instead of scaling them.</li><br />
<dt>2008-04-09  6.4.0-5 Glenn Randers-Pehrson &lt;glennrp@image...&gt;</dt>
  <li> Revised png.c to avoid saving unknown chunk types that will never    be used later.  This prevents the vulnerability described in    CVE-2008-1382, with respect to all unknown chunks except vpAg.    To handle an invalid, zero-length vpAg chunk properly will require    libpng-1.2.27 or later.</li><br />
<dt>2008-04-04  6.4.0-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use mplayer delegate if ImageMagick does not grok AVI op code.</li>
  <li> Use proper rounding for the -fx intensity expression.</li><br />
<dt>2008-03-26  6.4.0-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix +swap option so it no longer throws an assertion.</li>
  <li> Return correct min/max for grayscale JPEG images (e.g. -format %[min]).</li><br />
<dt>2008-03-26  6.4.0-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Rewrote patch so that writing pyramid TIFF images no longer fails if a   tile size is specified (e.g. ptif:image.tif[128x128]).</li>
  <li> Malformed use of caption no longer consumes memory (reference   http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10914).</li>
  <li> Don't run Ghostscript twice (reference   http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10922).</li><br />
<dt>2008-03-21  6.4.0-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> SpreadImage() no longer introduces noise into the resulting image (reference                http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10892).</li>
  <li> Properly handle min-is-white TIFF gray scale images.</li>
  <li> Use CompositeImage() instead of DrawAffineImage() if the affine expansion    factor is 1.0.</li><br />
<dt>2008-03-20  6.3.9-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Writing pyramid TIFF images no longer fails if a tile size is specified    (e.g. ptif:image.tif[128x128]).</li>
  <li> Reset page geometry when interactively cropping an image with the display    program.</li><br />
<dt>2008-03-18  6.3.9-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> With a single swap argument should swap the image with the *last* image.</li><br />
<dt>2008-03-16  6.3.9-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Make sure we don't sync a blob after it has been closed.</li><br />
<dt>2008-03-14  6.3.9-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Patch mpeg:encode delegate to properly produce an MPEG image sequence.</li><br />
<dt>2008-03-11  6.3.9-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support both GTK and CAIRO interfaces to RSVG (reference    ttp://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=10802).</li>
  <li> Display colormapped PNG images with alpha properly (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10819).</li><br />
<dt>2008-03-09  6.3.9-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Define inline to _magickcore_inline (to satisfy HP's aCC compiler).</li><br />
<dt>2008-03-08  6.3.9-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The rsvg delegate library depends on cairo-svg.</li>
  <li> Account for min-is-white 8-bit gray TIFF images.</li><br />
<dt>2008-02-29  6.3.9-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for the Postable Document Archive Format.</li>
  <li> Add support for Braille images.</li>
  <li> Add support for DDS images (contributed by Bianca van Schaik).</li>
  <li> Add GetImageAlphaChannel() method.</li>
  <li> PSD clipping paths are once again recognized.</li><br />
<dt>2008-02-24  6.3.9-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Return the actual image format for HTTP: or FTP: format (reference        http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=10715).</li>
  <li> Fix so image.quantize(true) returns error as expected (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=10735).</li><br />
<dt>2008-02-20  6.3.9-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed a small memory leak (8 bytes) in TransformImages().</li>
  <li> Render to Cairo surface rather than a GDK buffer when rendering SVG.</li>
  <li> Identify now reports both actual and reported image depths (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=10716).</li><br />
<dt>2008-02-17  6.3.8-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Speed up converting large PDF/PS images when only selecting a few pages    (e.g. pdffile.pdf[195-199]).</li>
  <li> Deprecate HSLTransform() and TransformHSL().</li><br />
<dt>2008-02-16  6.3.8-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix Magick++-config script to reflect the MagickWand / MagickCore    dependencies.</li><br />
<dt>2008-02-14  6.3.8-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Promote colormapped to truecolor images when enciphering.</li><br />
<dt>2008-02-08  6.3.8-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add EncipherImage() / DecipherImage() methods.</li>
  <li> Add -encipher / -decipher options to the command-line utilities.</li><br />
<dt>2008-02-03  6.3.8-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> New Unix/Linux refactoring (should be transparent since changes are    reflected in Magick-config and ImageMagick.pc pkg-config files):      /usr/local/include =&gt; /usr/local/include/ImageMagick      libMagick =&gt; libMagickCore      libWand =&gt; libMagickWand      Magick-config (deprecated) =&gt; MagickCore-config      Wand-config (deprecated) =&gt; MagickWand-config      Add Magick++-config, MagickCore.pc, MagickWand.pc, Magick++.pc</li><br />
<dt>2008-01-28  6.3.8-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Liquid rescale limits the final size to twice the original size (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=10536).</li>
  <li> Read EXIF data in TIFF images; writing is pending until we can figure out    how to use the libtiff delegate library to write EXIF data.</li><br />
<dt>2008-01-24  6.3.8-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for liquid rescaling (e.g. -liquid-rescale).</li>
  <li> Support a ^ meta character in an image geometry (.e.g    convert 640x480.png -resize 240^ returns a 320x240 result).</li><br />
<dt>2008-01-20  6.3.8-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix transient bug where "identify -format '%w;%[exif:Model]'" failed to    return camera model number.</li><br />
<dt>2008-01-14  6.3.8-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Monochome EPS3 images are no longer corrupt (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10422).</li>
  <li> Eliminate memory corruption with broken PICT image (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10447).</li>
  <li> Return a Grayscale colorspace for grayscale DPX image (previously    returned Log colorspace).</li>
  <li> Fix -g option for PCL6 support (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10462).</li><br />
<dt>2008-01-08  6.3.7-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Only read ICON alpha mask if BPP is <= 16.</li>
  <li> Add support for +opaque and +transparent (requested by Anthony).</li>
  <li> Throw an exception *before* we call wmf_api_destroy() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10420).</li><br />
<dt>2008-01-01  6.3.7-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use explicit format specifier to render transparent Adobe Illustrator    files (i.e. convert ai:image.ai image.png).</li>
  <li> Set RSVG base URI (patch provided by tsdineen).</li><br />
<dt>2007-12-20  6.3.7-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> `Magick-config --version` returns Q16 instead of    Q@MAGICKCORE_QUANTUM_DEPTH@.</li>
  <li> Permit commas in numbers in certain locales (e.g. german +100,000).</li><br />
<dt>2007-12-13  6.3.7-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Added an exception reason to BlobToImage() in the event an image has no    magic number and neither the image magick or filename is set.</li>
  <li> Do not pass PhotoYCC data thru gamma-corrected lookup-table.</li>
  <li> Fix bug in GetEXIFProperty() (reference    https://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10300).</li><br />
<dt>2007-12-12  6.3.7-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Adding comments to your image is now possible with the display program.</li><br />
<dt>2007-12-09  6.3.7-3 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Adjusted -clut multiplyer for correct handling of    "-interpolation Integer" in color lookup.</li><br />
<dt>2007-12-01  6.3.7-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix 'insufficient image data' for DCM format (reference    https://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10227).</li>
  <li> Force a colormapped image if Palm bits-per-pixel &lt; 16.</li>
  <li> Fix multiple problems with Palm Data Base reader (patch from    1tms@gmx.d...).</li>
  <li> Do not exit after first image with the display --immutable option.</li>
  <li> Update autoconf/automake/libtool configuration files.</li>
  <li> Add support for resource limit units (e.g. -limit memory 16mb).</li>
  <li> Return original image if gaussian blur sigma is 0.0.</li>
  <li> Colormapped multi-image PDF's are no longer corrupt (reference    https://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10258).</li><br />
<dt>2007-11-27  6.3.7-2 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Finalisation of new resize filters, "Lagrange" self-windowing filter    now adjusts automatically with different support window size.</li>
  <li> Added "Bohman" (another 2'rd order cosine function) and "Bartlett"    (triangluar) resize windowing filters.</li>
  <li> Adjusted -clut to use a grayscale image (with no alpha) to select colors    from the Lookup Table image.</li><br />
<dt>2007-11-26  6.3.7-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Not all DCM tags were being saved as image attributes (patch provided by    jcupitt@gmail...).</li>
  <li> Normalize pixel values when quantum format is floating-point.</li>
  <li> Initialize the pixel sum to zero when averaging image pixels.</li><br />
<dt>2007-11-23  6.3.7-1 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Bug fix in height calculation for -layers merge operation</li><br />
<dt>2007-11-02  6.3.7-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for SCT grayscale images.</li>
  <li> Fixed transparancy bug for the ICO image format.</li>
  <li> Fixed small memory leak in the caption and label coders.</li>
  <li> Fixed -threshold option to return all white for -threshold 0 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10126).</li><br />
<dt>2007-11-06  6.3.6-10 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> Corrected CGM delegate command in config/delegate.xml.</li><br />
<dt>2007-11-05  6.3.6-9 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> Reclassified X server open error from fatal to non-fatal.</li>
  <li> New SetImageAlphaChannel() method to activate, deactivate, reset, or    set the image alpha channel.</li>
  <li> Patch for Scanalytics IPLab image format for non 8-bit images    (contributed by Sean Burke).</li><br />
<dt>2007-11-04  6.3.6-8 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> Remove ctrl-M characters on in various source files.</li>
  <li> Fix signature for Magick++ averageImages() regression tests for HDRI.</li>
  <li> Only invoke PerlMagick x11 regression test if DISPLAY variable is set.</li><br />
<dt>2007-11-03  6.3.6-7 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> MAGICK_ERX_SRCS should be MAGICK_EXR_SRCS in coders/Makefile.am.</li><br />
<dt>2007-11-02  6.3.6-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Upgrade to FPX version libfpx-1.2.0.14 (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10041).</li>
  <li> Modules are searched first in the directories specified by the environment    variables, and then -- if the desired module is not found -- in the    compiled-in path.  (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=10039).</li><br />
<dt>2007-11-01  6.3.6-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Update FPX regression test reference images.</li>
  <li> Fixed Magick++ compile error for Sun Studio 10 compiler.</li><br />
<dt>2007-10-25  6.3.6-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -equalize option now respects the -channel option.</li><br />
<dt>2007-10-23  6.3.6-4 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Additional Filters:  Welsh, Parzen, Lagrangian</li>
  <li> Addition of Cubic filter B,C controls</li>
  <li> 'verbose' filter plotting output using  -define "filter:verbose"</li><br />
<dt>2007-10-20  6.3.6-3 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Further expandsion and handling of filters with expert options.    -filter selects from a table of standard filter settings, while    expert options allow complete selection of filter, windowing, support    and blurring options.  Includes automatic switch from Sinc to Bessel    for operators using 2 dimentional cylindrical filter, rather than    two pass 1 dimentional orthogonal filters.</li><br />
<dt>2007-10-14  6.3.6-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Obsolete -support (set filter blur factor)</li>
  <li> Expandsion to add -set/define filter options</li><br />
<dt>2007-10-12  6.3.6-2 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Least Squares coordinate handling added for -distort methods Affine,    Perspective, Bilinear.   This allows for more than the minimal number of    coordinates to be used to 'fit' a distortion function to an image.    This addition will allow the use of image registration to generate    panarama overviews and better geographical coordinate correction.</li>
  <li> Cosolidated the simular methods FlattenImage() and MosaicImage()    into a new layers function MergeImageLayers() method, adding 'flatten'    and 'mosaic' layer methods.</li>
  <li> Addition of another simular layers method 'merge' which 'unlocks' the    normal flatten/mosaic layer merger from the origin, The resulting image    will have a virtual canvas of minimal size with an offset. Also images    with negative offsets will not be clipped by the 'merge' form of the    command.  This was created for better layering of distorted images, such    as panarama overlays.</li>
  <li> Bug fix in handling transparency for EWA resampling.</li>
  <li> Access to Resize Filter Functions from resize.c (for resample.c)    with posible future filter sources... Acquire/Destory/Call ResizeFilter()</li>
  <li> All resize filters added to resampling, but filter handling is incomplete.</li><br />
<dt>2007-10-05  6.3.6-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The box filter no longer produces a black grid when resizing an image    under Mac OS X.</li>
  <li> Respect cropbox for PDF with a subimage specification (e.g.        image.pdf[1-3]).</li>
  <li> Detect proper PDF bounding box when offsets are negative.</li><br />
<dt>2007-10-02  6.3.6-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Speed up the Fx interpreter.</li>
  <li> Use ULL not ui64 for MinGW 64-bit constants.</li>
  <li> Call SyncCacheView() instead of SyncImagePixels() in WaveImage().</li>
  <li> Close all references to a pixel cache on disk before removing the temporary          file as required under Windows.</li><br />
<dt>2007-09-29  6.3.6-0 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Added Scaling 'derivitives' to -distort Arc, so image arcing is now    sharp and clear as you approach the center of the distort.</li>
  <li> Added  " -set option:distort:viewport 'geometry' " special option    that can be used to override the output image size and offset.</li>
  <li> Fixed experimental use of -filter and -support in Resampling (more later).</li>
  <li> Changed order for coordinate arguments in -distort (for later leastsq    multiple coordinate distortion function fitting)</li><br />
<dt>2007-09-22  6.3.6-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Check the API version and quantum depth before loading a coder module or          image filter (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9780).</li>
  <li> Add exception to the image filter signature.</li>
  <li> Get the execution path under Mac OS X.</li>
  <li> TIFFTAG_STRIPBYTECOUNTS requires a uint32 pointer (magick/compress.c).</li>
  <li> Fixed memory leak in CloneString() (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9763).</li>
  <li> Set S_IRUSR | S_IWUSR | S_IRGRP mode when writing a file in    CopyDelegateFile().</li><br />
<dt>2007-09-18  6.3.5-9 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Bug fix for +distort in Perspective, also effected PerspectiveProjection</li><br />
<dt>2007-09-17  6.3.5-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Replace all InterpolatePixelColor() calls to use the ResamplePixelColor()    method instead.</li>
  <li> Map the display program pan icon window for each oversized image.</li>
  <li> The ufraw delegate does not like quotes around the output filename.</li>
  <li> Adjust the sensitivity of a few PerlMagick tests to pass the validation on    a 64-bit FreeBSD system.</li>
  <li> The -level option now works properly for colormapped images.</li>
  <li> Allow Extrapolated blending of images using -blend       http://netpbm.sourceforge.net/doc/extendedopacity.html</li><br />
<dt>2007-09-12  6.3.5-9 Anthony &lt;anthony@griffith...&gt;</dt>
  <li> Major Addition,  Area Resampling Functions, (scaled interpolation)    for pixel lookup in Distortion functions.  This improves the look in    areas of minification enormousally, especially in situations of infinite    tiling and horizon views.  All virtual pixel methods have been handled    to minimise computation time involved with area resampling.  To use the    new function distortions need to be able to determine scaling vectors    (distortion function derivitives) for correct working.  All    -distort methods, except Arc, uses scaled area resampling.</li>
  <li> Improvements to perspective distort method, to include the correct    differentation between the 'ground' on which the image lies, and the    'sky', the color of which can be set using the -mattecolor setting    (as the distortion invalid pixel color). Background color is retains    for surrounding ground areas. The horizon is also correct anti-aliased    and transparent colors are also allowed, allowing you to add backdrops    of gradients and patterns.</li><br />
<dt>2007-09-04  6.3.5-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Read/Write Scanalytics IPLab image format (contributed by Sean Burke).</li>
  <li> Patched ReadBlobString() to fix a off-by-one vulnerability (alert from    iDefense).</li>
  <li> Patched ReadDIBImage() to fix a sign extension vulnerability (alert from    iDefense).</li>
  <li> Patched AllocateImageColormap() to fix an integer overflow vulnerability    (alert from iDefense).</li>
  <li> Patched ReadDCMImage() to fix an integer overflow vulnerability    (alert from iDefense).</li>
  <li> Patched ReadDIBImage() to fix an integer overflow vulnerability    (alert from iDefense).</li>
  <li> Patched ReadXBMImage() to fix an integer overflow vulnerability    (alert from iDefense).</li>
  <li> Patched ReadDCMImage() to fix an denial of service vulnerability    (alert from iDefense).</li>
  <li> Patched ReadXCFImage() to fix an denial of service vulnerability    (alert from iDefense).</li>
  <li> If image size changes, don't trust DPX orientation attributes.</li><br />
<dt>2007-09-04  6.3.5-9 Gozer404</dt>
  <li> Add French to the messaging system (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=9601).</li>
  <li> Add -fopenmp to MAGICK_PCFLAGS (reference   http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9608).</li><br />
<dt>2007-08-14  6.3.5-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add -alpha {activate,deactivate,reset} option to activate, deactivate, or    reset the alpha channel.</li>
  <li> Render proper image labels for VID coder.</li>
  <li> Resolved a conflict for the -list option.  Use -list font to list          ImageMagick fonts and -list type to list image types.</li>
  <li> Catch any errors returned by pthread_mutex_init() (problem report    from devman@gmx-t...).</li>
  <li> TransformHSL() returns a proper hue component.</li>
  <li> Added -clut option and the ClutImage() method.</li>
  <li> Fix glyph memory leak in AnnotateImage (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9523).</li>
  <li> Rename analyze.c to Analyze.c (reference    ttp://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9538).</li><br />
<dt>2007-08-07  6.3.5-6 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Enabled use of +distort to auto resize destination image to 'bestfit'    the distorted input image.  This also enabled the use of virtual canvas    offsets in source and destination images for most distortion methods.</li><br />
<dt>2007-08-05  6.3.5-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Remove atexit in Magick++ code to avoid possible client crash (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9270).</li><br />
<dt>2007-08-01  6.3.5-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Read/Write Scanalytics IPLab image format (contributed by Sean Burke).</li><br />
<dt>2007-07-30  6.3.5-5 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Added -distort arc.  This update also allows the destination image    size and offset to be set according to the specific distortion being    applied.</li><br />
<dt>2007-07-29  6.3.5-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Set the -poloroid border color with the -bordercolor option.</li><br />
<dt>2007-07-25  6.3.5-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Remove extranous break statement so -type option properly sets the    image_info-&gt;type member (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9261).</li><br />
<dt>2007-07-21  6.3.5-4 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Allow the use of optional arguments in -distort SRT</li><br />
<dt>2007-06-29  6.3.5-0 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Initial addition of three Affine Distortions to -distort with the affine    mapping defined by the use of;  an Affine Matrix, Coordinates of Triangles,    or separate Scale-Rotate-Translate actions.</li><br />
<dt>2007-06-18  6.3.5-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix X11 font ascender.</li>
  <li> Add -distort option.</li>
  <li> Add random noise option (e.g. +noise random).</li>
  <li> Many internal algorithms are now threaded to take advantage of speed-ups    offered by the new dual and quad-core processor technologies.    and quad-core processor technology.</li>
  <li> Tiff images in the LAB colorspace are no longer identified as RGB    (reference http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9015).</li>
  <li> Update image color_profile and iptc_profile members in the JPEG coder    (reference http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9063);</li><br />
<dt>2007-06-13  6.3.4-10 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix composite mask bug (reference    http://www.imagemagick.org/Usage/bugs/composite_mask/).</li>
  <li> Speed up GetPixelOpacity() method (patch from seth@price...).</li>
  <li> Set icon image width/height before allocating the image colormap.</li>
  <li> Remove Photoshop string segment from JPEG profile (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=9006).</li><br />
<dt>2007-06-11  6.3.4-9 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Converting a jpg to pdf is creating an empty pdf object (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8954).</li>
  <li> Respect the '-set type:hinting off option' (bug report from Richard    Jones).</li>
  <li> WritePSDImage vulnerable to exploitable heap corruption (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8967).</li><br />
<dt>2007-06-09  6.3.4-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> SetMagickRegistry() post-increment the value 'id' (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8944).</li><br />
<dt>2007-06-02  6.3.4-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Read/write 10 & 12-bit packed DPX images.</li>
  <li> Reduce stack requirements for messaging system.</li>
  <li> Small memory leak for raw profiles in the PNG coder.</li><br />
<dt>2007-06-01  6.3.4-5 Glenn &lt;glennrp@image...&gt;</dt>
  <li> Added GIF, JPEG, and PNG interlace types.  For backward compatibility,    you can continue to use "-interlace Plane" to request these.</li><br />
<dt>2007-04-30  6.3.4-0 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Fixed minor bug in the 'curl' for Polaroid of very non-square images.</li><br />
<dt>2007-06-01  6.3.4-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Set min-is-white for Group4-compressed PDF.</li>
  <li> Add PaintFloodfillImage() method.</li><br />
<dt>2007-05-30  6.3.4-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add MEPP metric to compare program.  Returns the mean error per pixel    along with the normalize mean and maximum error.</li>
  <li> Attach an XMP profile to an image (e.g.    convert input.tif -profile xmp:metadata.xmp output.tif).</li><br />
<dt>2007-05-22  6.3.4-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed mogrify conversions with -format and -path (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=1&t=9127).</li><br />
<dt>2007-05-15  6.3.4-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> SVG style element was not always parsed properly.</li>
  <li> Do not dither when the number of unique colors is already less than the    maximum.</li>
  <li> Return normalized PAE metric (compare utility).</li><br />
<dt>2007-05-03  6.3.4-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add support for PFM images.</li>
  <li> Check for corrupt EXIF image profiles.</li>
  <li> Writing JPEG YCbCr TIFF images no longer faults (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8896).</li><br />
<dt>2007-04-30  6.3.4-0 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Fixed minor bug for crop missed images and 'background' GIF disposal.</li><br />
<dt>2007-04-28  6.3.4-0 Glenn  &lt;glennrp@image...&gt;</dt>
  <li> Added profile support to the GIF decoder/encoder.  They are stored    as GIF Application Extensions.  Known extensions include existing ICCRGB1    (for ICC profiles) and new MGKIPTC0 and MGK8BIM0 (for IPTC and 8BIM    profiles).  Unknown extensions found in GIF files are read as gifappNNN.</li><br />
<dt>2007-04-28  6.3.4-0 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Invert Opacity change for user defined ordered dither threshold maps,    so that 'off' map is transparent, and 'on' is opaque.</li><br />
<dt>2007-04-24  6.3.4-0 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Added an initial Coalesce Images, and a final +map local colortable    optimization to the -layers Optimize method, for a simple to use    GIF optimization operation.  (more work to come)</li><br />
<dt>2007-04-22  6.3.4-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Properly set the virtual canvas of a multi-frame GIF image sequence.</li>
  <li> Add AcquireOneVirtualPixel() method.</li>
  <li> Set Log colorspace properly when writing DPX images.</li>
  <li> Add -tile-offset option.</li>
  <li> Add support for the EXR image format.</li>
  <li> Improve support for DPX images.</li>
  <li> Add --enable-hdri option to the configure script.</li>
  <li> Add support for high dynamic-range images (HDRI).</li><br />
<dt>2007-04-20  6.3.3-9 Peter Hull  &lt;peterhull90@gmail...&gt;</dt>
  <li> Improve support for writing multiple image icons.</li><br />
<dt>2007-04-18  6.3.3-9 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Separated -layers Optimize from -layers OptimizeFrame to allow    the former expansion into a general (multiple method) optimizer    of GIF animations</li>
  <li> merged -layers OptimizeTransparency into -layers Optimize method</li><br />
<dt>2007-04-12  6.3.3-8 Chris Madison  &lt;madisonblu@hotma...&gt;</dt>
  <li> Fix fault whem comparing a colormapped image with a non-colormapped one.</li>
  <li> Fix race condition when spawning delegate programs.</li>
  <li> TIFF JPEG now respects the -quality comptression setting.</li>
  <li> The -fx option now properly groks the logical and operator.</li>
  <li> DPX tilestamp property should be timestamp.</li><br />
<dt>2007-04-13  6.3.3-7 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Added GravityAdjustGeometry() to "geometry.c" to adjust geometry settings    according to given gravity and canvas area it applies to. This is for    code simplification thoughout MagickCore.</li><br />
<dt>2007-04-09  6.3.3-6 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Fixed CoalesceImages() to reset virtual canvas info on second and later    frames.   Other animation handlers may also need to reset virtual canvas    sizes to match the first frame, as well.</li><br />
<dt>2007-04-06  6.3.3-6 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Addition of a CompositeImages() "layer.c" function to compose two    separate image lists together (with a virtual canvas offset) in three    different ways, depending on the size of the lists.</li>
  <li> A 'hack' for command line use (the two lists separates by the special    "NULL" image, which is junked) has also been added. Specifically...    "-layers Composite".</li><br />
<dt>2007-04-04  6.3.3-6 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Add -layers RemoveDups method to remove duplicate sequential images in    coalesced animations.</li>
  <li> Add -layers RemoveZero method to remove images with a zero time delay    (with no action and a warning is all images have zero time delay)</li><br />
<dt>2007-04-01  6.3.3-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Permit generic profiles (e.g. -profile name:profile).</li><br />
<dt>2007-03-31  6.3.3-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed DCM and XWD buffer overflow vulnerabilities (reference    http://labs.idefense.com/intelligence/vulnerabilities/display.html?id=496).</li><br />
<dt>2007-03-28  6.3.3-4 Anthony  &lt;anthony@griffith...&gt;</dt>
  <li> Code duplication, simplification, and possible logic faults in "list.c".</li>
  <li> Added new Composition method, 'ChangeMask' to return pixels    that have changed or will cause a color change in overlays</li>
  <li> Used 'ChangeMask' to implement the "-layers" method    "OptimizeTransparency" to improve the compressibility of    frame optimized GIF animations. See IM Examples...      http://www.imagemagick.org/Usage/anim_opt/#opt_trans</li><br />
<dt>2007-03-19  6.3.3-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fixed two memory leaks in wand/magick-image.c and magick/stream.c and made    some minor changes to the GIF coder to make reading and pinging images    faster (patch provided by mstemm@cloud...).</li><br />
<dt>2007-03-19  6.3.3-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Patch RotateImage() to properly rotate CMYK images.</li>
  <li> Patch the XWD coder to prevent heap overflow vulnerability (vulnerability    report from idefense.com [IDEF2108] [IDEF2221] [IDEF2226]).</li><br />
<dt>2007-03-19  6.3.3-3 Anthony &lt;Anthony@griffith...&gt;</dt>
  <li> Fixed bug for GIF Optimization for images without a matte channel.</li>
  <li> Improved image handling for "-layers" method "Dispose".</li><br />
<dt>2007-03-11  6.3.3-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Improve configure script to better support Ghostscript under Mac OSX (    reference http://www.imagemagick.org/discourse-server/viewtopic.html?t=8557).</li>
  <li> Force a virtual pixel method of Tile for GetFillColor() and    GetStrokeColor().</li>
  <li> Add -reverse option to reverse the image list.</li><br />
<dt>2007-03-08  6.3.3-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Support versions 2.1.0 and above (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=8620).</li>
  <li> Support SVG rotation about a point (e.g. rotate(45 75 75)).</li>
  <li> Fix fault in DCM coder (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8618).</li>
  <li> Check for a NULL parser in SVGReference in coders/svg.c (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=3&t=8609).</li>
  <li> Add --disable-deprecated configure script option.</li>
  <li> Composite mask now works properly with transparent images.</li><br />
<dt>2007-03-04  Daniel Kobras &lt;kobras@debia...&gt;</dt>
  <li> Fixed additional data-driven faults (reference    http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=412945).</li>
  <li> Allocate proper scanline length to prevent a PCX overflow.</li><br />
<dt>2007-03-03  6.3.3-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Patch ImageMagick to permit referenced labels: -set option:mylabel    "color = %[pixel:u[0].p{12,26}]" label:'%[mylabel]'</li><br />
<dt>2007-02-24  6.3.3-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Escape indirect labels and comments (e.g. -label @file).</li>
  <li> Added -format %C to return the image compression type.</li>
  <li> Do not report channel statistics if -ping -format is specified with the    identify program.</li>
  <li> Add ResetImagePage() to reset the image page canvas and position.</li>
  <li> Upgrade to LCMS 1.16</li>
  <li> Configure Ghostscript for library or framework (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?f=2&t=8557).</li>
  <li> Add -taint option to convert/mogrify to mark image as ineligible for</li>
  <li> Fixed various data-driven faults (reference    http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=412945).  The corrupt    JP2 image faults but its failing in the JP2 jas_image_decode() method,    not MagickCore.  The corrupt XWD image faults but its failing in    the X11 XGetPixel() method, not MagickCore.</li><br />
<dt>2007-02-20  6.3.2-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Use -define quantum:polarity=min-is-black or -define    quantum:polarity=min-is-white to toggle the photometric interpretation for    a bilevel TIFF image.</li><br />
<dt>2007-02-17  6.3.2-8 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Don't interpret embedded format characters when reading comments/labels    from a file.</li>
  <li> Reading an image from stdin stopped working.</li><br />
<dt>2007-02-17  6.3.2-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> PerlMagick Label() no longer faults.</li>
  <li> Fix double-free when using the display/animate -geometry option.</li>
  <li> Add GetStringInfoLength() and GetStringInfoDatum(); deprecate    profile-&gt;length and profile-&gt;datum.</li><br />
<dt>2007-02-16  6.3.2-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix file leak in InjectImageBlob().</li>
  <li> Do not reinterpret image properties (e.g. -comment %%w).</li><br />
<dt>2007-02-14  6.3.2-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Don't over-allocate file buffers.</li><br />
<dt>2007-02-12  6.3.2-5 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Format strings in the POSIX locale.</li>
  <li> Make font metrics invarient to the strokewidth.</li><br />
<dt>2007-02-10  6.3.2-4 Albert Chin  &lt;china@thewr...&gt;</dt>
  <li> Patch to fix configure.ac typo.</li><br />
<dt>2007-02-08  6.3.2-4 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Permit ImageMagick to run as a service under Windows.</li>
  <li> Remove duplicate EXIF properties.</li>
  <li> Support strokewidth option for the caption format.</li>
  <li> Don't use Ghostscript for rendering fonts if Freetype is available.</li><br />
<dt>2007-02-02  6.3.2-3 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Added thumbnail format to write EXIF thumbnails.</li>
  <li> Move ReadByteImage() out of Min() macro of ReadPALMImage().</li>
  <li> Move EXIF properties to the EXIF namespace (e.g. exif:XResolution).</li><br />
<dt>2007-01-26  6.3.2-2 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Add interpolate and background options to PerlMagick's AffineTransform().</li>
  <li> Revert to Postscript rendering if Freetype delegate library is not    available.</li><br />
<dt>2007-01-20  6.3.2-1 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Accept Fx expressions from a file with -fx @filename.</li>
  <li> Enhance -fill and -stroke to accept image filenames as patterns.</li><br />
<dt>2007-01-16  6.3.2-0 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Save grayscale images as JPEG-compressed grayscale when writing in the TIFF    format.</li>
  <li> Update EXIF resolution fields when image density changes.</li><br />
<dt>2007-01-07  6.3.1-7 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> The -polaroid option now respects -gravity.</li>
  <li> Deprecate Get/SetImageAttribute().  Recommend Get/SetImageProperty()    instead.</li>
  <li> Any form of "-crop" with a percentage, implies an offset for the crop.</li>
  <li> Fixed percent option for -border (e.g. -border 10%x0%).</li>
  <li> Add -path option to the mogrify program to specify where to write the    images.</li><br />
<dt>2007-01-06  6.3.1-6 Cristy  &lt;quetzlzacatenango@image...&gt;</dt>
  <li> Fix the -auto-orient to work with an image sequence (reference    http://www.imagemagick.org/discourse-server/viewtopic.html?t=8100).</li>
  <li> Add -polaroid option to simulate a Polaroid picture.</li>
  <li> Eliminate double-free bug in GradientImage().</li>
  <li> Set AppendImage() matte channel only when image has matte attribute set.</li>
  <li> The -crop with negative offsets do not modify the virtual canvas.</li>
  <li> Caption: Given both the width and height ("-size") of the area to fill,    adjust the fonts "-pointsize" until the text just filles the whole space    without overflowing.</li>
  <li> Generate proper Windows icon image files (patch provided by    Robert M. Jansen).</ul>
</div>

<div id="linkbar">
 <!--    <span id="linkbar-west">&nbsp;</span>  -->
    <span id="linkbar-center">
      <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
      <a href="../www/mailing-list.html">Mailing Lists</a> &bull;
    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
    </span>
    <span id="linkbar-east">&nbsp;</span>
  </div>
  <div class="footer">
    <span id="footer-west">&copy; 1999-2009 ImageMagick Studio LLC</span>
    <span id="footer-east"> <a href="http://www.imagemagick.org/script/contact.php">Contact the Wizards</a></span>
  </div>
  <div style="clear: both; margin: 0; width: 100%; "></div>
</body>
</html>
