files/index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta name="generator" content="HTML Tidy for HTML5 for Linux version 5.8.0">
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="../assets/usage.css">
  <title>File Handling -- ImageMagick Examples</title>
  <link rel="icon" href="../img_www/favicon.ico" type="image/x-icon">
  <link rel="shortcut" href="../img_www/favicon.ico" type="image/x-icon">
  <link rel="canonical" href="https://imagemagick.org/Usage/files/">
</head>
<body>
  <main class="container">
    <div class="magick-template">
      <div class="magick-header">
        <h1>ImageMagick Examples --<br>
        <img src="../img_www/space.gif" width="50" height="1"> Image File Handling</h1>
        <div>
          <dl>
            <dt><b>Index</b></dt>
            <dt>
              <a href="../"><img src="../img_www/granitesm_left.gif" border="0" width="15" height="15"> ImageMagick Examples Preface and Index</a>
            </dt>
            <dd>
              <a href="#summary"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Image Formats Summary</a>
            </dd>
            <dd>
              <a href="#read"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Reading Images</a>
              <ul>
                <li>
                  <a href="#read_mods">Read Modifiers</a>
                </li>
                <li>
                  <a href="#read_meta">Input Filename Meta-character Handling</a>
                </li>
                <li>
                  <a href="#read_compressed">Compressed Images</a>
                </li>
              </ul>
            </dd>
            <dd>
              <a href="#save"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Saving Images</a>
              <ul>
                <li>
                  <a href="#save_escapes">Filename Percent Escapes</a>
                </li>
                <li>
                  <a href="#save_gzip">GZipped Compressed Images</a>
                </li>
                <li>
                  <a href="#save_attributes">Saved Attributes</a>
                </li>
                <li>
                  <a href="#save_encrypted">Encrypted Images</a>
                </li>
                <li>
                  <a href="#adjoin">Writing a Multiple Images (adjoin)</a>
                </li>
                <li>
                  <a href="#scene">Starting Sequence (Scene) Number</a>
                </li>
                <li>
                  <a href="#write">Writing an Image, Multiple Times</a>
                </li>
              </ul>
            </dd>
            <dd>
              <a href="#special_formats"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Special Output File Formats</a> <font size="-1">(Specific to IM)</font>
              <dl>
                <dd>
                  <a href="#miff"><code>miff:</code></a>&nbsp;&nbsp; <a href="#info"><code>info:</code></a>&nbsp;&nbsp; <a href="#null"><code>null:</code></a>&nbsp;&nbsp; <a href="#txt"><code>txt:</code></a>&nbsp;&nbsp; <a href="#sparse-color"><code>sparse-color:</code></a>&nbsp;&nbsp; <a href="#histogram"><code>histogram:</code></a>&nbsp;&nbsp; <a href="#mpr"><code>mpr:</code></a>&nbsp;&nbsp; <a href="#mpc"><code>mpc:</code></a>&nbsp;&nbsp; <a href="#fd"><code>fd:</code></a>&nbsp;&nbsp; <a href="#inline"><code>inline:</code></a>&nbsp;&nbsp;
                </dd>
                <dd>
                  <a href="#clipboard"><code>clipboard:</code></a> -- Read/Write to/from windows clipboard
                </dd>
                <dd>
                  <a href="#ephemeral"><code>ephemeral:</code></a> -- Auto-delete after read
                </dd>
                <dd>
                  <a href="#show"><code>show:</code>, <code>win:</code>, and <code>x:</code></a> -- Display Images Directly
                </dd>
                <dd>
                  <a href="#x"><code>x:</code> (as input)</a> -- Display Capture and Re-draw
                </dd>
              </dl>
            </dd>
            <dd>
              <a href="#delegates"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Delegates and Coders for Image Formats</a>
              <ul>
                <li>
                  <a href="#delegate_input">Input Delegate Example</a>
                </li>
                <li>
                  <a href="#delegate_output">Output Delegate Example</a>
                </li>
                <li>
                  <a href="#delegate_list">Listing Delegates and Source Files</a>
                </li>
                <li>
                  <a href="#delegate_print">Printing Delegate</a>
                </li>
                <li>
                  <a href="#delegate_spawn">Spawning External Commands</a>
                </li>
                <li>
                  <a href="#delegate_postscript">Postscript and PDF Delegates</a>
                </li>
                <li>
                  <a href="#delegate_direct">Direct Delegate Format Conversion (taint)</a>
                </li>
                <li>
                  <a href="#delegate_other">Other Delegate Examples</a>
                </li>
              </ul>
            </dd>
            <dd>
              <a href="#massive"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Really Massive Image Handling</a>
            </dd>
            <dd>
              <a href="#image_streams"><img src="../img_www/granitesm_right.gif" border="0" width="15" height="15"> Long Streams of Lots of Images, Video sequences</a>
            </dd>
          </dl>To process an image, you not only need operators to work on the images, but you also need ways to read in and write out the image in as many different file formats as possible. In this section we look at IM file formats in general.
          <hr>
          <!-- ---------------------------------------------------------------- -->
          <a name="summary" id="summary"></a>
          <h2>Image Formats Summary</h2>One of the most common uses of ImageMagick is not to modify images at all, but only to magick an image from one image format to another. In fact this was the original reason for IM's creation was this sort of image format conversion. This is why the primary IM command is call "<code>magick</code>". To this end, ImageMagick can handle a bewildering array of image and file formats. Added to this array are a large number of special input and output formats for built-in test images, simple image creation, and image formats specific for programming shell scripts, and programs. For a complete list, see <a href="https://imagemagick.org/script/formats.php">IM Image Formats Page</a> on the IM web site. All this can be daunting for a new user of ImageMagick. My best advise is to ignore most of the file formats, as you will probably never need them. Instead concentrate on what you want to do, and try to do it. If you don't know how, try to look for an example in these pages and across the web. For image formats demonstrated in IM Examples, see <a href="../reference.html#formats">Reference Index, File Formats</a>.
          <hr>
          <!-- ---------------------------------------------------------------- -->
          <a name="read" id="read"></a>
          <h2>Reading Images</h2>IM by default will attempt to determine the image format type by the 'magic' file identification codes within the file itself. If this fails however you will need to specify the images file format using with the files suffix, or by adding a prefix format. Some formats will not read any files and ignore any given filename. These are some of the common built-in images...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  logo:      granite:     rose:
</samp></pre>
                </td>
              </tr>
            </table>
          </div>Some of them will generate images based on arguments given as a filename and perhaps an extra "<code><a href="https://imagemagick.org/script/command-line-options.php?#size">-size</a></code>" controlling the final image size...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  -size 30x30  canvas:red
  -size 30x30  gradient:yellow-lime
  -size 30x30  pattern:fishscales
  magick import:
</samp></pre>
                </td>
              </tr>
            </table>
          </div>In some cases you can even use multiple formats...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  -size 30x30  tile:pattern:gray95
</samp></pre>
                </td>
              </tr>
            </table>
          </div>This is however overkill in this case as the '<code>pattern:</code>' format coder has the '<code>tile:</code>' coder built into it. But it does make it clear what you were intending to do. IM can also download an image that is published on the 'world wide web' by specifying that images URL. This basically provides a '<code>http:</code>' image coder, which is why it works.
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick http://www.ict.griffith.edu.au/anthony/images/anthony_castle.gif \
          -resize 100x100 castle_logo.png
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="castle_logo.png"><img src="castle_logo.png" width="100" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>As you can see this command reads the image from the WWW and resizes it before finally saving the result to disk.
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>When a prefix file format is given, any suffix given as part of the filename does not have any bearing on the way the file is read. This is in fact vital when reading some file formats such as the "<code><a href="../text/#text">text:</a></code>" verses the "<code><a href="#txt">txt:</a></code>" file format handling. Of course if an image generator actually reads in an image file to process it in a special way (for example "<code><a href="../canvas/#tile">tile:</a></code>") then the suffix (or prefix) file formats will again become important, as it was in the last example</i></font></td>
            </tr>
          </table>A special coder prefix "<code>implicit::</code>" can be used to 'turn-off' any use of coders, allowing use of ':' in the filename. Filename can have the special 'file meta-characters', such as '<code>*</code>' and '<code>?</code>' embedded in them. IM will expand these characters to generate a list of filenames to be read in, avoiding the need for an external shell to do this, or problems with command line length limits. For example...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick montage  '*.jpg' -geometry 50x50+2+2  image_index.gif
</samp></pre>
                </td>
              </tr>
            </table>
          </div>This will produce a single montage index image of all the JPEG files in the current directory. Note however that I needed to quote the argument to prevent my UNIX shell from expanding the file names rather than ImageMagick. See below for a more complete "<code>magick montage</code>" specification. Of course the linux shells can also expand '<code>*</code>' and '<code>?</code>' characters passed to them unquoted. However in some cases you may find yourself hitting 'command line limits' if the file list expands to a very large number of filenames. Here are other examples of using a linux shell to expand the filename...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick image_[0-9].gif  image_[1-9][0-9].gif  animation.gif
  magick image_?.gif  image_??.gif  image_???.gif  animation.gif
  magick image_(?|??|???|????).gif  animation.gif
</samp></pre>
                </td>
              </tr>
            </table>
          </div>Also see the <a href="#read_frames">Read Frames, Read Modifier</a> below, for an formated incrementing number in the filename. If the filename is simply the single character string '<code>-</code>' IM reads the image from standard input.
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" no_txt2gif="">
  cat tree.gif | magick - -frame 5x5+2+2 read_stdin.gif
</code></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="read_stdin.gif"><img src="read_stdin.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>Note that some image file formats allow you to simple append multiple image files together in one long multi-image stream. These formats include the simple <a href="../formats/#pbmplus">PbmPlus/NetPBM</a> image formats, as well as IM's own special file format <a href="#miff">MIFF:</a>
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" script="" image="read_multiple_stdin.gif">
  for image in eye.gif news.gif storm.gif
  do
    magick $image  miff:-
  done |
    magick - -frame 5x5+2+2 +append read_multiple_stdin.gif
</code></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="read_multiple_stdin.gif"><img src="read_multiple_stdin.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>The special character '<code>@</code>' at the start of a filename, means replace the filename, with contents of the given file. That is, you can read a file containing a list of files!
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" no_txt2gif="">
  echo "eye.gif news.gif storm.gif" &gt; filelist.txt
  magick @filelist.txt  -frame 5x5+2+2 +append filelist.gif
</code></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="filelist.gif"><img src="filelist.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>You can also use '<code>@</code>' with the special filename '<code>-</code>' to read the filenames from standard input.
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  echo "eye.gif news.gif storm.gif" |\
    magick @- -frame 5x5+2+2 +append filelist_stdin.gif
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="filelist_stdin.gif"><img src="filelist_stdin.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>Reading a list of filenames from a file using the '@' syntax was added in IM v6.5.2-1.</i></font></td>
            </tr>
          </table>
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>As a security precaution this only works with actual image files. It does not work with image generators such as "<code>rose:</code>" or "<code>label:string</code>". It also can not be used to 'include' command line options from a file.</i></font></td>
            </tr>
          </table><a name="read_mods" id="read_mods"></a> <a name="extract" id="extract"></a>
          <h3>Read Modifiers or Extract Setting</h3>Image can be modified immediatally they have been read into memory, but before the image(s) are actually added to the current image sequence. You can specify a "<code><a href="https://imagemagick.org/script/command-line-options.php?#extract">-extract</a></code>" setting. For example, here I crop the rose image...
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick -extract 32x32+20+5 rose: +repage rose_extract.gif
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="rose_extract.gif"><img src="rose_extract.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>Or you can append a read modifier to the end of the filename using square brackets '<code>[...]</code>'. For example...
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick 'rose:[32x32+20+5]' +repage  rose_read_modifier.gif
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="rose_read_modifier.gif"><img src="rose_read_modifier.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>Note however that '<code>[]</code>' characters are usually also special shell meta-characters, so if you use them it is a good idea to quote the additional modifier, to stop UNIX shells interpreting it. Both the "<code><a href="https://imagemagick.org/script/command-line-options.php?#extract">-extract</a></code>" setting and the read modifer does the same job, though the latter will override the former. Also when you use a modifier, you must let IM handle any special file expansion meta-characters, such as '<code>*</code>' and '<code>?</code>', as an UNIX shell will not 'find' the requested files due to the modifier. What it actually does in that case is shell dependant. As such the whole filename should be quoted when using read modifiers. The real purpose of these read modifiers is to limit the amount of memory needed, by removing unwanted images or making images smaller, while images are still being read into memory. For example when readin a whole directory of large JPEG images. Here is the list of all the special read modifiers (and "<code><a href="https://imagemagick.org/script/command-line-options.php?#extract">-extract</a></code>" settings ) and their effects. A '<code>#</code>' represent some number.
          <dl>
            <dd>
              <dl>
                <dt>
                  <a name="read_frames" id="read_frames"></a> '<code>[#]</code>' '<code>[#-#]</code>' '<code>[#,#,#]</code>' <code>[#,#-#,#]</code>'. <b>Read Frames</b>
                </dt>
                <dd>
                  Will select specific sub-frames from a multi-image file format from the image that has been read in. The given number '<code>#</code>' index specifies the frame number to read. Multiple indexes can be specified in either comma order or as an index range. The image index start at zero for the first image, 1 for the second and so on. If you specify a negative index then the count is from the end of the image sequence, in reverse order, -1 for the last image, -2 for the second last image. This is exactly the same convention as used for the <a href="../basics/#list_ops">Image Lists Operators</a>. For example
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick document.pdf'[0]'     first_page_of_pdf.gif
  magick animation.gif'[1-3]'  second_to_fourth_frames.gif
  magick animation.gif'[-1,2]' last_then_the_third_frame.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>You can also get IM to read images based on a list of numbers. For example..
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick 'image_%03d.png[5-7]' ...
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>will read in the files "<code>image_005.png</code>", "<code>image_006.png</code>", and "<code>image_007.png</code>". With this method you can not use a negative index.
                </dd>
                <dt>
                  <a name="read_resize" id="read_resize"></a> '<code>[#x#]</code>' <b>Read Resize</b>
                </dt>
                <dd>
                  From IM version 6.2.6-2 a new modifier was added to help IM users to handle very very large images. This modifier will resize the image that was just read in, immediately before that image is added to the other images already in memory.
                  <table border="0" cellspacing="0" cellpadding="0" width="90%">
                    <tr valign="bottom">
                      <td width="100%" align="justify">
                        This can both shrink images, or enlarge images. For example...
                        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                          <tr>
                            <td>
                              <pre class="bg-light text-dark mx-4"><samp>
  magick pattern:gray95'[60x60]' enlarged_dots.gif
</samp></pre>
                            </td>
                          </tr>
                        </table>
                      </td>
                      <td>
                        <a href="enlarged_dots.gif"><img src="enlarged_dots.gif" width="60" height="60" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                      </td>
                    </tr>
                  </table>Warning, the read modifier does not currently use any of the resize flags, such as <code>'!'</code> (no aspect preserve) or <code>'&gt;'</code> (only shrink larger images. (perhaps if you put in a request?) You can also use it as an alternative way of specifying the size of a solid color canvas. Actually what is happening is that it is resizing the default single pixel image. For example...
                  <table border="0" cellspacing="0" cellpadding="0" width="100%">
                    <tr>
                      <td width="100%" align="justify">
                        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                          <tr>
                            <td>
                              <pre class="bg-light text-dark mx-4"><samp>
      magick 'canvas:DodgerBlue[50x50]'  canvas_size.gif
    </samp></pre>
                            </td>
                          </tr>
                        </table>
                      </td>
                      <td>
                        <a href="canvas_size.gif"><img src="canvas_size.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                      </td>
                    </tr>
                  </table>The modifier is most important when you are attempting to read in lots of very very large images, as each image will be resized before the next image is read, producing a substantial saving in total memory needed to handle those images. For example instead of...
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick montage '*.tiff'  -geometry 100x100+5+5 -frame 4  index.jpg
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>which reads all the tiff files in first, then resizes them. You can instead do...
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick montage '*.tiff[100x100]'  -geometry 100x100+5+5 -frame 4  index.jpg
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>This will read each image in, and resize them, before proceeding to the next image. Resulting in far less memory usage, and possibly prevent disk swapping (<a href="http://en.wikipedia.org/wiki/Thrash_(computer_science)">thrashing</a>), when memory limits are reached.For JPEG images I also recommend you use the special "<code><a href="https://imagemagick.org/script/command-line-options.php?#define">-define</a></code>" setting instead, producing something like...
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick montage -define jpeg:size=200x200 '*.jpg[100x100]' -strip \
          -geometry 100x100+5+5 -frame 4  index.png
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>The special setting is passed to the JPEG library and is used to limit the size the JPEG image during the reading process. However it is not exact, with the resulting image being somewhere between that size or double that size with the aspect ratio preserved. See <a href="../formats/#jpg_read">Reading JPEG Images</a> for more details. The result of the combination is a much faster reading and even lower memory usage for JPEG images. Especially when generating lots of small thumbnails. See <a href="../thumbnails/#creation">General Thumbnail Creation</a>.
                </dd>
                <dt>
                  <a name="read_crop" id="read_crop"></a> '<code>[#x#+#+#]</code>' <b>Read Crop</b>
                </dt>
                <dd>
                  From IM v6.3.1 if you also add an offset the above becomes a crop of the image being read in. For example, To get a smaller 600x400 pixel sub-section from a much larger image.
                  <div align="center">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick 'image.png[600x400+1900+2900]' tileimage.png
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </div>This however will read in the entire image into memory then crop it before it is finally added to the current image sequence. If you want to handle really large images I suggest you look at the "<code><a href="../basics/#stream">stream</a></code>" command and pipe you image into the "<code>magick</code>" command for further processing. See <a href="#massive">Massive Image Handling</a> below.
                </dd>
              </dl>
            </dd>
          </dl>If the image is "<code>gzip</code>"ed, IM will automatically uncompress it, into a temporary file before attempting to figure out the image format and decode the image file format. As such you can not only save images in gzip compressed format, but use them directly in later IM processing. For large text based images this can result in enormous disk space savings.
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>The PNG format includes "<code>gzip</code>" compression as part of its format specification. In this case the first digit of the two digit PNG "<code><a href="https://imagemagick.org/script/command-line-options.php?#quality">-quality</a></code>" setting defines the level of compression. For more detail see <a href="../formats/#png">PNG Image File Format</a> examples.</i></font></td>
            </tr>
          </table>The above is only a short summary of the special input options available when reading images into ImageMagick. A full summary is given on the <a href="https://imagemagick.org/script/command-line-processing.php">The Anatomy of the Command Line</a> page on the <a href="https://imagemagick.org/">ImageMagick Website</a>.<br>
          As shown previously the image input can be modified by some IM settings such as "<code><a href="https://imagemagick.org/script/command-line-options.php?#size">-size</a></code>" for image creation and "<code><a href="https://imagemagick.org/script/command-line-options.php?#define">-define</a> jpeg:size=??</code>" for JPEG reading. Other options also effect image input creation, including, "<code><a href="https://imagemagick.org/script/command-line-options.php?#page">-page</a></code>", "<code><a href="https://imagemagick.org/script/command-line-options.php?#type">-type</a></code>", "<code><a href="https://imagemagick.org/script/command-line-options.php?#dispose">-dispose</a></code>", "<code><a href="https://imagemagick.org/script/command-line-options.php?#delay">-delay</a></code>". See <a href="../basics/#meta-data">Setting/Changing Image Meta-Data</a>.
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>Be very careful when passing an user provided argument to IM in a script, insuring that the argument is what you expect. You do not want to let a web image processing script return an image of the system password file for example.</i></font></td>
            </tr>
          </table><br>
          <a name="read_meta" id="read_meta"></a>
          <h3>Input Filename Meta-Character Handling</h3>
          <div align="center">
            <font size="+2"><b><img src="../img_www/const_barrier.gif" width="39" height="35" align="top"> Under Construction <img src="../img_www/const_hole.gif" width="144" height="50" align="middle"></b></font>
          </div>
          <pre>
Not only does the shell handle meta-characters (unless that argument is
quoted) but IM also does its own form of meta-character handling in filenames.

For example
  magick *.jpg ....

is expanded by the shell BEFORE passing the filenames to IM, while

  magick '*.jpg' ....

will have the shell pass "*.jpg" to ImageMagick, which then expands into
an internal list of filenames!  This was provided for Windows Dos support, and
as a method to preventing command line limit overflows in command such as
"magick mogrify" and "magick montage", which typically process long lists of images.

As such to actually get IM to read a file names literially named on disk as
'*.jpg'  you need to use any of the following forms...

  magick '\*.jpg' ....
  magick "\*.jpg" ....
  magick "\\*.jpg" ....
  magick \\\*.jpg ....

NOTE; the second line is NOT recommended as some shells (not bash) and some
APIs (C programs, possibly PHP) may actually remove the single backslash, and
pass '*.jpg' to IM which it will again expand!

On top of '?' and '*',  IM also adds the meta-character handling of  ':', '%'
and '[...]' for read modifier handling.  These however have a different
meaning  (codec specification, scene number inclusion, and read modifiers) to
normal shell syntax of those meta-characters.

For example DOS uses will need to escape a 'drive-letter' in filename paths
being passed to ImageMagick.  For example...

  magick C\:\path\to\image.jpg ....

Another example is when loading an image containg a time code.  For example..

  magick "time_10\:30.jpg" ....

will read the filename "time_10:30.jpg" from disk.  Without the backslash, IM
may think that the image should be read with a non-existant image file format
(or delegate) "time_10:", and fail in an unexpected way.

An alternative is to use a question mark...

  magick "time_10?30.jpg" ...

However that may also match another file such as "time_10_30.jpg" as well!
</pre><a name="read_compressed" id="read_compressed"></a>
          <h3>Compressing Images</h3>
          <div align="center">
            <font size="+2"><b><img src="../img_www/const_barrier.gif" width="39" height="35" align="top"> Under Construction <img src="../img_www/const_hole.gif" width="144" height="50" align="middle"></b></font>
          </div>
          <pre>
IM will also read files that have been compressed, and given the appropriate
suffix, or image format specification.

That is, an image saved as "image.gif.gz"  will first be uncomressed, before
being decoded from its GIF image format.

Gzipped XPixmap (xpm) and NetPbm/PbmPlus (ppm) images is also automatically
handled, both by Imagemagick, and the formats normal delegate library.  As
such you can use the compressed forms directly either in IM, or in other
programs that understand these file formats.

See  <a href="#save_gzip">Saving Compressed Images</a> below.
</pre>
          <hr>
          <!-- ---------------------------------------------------------------- -->
          <a name="save" id="save"></a>
          <h2>Saving Images</h2>Processing images is well and good but it can be just as important to save the results in the right way. The last argument of the "<code>magick</code>", "<code>magick montage</code>" and "<code>magick composite</code>" defines a filename, and image format for a final write of the image (defailt image output). Though you can also save an image in the middle of an image sequence using "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>" (see below). To specify what file format you want to save your image, or images, you can either use a filename suffix, such as I use in just about all these examples, or prefix the filename with the string "<code>{format}:</code>". For example...
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick tree.gif    GIF:tree_image
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="tree_image"><img src="tree_image" width="32" height="32" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>If you check the resulting image you will find that a GIF image file was actually created, even though the filename itself does not have a "<code>.gif</code>" filename suffix. The case of the format is not sensitive, so you can use either lowercase or uppercase. This image format specification becomes particularly important when you want to save the image to the standard output of the command (using a "<code>-</code>" filename). This special filename does not have a suffix, so you <i>must</i> tell ImageMagick what format to use. If you don't, the image will default to the original image format that the image came from (if known). For example, here we write an IM pixel enumeration to the screen using a "<code>-</code>" to output the result to the standard output.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre><code execute="" out="write_stdout.txt">
  magick tree.gif  -resize 1x3\!  txt:-
</code></pre>
                </td>
              </tr>
            </table>
            <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <a href="write_stdout.txt"><img src="write_stdout.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                </td>
              </tr>
            </table>
          </div>It is also used to pass the image, on to another command such as "<code>magick identify</code>" though a shell 'pipeline', without saving it to a temporary file.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre><code execute="" noimage="" out="write_identify.txt">
  magick tree.gif -resize 200% miff:- | identify -
</code></pre>
                </td>
              </tr>
            </table>
            <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <a href="write_identify.txt"><img src="write_identify.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                </td>
              </tr>
            </table>
          </div>In this case you can also see that the special "<code>-</code>" filename is also used to denote reading an image from standard input by the "<code>magick identify</code>" command. For more information see the offical guide at <a href="https://imagemagick.org/script/command-line-processing.php#output">The Anatomy of the Command Line, Output Filenames</a>. <a name="save_escapes" id="save_escapes"></a>
          <h3>Filename Percent Escapes</h3>The save filename can contain a few special percent escape (<code>%</code>) sequences. Specifically, '<code>%d</code>', '<code>%x</code>', and '<code>%o</code>'. These inserts the images 'scene number' into the file name using the C '<code>printf()</code>' formats. For more information see <a href="#adjoin">Writing a Multi-Image Sequence</a> below. Of course this means that if you want to insert a percent character into the filename you will need to double it ('<code>%%</code>'). As of IM v6.4.8-4 you can now also insert special pre-prepared setting (must start with '<code>filename:</code>' into the final filename. For example...
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" image="rose_70x46.png">
  magick rose: -set filename:mysize "%wx%h" 'rose_%[filename:mysize].png'
</code></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="rose_70x46.png"><img src="rose_70x46.png" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>This saves the built-in rose image into a file containing that images size in pixels. Specifically, the filename "<code>rose_70x46.gif</code>". This will let you (with a little indirection) use any <a href="http://imagemagick.org/script/escape.php">Image Property Percent Escape</a> as part of your output filename. Note that only a '<code>%[filename:<i>label</i>]</code>' image <a href="../basics/#property">Property</a> can be used within the output filename (along with the normal '<code>%d</code>' escape. This restriction is for security reasons and the fact that legitimate image filenames could include '<code>%</code> and '<code>[]</code>'. Warning, do not include the file suffix in the filename setting! IM will not see it, and save the image using the original file format, rather than the one that was included in filename setting. That is, the filename will have the suffix you specify, but the image format may different! The '<code>filename:</code>' setting does not need to be the same for every image. You can generate or even calculate or set a different setting for each image being used. Here is another example where I modify an image, and write it to a new filename, that was built using each individual images original filename.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre><code execute="" image="eye_magnify.gif">
  magick eye.gif news.gif storm.gif    -scale 200% \
          -set filename:f '%t_magnify.%e' +adjoin '%[filename:f]'
</code></pre>
                </td>
              </tr>
            </table><a href="eye_magnify.gif"><img src="eye_magnify.gif" width="64" height="64" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a> <a href="news_magnify.gif"><img src="news_magnify.gif" width="64" height="64" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a> <a href="storm_magnify.gif"><img src="storm_magnify.gif" width="64" height="64" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a>
          </div>This magnifies each image such as "<code>eye.gif</code>" and saves it in the file "<code>eye_magnify.gif</code>" in the current directory. However all three images are read into memory, and then modified by the one command. This is not a recommended solution for a number of large images, or very large numbers of images, due to the posibilty of reaching memory limits and thus going to disk swapping (thrashing). Note that the "<code><a href="https://imagemagick.org/script/command-line-options.php?#adjoin">+adjoin</a></code>" in this case is vital to prevent IM saving all the images into a mutli-image GIF animation, using just the filename of the first image. I also ensured I preserved the original suffix of the filename using the "<code>%e</code>" escape sequence. Normally including the suffix in the filename setting is a bad idea, as IM does not see it when it comes from an escape sequence, for determining the output file format. In this case however the format is not changing so there is no problem. Caution is needed. To get the exact original filename of the image use '<code>%d/%f</code>' or '<code>%d/%t.%e</code>'. You can also use '<code>%m</code>' instead of '<code>%e</code>' which is the actual format (in capitals) that IM found in the original images file (which may not match the original images filename suffix). Note that for built-in images, many of these escape sequence strings are blank. Also if there is no directory the '<code>%d</code> will be blank. This is a known problem for IMv7 Another example of using 'Filename Escape Sequence' is in <a href="../crop/#crop_tile">Tile Cropping Images</a>, where the technique it is used to generate a filename basied on a calculated tile position for each of the resulting images. Also see the example in <a href="../basics/#mogrify_convert">Using Convert Instead of Morgify</a>. <a name="save_gzip" id="save_gzip"></a>
          <h3>Automatic GZip Suffix</h3>IM will also automatically "<code>gzip</code>" images if a "<code>.gz</code>" suffix is given. For example, here I save the built-in "<code>rose:</code>" image as a "<code>gzip</code>"ed, uncompressed GIF file. I turn off the normal LZW compression of GIF, as it would prevent "<code>gzip</code>" compression from achieving its best compression.
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick rose: -compress none  rose.gif.gz
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="rose.gif.gz"><img src="../img_www/doc_art.png" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
              </td>
            </tr>
          </table>How browsers handle a gzipped image depends on the file type returned by the web server and how your browser handled compressed images. Because of this I did not directly display the above image. Click on the 'art' icon to see what your browser does, with such an image from this web server. Compare the size of this to a normal saved LZW compressed GIF image...
          <table border="0" cellspacing="0" cellpadding="0" width="100%">
            <tr>
              <td width="100%" align="justify">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick rose: rose.gif
</samp></pre>
                    </td>
                  </tr>
                </table>
              </td>
              <td>
                <a href="rose.gif"><img src="rose.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
              </td>
            </tr>
          </table><!-- <CODE EXECUTE NOIMAGE OUT=rose_gz_size.txt>
  ls -l rose.gif.gz | awk '{printf "%d", $5}'
</CODE> -->
          <!-- <CODE EXECUTE NOIMAGE OUT=rose_size.txt>
  ls -l rose.gif | awk '{printf "%d", $5}'
</CODE> -->
          The "<code>gzip</code>"ed rose is <a href="rose_gz_size.txt"><img src="rose_gz_size.txt.gif" align="top" vspace="0" hspace="0" border="0" alt="[IM Text]"></a> bytes in size, while a normal LZW compressed rose is <a href="rose_size.txt"><img src="rose_size.txt.gif" align="top" vspace="0" hspace="0" border="0" alt="[IM Text]"></a> bytes. As you can see GZIP compression is actually slightly better than the LZW compression that the GIF format uses, so may be better for archiving purposes. GZipped image files are more commonly used for longer term storage of image file formats that do not have any compression by default. This includes the IM File format "<a href="#miff">MIFF:</a>" and the simpler <a href="../formats/#netpbm">NetPBM</a> image file formats. <a name="save_attributes" id="save_attributes"></a>
          <h3>Saved Attributes</h3>
          <div align="center">
            <font size="+2"><b><img src="../img_www/const_barrier.gif" width="39" height="35" align="top"> Under Construction <img src="../img_www/const_hole.gif" width="144" height="50" align="middle"></b></font>
          </div>
          <pre>
Other Settings specific to image writing....
    -depth  -quality  -compress -type  -loop
    -set label   -set comment
Also see <a href="../basics/#depth">Image Depth</a>,
<a href="../basics/#type">Image Type</a>,
<a href="../formats/#jpg_write">JPEG Quality</a>,
<a href="../formats/#png_quality">PNG Quality</a>.
<a href="../anim_basics/#loop">GIF loop</a>.

Talk about file compressions, which are part of various image formats.

Different compressions are used for different image formats.

Especially the JPEG to TIFF compression change needed.

Using or "<a href="https://imagemagick.org/script/command-line-options.php?#compress">-compress</a>
None" and "<a href="https://imagemagick.org/script/command-line-options.php?#compress">-compress</a>" NetPBM text/binary format selection.

The GIF compression and the copyright patent.

Other than using IM to reduce -quality or changing the format to something
else the -compression option is rarely used.  Often it is only used internally
by IM to save images using the same compression the image was read with.
</pre><a name="save_encrypted" id="save_encrypted"></a>
          <h3>Encrypted Images</h3>IM also allows you save sensitive images with encrypted with a pass phrase using the options "<code><a href="https://imagemagick.org/script/command-line-options.php?#encipher">-encipher</a></code>" and "<code><a href="https://imagemagick.org/script/command-line-options.php?#decipher">-decipher</a></code>". See <a href="../transform/#encipher">Encrypting Images</a> <a name="write_list" id="write_list"></a> <a name="adjoin" id="adjoin"></a>
          <h3>Writing a Multiple Images - Adjoin Techniques</h3>A major problem with saving images, is that ImageMagick works with an ordered sequence (list) of images, not just one image at a time. Because of this IM will attempt to write ALL the images in the current image sequence into the filename given. If the file format allows multiple images IM will by default save all the images in the current image sequence into that image file. For example if you look at the <a href="../anim_basics/">GIF Animation Basics</a> examples page you will see that it will save multiple image frames into a single image file format to produce an animation. If the output format does not allow you to save multiple images into the one file, IM will instead generate multiple files. For example, when saving to image formats like <code>JPEG</code> and <code>PNG</code> and so on. You can also force this behavior on image formats that do allow multiple images per file, such as <code>GIF</code> and <code>PS</code> by using the "<code><a href="https://imagemagick.org/script/command-line-options.php?#adjoin">+adjoin</a></code>" output file handling setting.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre><code execute="" noimage="">
  magick eye.gif news.gif storm.gif  +adjoin  image.gif
</code></pre>
                </td>
              </tr>
            </table><a href="image-0.gif"><img src="image-0.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image-1.gif"><img src="image-1.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image-2.gif"><img src="image-2.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a>
          </div><!-- <CODE EXECUTE ASSERT>
  [ -f image.gif ] && echo >&2 \
    "ASSERTION FAILURE: +adjoin with no %d produces a single image"
</CODE>-->
          If you look closely at the filenames of the three images generated above, you will see that IM generated images named "<code>image-0.gif</code>" to "<code>image-2.gif</code>".
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>Previous to ImageMagick version 6.2.0 the output filename of the above would have been "<code>image.gif.0</code>" to "<code>image.gif.2</code>". This resulted in many problems due to the loss of the filename suffix, so was changed to add the image number, before the filename suffix.</i></font></td>
            </tr>
          </table>An alternative is to add a 'C language printf()' construct "<code>%d</code>" to the output filename. This special string will be replaced by the current image number of each image in sequence.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick eye.gif news.gif storm.gif  +adjoin  image_%d.gif
</samp></pre>
                </td>
              </tr>
            </table><a href="image_0.gif"><img src="image_0.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_1.gif"><img src="image_1.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_2.gif"><img src="image_2.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a>
          </div>Here we generated the images "<code>image_0.gif</code>" to "<code>image_2.gif</code>", using an underscore rather that the IM default of a dash.
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>Not only can you use '<code>%d</code>' for a decimal number, but you can use '<code>%x</code>' for a hexadecimal number (lowercase), '<code>%X</code>' for a hexadecimal number (uppercase), or '<code>%o</code>' for an octal number.<br>
              <br></i></font></td>
            </tr>
          </table>
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>If you really want a percent character which is followed by one of these letters, then you will need to double the percent character to escape its meaning. That is, you will need to use '<code>%%</code>' to ensure you actually generate a percent symbol.<br>
              <br></i></font></td>
            </tr>
          </table>
          <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
            <tr valign="top">
              <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
              <td align="justify" width="100%"><font size="-1"><i>The '<code>%d</code>' in the output filename actually enables the "<code><a href="https://imagemagick.org/script/command-line-options.php?#adjoin">+adjoin</a></code>" setting of ImageMagick, automatically.<br>
              However while I don't actually need the "<code><a href="https://imagemagick.org/script/command-line-options.php?#adjoin">+adjoin</a></code>" in the above, it is probably a good idea to provide it anyway, just so it is clear that you are generating separate images.</i></font></td>
            </tr>
          </table>This works well for a small number of images, but if you have more than ten images you will get a mix of image with one digit and two digit numbers. And if you have more than a hundred, you get three digit numbers too. When that happens, directory listings will no longer list the saved images in sequence, since "<code>image_15.gif</code>" would alphabetically appear before "<code>image_5.gif</code>". Of course there are ways to fix this. For example using a command line shell expressions like..
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick image_[0-9].gif  image_[1-9][0-9].gif  animation.gif
  magick image_?.gif  image_??.gif  image_???.gif  animation.gif
  magick image_(?|??|???|????).gif  animation.gif
  magick 'image_%d.gif[0-123]'  animation.gif
</samp></pre>
                </td>
              </tr>
            </table>
          </div>The last method is the proper IM way of handling a sequence of files, though you need to know the range of number you want to use. The '<code>%d</code>' formats each number to match the filename (see next)In any case, this is awkward and prone to mistakes, can produce errors if files are missing, and can be dependant on what type of computer system you are using. Better to avoid this problem altogether. If you are familiar with the 'C' language (look up the UNIX system man page for '<code>printf</code>') then you will probably know that if you use something like "<code>%03d</code>" you will always get 3 digit numbers (with leading zeros) for the image sequence frame number. The image names would in that case be "<code>images_000.gif</code>", "<code>images_001.gif</code>" and so on.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick eye.gif news.gif storm.gif  +adjoin  image_%03d.gif
</samp></pre>
                </td>
              </tr>
            </table><a href="image_000.gif"><img src="image_000.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_001.gif"><img src="image_001.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_002.gif"><img src="image_002.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a>
          </div>Using this method, the images will not only be numbered, but will also list alphabetically correctly, making image file handling a whole lot easier. I thus recommended you add a '<code>%03d</code>' or whatever is appropriate, to the output filename whenever you plan on writing multiple images, as separate image files. <a name="scene" id="scene"></a>
          <h3>Written Scene Numbers</h3>If you want the image sequence to start at '<code>1</code>', instead of '<code>0</code>', and don't want to rename all the resultant image files, the simplest solution is to prepend a 'junk' image on the front of the sequence to be written.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre><code execute="" nowarn="">
  magick null:  eye.gif news.gif storm.gif  +adjoin  image_%01d_of_3.gif
  rm image_0_of_3.gif
</code></pre>
                </td>
              </tr>
            </table><a href="image_1_of_3.gif"><img src="image_1_of_3.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_2_of_3.gif"><img src="image_2_of_3.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_3_of_3.gif"><img src="image_3_of_3.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a>
          </div>You can, of course, use "<code><a href="https://imagemagick.org/script/command-line-options.php?#insert">+insert</a></code>" to do this after your image processing. This is not a particularly nice solution, but works, and is simple, and backward compatible with the older major versions of IM. As of IM version 6.2 you can use the "<code><a href="https://imagemagick.org/script/command-line-options.php?#scene">-scene</a></code>" setting to set the starting number for the current image sequence.
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick eye.gif news.gif storm.gif  +adjoin -scene 101 image_%03d.gif
</samp></pre>
                </td>
              </tr>
            </table><a href="image_101.gif"><img src="image_101.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_102.gif"><img src="image_102.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a> <a href="image_103.gif"><img src="image_103.gif" width="32" height="32" align="middle" vspace="5" hspace="20" border="1" alt="[IM Output]"></a>
          </div>Which produced the image files "<code>image_101.gif</code>" to "<code>image_103.gif</code>". <!-- <CODE EXECUTE ASSERT>
  [ -f image_101.gif -a -f image_103.gif ] || echo >&2 \
    "ASSERTION FAILURE: scene numbered images were not generated"
</CODE>-->
          <a name="write" id="write"></a>
          <h3>Writing an Image, Multiple Times</h3>While on the subject of writing images, it is possible to write an image from the middle of a sequence of image operations, using the special "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>" image operator. This is very useful when you like to output an image multiple times at various points during image processing. For example, see <a href="../basics/#complex">Complex Image Processing with Debugging</a>. Here is an example where I have a <a href="../img_photos/parrots_orig.png">Photo of some Parrots</a>, curtisy of the <a href="http://r0k.us/graphics/kodak/">Kodak Lossless True Color Image Suite</a> (image 23), but I want to save them in a range of different sizes, using one command...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick parrots_orig.png \
          \( +clone -resize x128  -write  parrots_lrg.jpg +delete \) \
          \( +clone -resize x96   -write  parrots_big.jpg +delete \) \
          \( +clone -resize x64   -write  parrots_med.jpg +delete \) \
                    -resize x32           parrots_sml.jpg
</samp></pre>
                </td>
              </tr>
            </table><a href="parrots_lrg.jpg"><img src="parrots_lrg.jpg" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a> <a href="parrots_big.jpg"><img src="parrots_big.jpg" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a> <a href="parrots_med.jpg"><img src="parrots_med.jpg" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a> <a href="parrots_sml.jpg"><img src="parrots_sml.jpg" align="middle" vspace="5" hspace="15" border="1" alt="[IM Output]"></a>
          </div><!-- <CODE EXECUTE ASSERT>
  [ -f parrots_med.jpg ] || echo >&2 \
    "ASSERTION FAILURE: write did not create an image"
</CODE>-->
          As you can see we can use the <a href="../basics/#list_ops">Image List Operators</a> to process a 'clone' of an image, write out the result, then delete and backtrack back to the original source image, repeating the process as many times as you need. In this particular case it means I did not end up resizing the same image over and over, and thus accumulating resize errors. It also meant I could have just as easily generate the smaller images first, then the larger images after that, without problems, or modify the image in many different ways for each image file generated. That is, the order and modification of each image is irrelevent! Note that "<code><a href="https://imagemagick.org/script/command-line-options.php?#clone">+clone</a></code>" does not actually duplicate the image data! IM uses a reference-counted cloning process which only copies the image pixels when they are updated. As such only enough memory to hold the original image and the new image that is generated is actually used, in the above process. It also makes "<code><a href="https://imagemagick.org/script/command-line-options.php?#clone">+clone</a></code>" very fast, and memory efficient.<br>
          Here is another technique of doing the same thing, but saving the original image in a named image register using "<code><a href="#mpr">MPR:</a></code>" (see below), instead of "<code><a href="https://imagemagick.org/script/command-line-options.php?#clone">-clone</a></code>".
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick scroll.gif  -background lightsteelblue -flatten  -alpha off \
          -write mpr:scroll  -resize x128  -write scroll_lrg.jpg +delete \
                 mpr:scroll  -resize x96   -write scroll_big.jpg +delete \
                 mpr:scroll  -resize x64   -write scroll_med.jpg +delete \
                 mpr:scroll  -resize x32          scroll_sml.jpg
</samp></pre>
                </td>
              </tr>
            </table><a href="scroll_lrg.jpg"><img src="scroll_lrg.jpg" align="middle" vspace="5" hspace="15" border="0" alt="[IM Output]"></a> <a href="scroll_big.jpg"><img src="scroll_big.jpg" align="middle" vspace="5" hspace="15" border="0" alt="[IM Output]"></a> <a href="scroll_med.jpg"><img src="scroll_med.jpg" align="middle" vspace="5" hspace="15" border="0" alt="[IM Output]"></a> <a href="scroll_sml.jpg"><img src="scroll_sml.jpg" align="middle" vspace="5" hspace="15" border="0" alt="[IM Output]"></a>
          </div><!-- <CODE EXECUTE ASSERT>
  [ -f scroll_med.jpg ] || echo >&2 \
    "ASSERTION FAILURE: -write did not create an image"
</CODE>-->
          Here we save one copy of the original image into the "<code>mpr:scroll</code>" image register, before modifying the image still in memory after the write. Note that a MPR register can actually hold a whole sequence of images. Once the results of that operation is written and deleted from memory, the original image (or image sequence) is recovered, and the process repeated as many times as needed. Of course as previously there is no need to use "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>" on the final image, as we can just output it as normal. If you did use a "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>", you can instead just junk the final image using another special file format "<code><a href="#null">NULL:</a></code>" (see below).<b>A word of warning about "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>"</b>: Because some file formats require images to be in a special format for writing, the "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>" operator could modify images. GIF images for example may be color reduced (see <a href="../quantize">Quantization and Dithering</a>). However other formats will leave the source image as is (see <a href="#miff">MIFF</a> and <a href="#mpc">MPC</a> below). If you need protect yourself from these changes (as you are not simply deleting the image afterward), you can use "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">+write</a></code>" which will make an internal clone of the image for writing, then delete it afterwards. However remember that this can result in a doubling of memory use to hold the write modified copy of the image. At least for a moment.
          <hr>
          <!-- ---------------------------------------------------------------- -->
          <a name="special_formats" id="special_formats"></a>
          <h2>Special File Formats <font size="-1">(specific to IM)</font></h2>As you saw above (and will explore in the next section <a href="../formats/">Common Image File Formats</a>), ImageMagick understands a huge number of well known image file formats. It also includes a good number of special image generators (as exampled in <a href="../canvas/">Canvas Creation</a>). On top of these there are also some very special file formats, which allow some very special handling of images.
          <dl>
            <dt>
              <a name="miff" id="miff"></a> <b><code>miff:</code></b>
            </dt>
            <dd>
              Is the ImageMagick File Format. The whole image sequence and <i>all</i> the attributes associated with the images are saved in this file format. Of course only ImageMagick commands will read this format, so it is not suitable for transferring between different image processing packages. The "<code>miff:</code>" file formats primary purpose is as an intermediate save format, when processing images in long an complex ways. It is also suitable for 'pipelining' an image from one IM command to another, while passing image meta-data and other attributes assocated with the image. I recommend when writing "<code>miff:</code>" that you include a "<code><a href="https://imagemagick.org/script/command-line-options.php?#depth">+depth</a></code>" option. This will reset the 'input depth' of the image to the IM memory quality so as to use the best posible quality for the intermediate image save. Of course you can 'clip' the save image depth using "<code>-depth 8</code>" so as to reduce the image size on disk, however that will also force <a href="../basics/#quantum_effects">Quantum Rounding</a> effects as well (unless <a href="../basics/#hdri_formats">HDRI floating-point save</a> is also enabled). For those interested in parsing this format, it starts with a plain text header of all the image attributes. The header end in a line containing a single formfeed character. This header is itself an useful way of extracting basic image information in various image processing processing scripts. For example, here are I use a GNU-sed command to list the "<code>miff:</code>" header up to the formfeed separator, showing all the attributes of the built-in "<code>rose:</code>" image.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" image="write_miff_info.txt" out="write_miff_info.txt">
<br>  magick rose:  miff:-  | sed -n '/^\f$/q; p'
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="write_miff_info.txt"><img src="write_miff_info.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>This is actually quite useful as it reveals all the current settings flags and meta data that IM knows about the image. However there is also statistics, as these are generated by either the "<code>magick identify</code>" command, the "<code><a href="https://imagemagick.org/script/command-line-options.php?#identify">-identify</a></code>" operator or the special "<code>info:</code>" format; if requested with a "<code><a href="https://imagemagick.org/script/command-line-options.php?#verbose">-verbose</a></code>" option. (see next) The image file format has very low parsing requirements, and while not compressed, can handle ANY type image IM knows about. It is almost the most ideal format to use for temporary images, and pipelined image commands you can use, though ImageMagick programs is the only one that can read it. See also the "<code><a href="#mpr">MPR</a></code>" image memory register, and "<code><a href="#mpc">MPC</a></code>" memory disk mapping formats below.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>The raw image data (binary) is actually prefixed by the four character sequence "\n\f\n:", (formfeed on a line by itself, and a colon). How this data should be read is encoded in the header data, but tyically consists of binary integers in RGB turples. But can have more channels, and could even consist of floats or even double data values.<br>
                  <br>
                  In may ways it is practically identical to a binery <a href="../formats/#pbmplus">PbmPlus</a> Image file format,with a greatly expanded header to hold image meta-data, and more variations in number of channels and data types.</i></font></td>
                </tr>
              </table>
            </dd>
            <dt>
              <a name="miff_stream" id="miff_stream"></a> <b>MIFF Image Streaming</b>
            </dt>
            <dd>
              The "<code>miff:</code>" format is a 'streaming' image file format. That is to say multiple images are handled simply by appending or concatenating the images together, one after the other. This means you can generate a 'stream' of multiple images, simply by writing the images to the same destination, such as a pipeline. Even if the individual images were generated by different commands. For example you can have a loop of image processing commands, each command simply outputs a 'streaming' MIFF image. After the loop you can pipe the 'stream' of images into an into a single command to generate montages, collages, animations, or something else. For example the following generates a list of colors starting with the letter 'b', then uses a loop of "<code>magick</code>" commands to generate a labeled color patch, one color at a time. These are then 'piped' into a "<code>magick montage</code>" to generate a simple color table.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick -list color | egrep '^b' | \
    while read color junk; do \
       magick -label $color -size 70x20 xc:$color +depth miff:-; \
    done |\
      magick montage - -frame 5 -tile 6x -geometry +2+2 \
              -background none color_table.png
</samp></pre>
                    </td>
                  </tr>
                </table><a href="color_table.png"><img src="color_table.png" align="middle" vspace="5" hspace="5" border="0" alt="[IM Text]"></a>
              </div>The above specific example was programmed into a script "<b><a href="../scripts/show_colors">show_colors</a></b>" which you can use to search for, find and display colors, for use in your image processing. The above is an example of a '<b>Pipeline of Streaming Images</b> that is very useful for generating multi-image sequences. Other examples of this technique include <a href="../layers/#layer_prog">Programmed Positioning of Layered Images</a>, <a href="../layers/#layer_pins">Pins in a Map</a>, the 'Named Colors Image' in <a href="../color_basics/#color_names">Colors by Name</a>, and the animations such as shown in <a href="../canvas/#random_ripples">Random Ripples</a>. This technique can also be used with operations like "<code>-write miff:-</code>", so as to output a miff format image from multiple places in a single command. Each image will be automatically append together in the final output stream. This can be especially useful for debugging complex image processing commands.The alternative method (commonly using in PHP scripts) is to use a 'generated command' technique, that uses a shell script to generate a long "<code>magick</code>" comamnd to be run. The scripts in <a href="../warping/#animations">Image Warping Animations</a> use this technique.
            </dd>
            <dt>
              <a name="info" id="info"></a> <b><code>info:</code></b>
            </dt>
            <dd>
              The "<code>info:</code>" file format (added in IM v6.2.4) does <i>NOT</i> output an actual image! This format basically outputs the same information that the ImageMagick "<code>magick identify</code>" command will output. Like "<code>magick identify</code>" this output format is controlled by the "<code><a href="https://imagemagick.org/script/command-line-options.php?#format">-format</a></code>" and "<code><a href="https://imagemagick.org/script/command-line-options.php?#verbose">-verbose</a></code>" options allowing you to output just the specific information you are interested in, as defined by the <a href="https://imagemagick.org/script/escape.php">Image Property Escapes</a> page.For example instead of piping a MIFF image to "<code>magick identify</code>" as we did above (see <a href="#saving_images">Saving Images</a>), we could have used the following, to retrieve the single line identification of the resulting image format.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" out="info_image.txt">
  magick granite:  info:-
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="info_image.txt"><img src="info_image.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>Of course you can use a "<code><a href="https://imagemagick.org/script/command-line-options.php?#format">-format</a></code>" setting to output the desired information in a specific and more parsable way. What is so useful about "<code>info:</code>" is that you can now produce your image, while extracting extra information about it, at the same time. This is done by using the "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a></code>" operator to save this special image format to a file (or the commands normal standard output).
              <table border="0" cellspacing="0" cellpadding="0" width="90%">
                <tr>
                  <td width="10%" align="justify"></td>
                  <td width="90%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" err="info_paged.txt">
  magick rose: -shave 12x0 -repage 64x64+9+9 \
          -format '%wx%h %g'  -write info:info_paged.txt    paged.gif
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td align="center">
                    <a href="paged.gif"><img src="paged.gif" width="64" height="64" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
                <tr>
                  <td></td>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <a href="info_paged.txt"><img src="info_paged.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td></td>
                </tr>
              </table>There is also a "<code><a href="https://imagemagick.org/script/command-line-options.php?#identify">-identify</a></code>" operator that is equivalent using "<code><a href="https://imagemagick.org/script/command-line-options.php?#write">-write</a> info:</code>" to output image identification information to standard output. This make it even easier to monitor what is happening to your images when debugging your IM commands. For example...
              <table border="0" cellspacing="0" cellpadding="0" width="90%">
                <tr>
                  <td width="10%" align="justify"></td>
                  <td width="90%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" out="info_thumbnail.txt">
  magick logo:           -identify \
          -trim           -identify \
          +repage         -identify \
          -resize 80x80\! -identify \
          logo_thumbnail.gif
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td align="center">
                    <a href="logo_thumbnail.gif"><img src="logo_thumbnail.gif" width="80" height="80" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
                <tr>
                  <td></td>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <a href="info_thumbnail.txt"><img src="info_thumbnail.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td></td>
                </tr>
              </table>Here you can see how "<code><a href="https://imagemagick.org/script/command-line-options.php?#trim">-trim</a></code>" reduced the size of the image but preserves the 'crop' information of what part of the image was trimmed, then the "<code><a href="https://imagemagick.org/script/command-line-options.php?#repage">+repage</a></code>" removing that extra 'canvas' or 'page' information. And so on. Also like the "<code>magick identify</code>" command, both "<code><a href="#info">info:</a></code>" and "<code><a href="https://imagemagick.org/script/command-line-options.php?#identify">-identify</a></code>", will become much more verbose if the "<code><a href="https://imagemagick.org/script/command-line-options.php?#verbose">-verbose</a></code>" setting is turned on. Here I limit the long output to just the first few lines, just so you can get a bit of an idea about it.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" noimage="" out="info_verbose.txt">
  magick rose: -verbose  info:  | head
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="info_verbose.txt"><img src="info_verbose.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>The "<code><a href="https://imagemagick.org/script/command-line-options.php?#verbose">-verbose</a></code>" setting will also cause extra information about images being read in or out, to be printed to the standard error (with the exception of the "<code>info:</code>" format). It also causes some operators like "<code><a href="https://imagemagick.org/script/command-line-options.php?#colors">-colors</a></code>" to output additional information. As such you may like to turn it off again after using it with either "<code><a href="https://imagemagick.org/script/command-line-options.php?#identify">-identify</a></code>" or the "<code>info:</code>" format.<br>
                  <br>
                  For example &nbsp;&nbsp;</i> "<code>-verbose -write info:image_info.txt +verbose</code>" <i>&nbsp;&nbsp; or &nbsp;&nbsp;</i> "<code>-verbose -identify +verbose</code>" <i>.</i></font></td>
                </tr>
              </table>
              <table border="0" cellspacing="0" cellpadding="0" width="90%">
                <tr valign="top">
                  <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>Scripted reading of the output from any form of "<code><a href="../basics/#identify">identify</a></code>", should do so in a case in-sensitive way. This insures better backward compatibility between different versions of ImageMagick.</i></font></td>
                </tr>
              </table>NOTE: "<code>info:</code>" (and "<code><a href="https://imagemagick.org/script/command-line-options.php?#identify">-identify</a></code>") is only an output format, producing the same output as the "<code><a href="../basics/#identify">identify</a></code>" command. You can not read, or create an image using the "<code>info:</code>" file format. You can also use "<code><a href="https://imagemagick.org/script/command-line-options.php?#print">-print</a></code>" to print information, but that is applied only once against the whole image sequence. That means you can use this operator to calculate much more complex '<code>%[fx:...]</code>' expressions involving multiple images. But remember unlike the other methods above, it is only applied once accross all images.
            </dd>
            <dt>
              <a name="null" id="null"></a> <b><code>null:</code></b>
            </dt>
            <dd>
              As an output format, this will just 'junk' the image results. As such if used as the final argument in a "<code>magick</code>", "<code>magick montage</code>", or "<code>magick composite</code>" command the final result will not be saved! Why? Well it may be that you are more interested in specific images, generated during image processing rather than the overall result, especially when debugging. For example, here we extract and save one image, from an image sequence, then junk all the other images using "<code>null:</code>".
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick eye.gif news.gif storm.gif tree.gif rose: logo: \
            \( -clone 2 -write write_storm.gif \)   null:
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="write_storm.gif"><img src="write_storm.gif" width="32" height="32" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>This is a lot simpler than attempting to delete all the other images one at a time. As an input image format however, "<code>null:</code>" will generate a special placeholder image of a single transparent pixel, with with a special 'null source' flag, in the current image sequence. This special image is especially important to <a href="../montage/#null">Leave Gaps in a Montage</a>, and as a list separator for multi-image <a href="../anim_mods/#composite">Layer Composition</a>. It is closely related to another special image format known as a '<a href="../crop/#crop_missed">missed image</a>', that can be generated for operations like "<code><a href="https://imagemagick.org/script/command-line-options.php?#crop">-crop</a></code>". This image format is produced when an operation produces an empty or non-sensible result. Both images are a single transparent pixel, and as such "<code>null:</code>" images will also be treated as if it is a '<a href="../crop/#crop_missed">missed image</a>'. At this time there is no method to remove any "<code>null:</code>" or even '<a href="../crop/#crop_missed">missed image</a>', from the current image sequence. However such a method has been proposed. Mail me if you find you need such a method.
            </dd>
            <dt>
              <a name="txt" id="txt"></a> <b><code>txt:</code></b>
            </dt>
            <dd>
              This is a simple ASCII text file, which basically lists each pixel in the image, one per line. It is not a general text to image converter, for that see <a href="../text/#text">Multi-line Text Files Examples</a>. If the 'pixel enumeration' is not reconised, the image will be passed to the "<code><a href="../text/#text">text:</a></code>" format coder, for rendering as a plain text file. For example, here is a "<code>netscape:</code>" image scale to a 2x2 pixel image, then listed using a "<code>txt:</code>" image format.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick netscape: -scale 2x2\! txt_netscape.txt
</samp></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="txt_netscape.txt"><img src="txt_netscape.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>The first line (header) of the image is packed with the basic information about the image. The information consists of... <i>File Magic:</i> The image header defines this file as a the special IM text image format (EG a "ImageMagick pixel enumeration" file), this is known in computing circles as the files 'magic' or the code string which identifies this file as being this specific file format. <i>Image Size:</i> The next two numbers define the size of the image contained in this file. Multiplying these numbers together will also tell you how many lines should follow the header to fully define the image. IM will always output this many lines, though as you will see later when reading you do NOT need to define ALL the pixels. <i>MaxValue:</i> The last number in the header defines the 'maximum value' of the image data that is possible. In the above examples this was '<code>255</code>' which is a result of using a 8 bit depth. The reason it output the built-in "<code>netscape:</code>" image at this depth is because it was defined internally using 8-bit values, and as such IM preserved this depth level for the image. See the section on the <a href="../basics/#depth">Depth Setting</a> for more information. But you can override the depth setting (up to the limit of your IM's Q or <a href="../basics/#quality">Compile-time Quality</a> setting, by changing the images "<code><a href="https://imagemagick.org/script/command-line-options.php?#depth">-depth</a></code>". For example, here I output the color values as 16 bit values (from 0 to 65535)...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick netscape: -scale 2x2\! -depth 16 txt_netscape_16.txt
</samp></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="txt_netscape_16.txt"><img src="txt_netscape_16.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>At this time you can not set a specific 'Maximum Value' to use in the output file format. You can only define a different value in terms of the current "<code><a href="https://imagemagick.org/script/command-line-options.php?#depth">-depth</a></code>" setting, making the maximum value equal to <code>2^depth-1</code>.</i></font></td>
                </tr>
              </table><i>Colorspace:</i> The last item in the header defines the <a href="../color_basics/#colorspace">colorspace</a> of the data that follows. If the image contained any transparency, a final letter '<code>a</code>' (for alpha) is also appended to the colorspace name, and an extra column of numbers added between parenthesis. Grayscale images will output an image as '<code>grey</code>', but will define at least three numbers, which will be the same value for each pixel. For example, here is the same image using a <a href="../color_basics/#colorspace">colorspace</a> of '<code>LAB</code>' with an alpha channel added!
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre class="bg-light text-dark mx-4"><samp>
  magick netscape: -scale 2x2\! -colorspace LAB -alpha set txt_cspace_lab.txt
</samp></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="txt_cspace_lab.txt"><img src="txt_cspace_lab.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div><!-- <CODE EXECUTE ASSERT>
  magick rose: -depth 16 txt:- |\
    head -1 | grep -i ,RGB\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output using RGB FAILED\!"
  [ "`magick rose: txt:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'`" -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using RGB FAILED\!"

  magick rose: -alpha set -depth 16 txt:- |\
    head -1 | grep -i ,RGBA\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output RGB with alpha FAILED\!"
  [ "`magick rose: -alpha set txt:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'`" -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using RGB with alpha FAILED\!"

  magick rose: -colorspace CMYK -depth 16 txt:- |\
    head -1 | grep -i ,CMYK\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output using CMYK FAILED\!"
  [ "`magick rose: -colorspace CMYK txt:- |\
        magick - -colorspace RGB miff:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'`" -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using CMYK FAILED\!"

  magick rose: -colorspace CMYK -alpha set -depth 16 txt:- |\
    head -1 | grep -i ,CMYKA\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output CMYK with alpha FAILED\!"
  [ "`magick rose: -colorspace CMYK -alpha set txt:- |\
        magick - -colorspace RGB miff:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'`" -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using CMYK with alpha FAILED\!"

  magick rose: -colorspace LAB -depth 16 txt:- |\
    head -1 | grep -i ,LAB\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output LAB FAILED\!"
  [ "`magick rose: -colorspace LAB txt:- |\
        magick - -colorspace RGB miff:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'`" -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using LAB FAILED\!"

  magick rose: -colorspace LAB -alpha set -depth 16 txt:- |\
    head -1 | grep -i ,LABA\$ >/dev/null || echo >&2 \
    "ASSERTION FAILURE: TXT output LAB with alpha FAILED\!"
  [ `magick rose: -colorspace LAB -alpha set txt:- |\
        magick - -colorspace RGB miff:- |\
          magick compare -dissimilarity-threshold 1 -metric PAE - rose: null: 2>&1 |\
            sed 's/ .*//'` -gt 10 ] && echo >&2 \
    "ASSERTION FAILURE: TXT read using LAB with alpha FAILED\!"
</CODE> -->
              After the initial header are the <i>Pixel Data</i> lines, one per pixel in the image. <i>Coordinates:</i> The first two numbers up to the colon '<code>:</code>' is the pixel position, starting from 0. <i>Color Values:</i> After this the color values for the pixel (from 0 to the <i>MaxValue</i> given in the header) is given in parenthesis, with anywhere from 3 to 5 numbers depending on the current colorspace for the image. Spaces are optional so caution is advised when parsing the numbers in parenthesis.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>The values are normally intergers. However as of IM v6.9.2-1, if the special define "<code><a href="https://imagemagick.org/script/command-line-options.php?#define">-define</a> txt:compliance=css</code>" is given with "<code><a href="https://imagemagick.org/script/command-line-options.php?#depth">-depth</a> 16</code>" the values will be represented as percentage values with '<code>%</code>' signs. This is part of SVG, CSS compliance.</i></font></td>
                </tr>
              </table><i>Color Comments:</i> Anything that follows the numbers in parenthesis, is regarded as comment. IM will fill in extra information on the pixel color using formats that it can parse as a color argument (See "<code><a href="https://imagemagick.org/script/command-line-options.php?#fill">-fill</a></code>" manual entry for details of these color specifications). The color comments are however variable, though typically it will start with a hash ('<code>#</code>') hexidecimal color value, after which it may output RGB() values, or color names depending of the pixel data given. These colornames should be understood by ImageMagick, but are meant as a referance only, as it is purely a comment. Exactly what colors is provided is highly dependant on the IM version you are using, especially in early IM v6 versions and before. There is no guarantee that this comment area will not change again in the future, so it is best not to rely on it. IM doesn't when reading a Pixel Enumeration Image. Here is an example of correctly reading a Pixel Enumeration in a shell script. The exact format of the TXT image is defined by the convert command, then '<code>tail</code>' is used to junk the header, '<code>tr</code>' to character replace every non-number character with a single space, so that the later '<code>while</code>' can read the numbers easily, junking any later comment numbers that may have been left over.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" script="" out="txt_shell_read.txt">
  magick rose: -resize 3x2\! -depth 8 -colorspace RGB -alpha off txt:- |
    tail -n +2 | tr -cs '0-9.\n'  ' ' |
      while read x y r g b junk; do
        echo "$x,$y = rgb($r,$g,$b)"
      done
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="txt_shell_read.txt"><img src="txt_shell_read.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div><br>
              <b>Reading TXT images</b> is also valid. You do not need to define ALL the pixels in the image. In fact you do not even need to have the pixels in the correct order! ImageMagick will just read each pixel defining line in turn, and 'draw' it onto a blank image canvas. Only the numbers in the parenthesis on each line is used for this, not the color names. The initial blank canvas, is cleared and set to the current background color. As such any pixel not provided by a "<code>txt:</code>" image, will be left as this color. For interesting use of "<code>txt:</code>" images, look at <a href="../distorts/#forward_mapping">Forward Pixel Mapping</a> where I output an Enumerated Pixel Image, then change each of the pixel locations so as to rotate (distort) the image, before reading the Enumerated Pixel Image, back into IM again. In the resulting image some pixel locations were not defined, while other locations had multiple pixels added. IM handled this without problems.<br>
              The "<code>txt:</code>" format is especially useful with the "<code><a href="https://imagemagick.org/script/command-line-options.php?#unique-colors">-unique-colors</a></code>" operator, which replaces each image in the current image sequence with a new image containing one pixel for each unique color found. When this is output to a "<code>txt:</code>" format file, you get a basic summary of the colors contained in an image (though not their counts, or histogram). For example, here are the colors used by the tree image. As GIF can only use 8 bit numbers, the colors is also output at the same <a href="../basics/#depth">Depth</a>.
              <table border="0" cellspacing="0" cellpadding="0" width="90%">
                <tr valign="top">
                  <td width="10%" align="justify" rowspan="2"></td>
                  <td width="90%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" noimage="" out="tree_colors.txt">
  magick tree.gif -unique-colors txt:-
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td align="center" rowspan="2">
                    <a href="../images/tree.gif"><img src="../images/tree.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
                <tr>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <a href="tree_colors.txt"><img src="tree_colors.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                        </td>
                      </tr>
                    </table>
                  </td>
                </tr>
              </table>There is another alternative to using the IM "<code>txt:</code>" format using the various <a href="../formats/#netpbm">NetPBM image file formats</a>. IM by default outputs this format as binary, but you can turn off "<code><a href="https://imagemagick.org/script/command-line-options.php?#compress">-compress</a></code>" to output an ASCII text version of the NetPBM format. For example.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" txt2gif="">
    magick tree.gif -unique-colors -compress None -depth 8 tree_netpbm.ppm
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="tree_netpbm.ppm"><img src="tree_netpbm.ppm.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>You may notice that the numbers in the above matches the number in the IM's Enumerated Pixel ("<code>txt:</code>") format. See <a href="../canvas/#gradient_resize">Resized Gradient</a> for some examples of generating a NetPBM format image for IM to read. If you just want the color of a specific pixel you can crop the image down to one pixel, and output it as a "<code>txt:</code>" image.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" out="rose_one.txt">
  magick rose: -crop 1x1+12+26 txt:
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="rose_one.txt"><img src="rose_one.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>Or you can use a special <a href="../transform/#fx_escapes">FX Escape Format</a> to output the color in a form directly usable by IM.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" out="rose_pixel.txt">
  magick rose: -format '%[pixel:u.p{12,26}]' info:
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="rose_pixel.txt"><img src="rose_pixel.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>See also <a href="../quantize/#extract">Extracting Image Colors</a>.
            </dd>
            <dt>
              <a name="sparse-color" id="sparse-color"></a> <b><code>sparse-color:</code></b>
            </dt>
            <dd>
              This is a special output image format that will return a simple comma separated list of coordinates and colors for each pixel that is not transparent. The output string is suitable for direct input into the <a href="../canvas/#sparse-color">Sparse Color Operator</a>. For example this finds the few pixels 'closest' to a pure red color in the "<code>rose:</code>" image.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" out="rose_sparse.txt">
  magick rose: -alpha set -fuzz 13% +transparent red sparse-color:
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="rose_sparse.txt"><img src="rose_sparse.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>In many ways this is more useful that the "<code><a href="#txt">txt:</a></code>" format shown above, but only if a couple of pixels are involved. Be warned however that at the time of writing, the output is all one line. Shell scripts may like to magick the spaces in the output to newlines.
            </dd>
            <dt>
              <a name="histogram" id="histogram"></a> <b><code>histogram:</code></b>
            </dt>
            <dd>
              This is actually the "<code><a href="#miff">miff:</a></code>" image format, but with a very large image comment that contains a complete count of all the colors within the image. That is, in the "<code><a href="#miff">miff:</a></code>" text header '<code>Comment={...}</code>' attribute. For example, here we again list the colors present in the "tree" image, but this time including the pixel count for each color. The text histogram comment is extracted from the "<code>histogram:</code>" image using a secondary "<code><a href="#info">info:</a></code>" formatted magick identify.
              <table border="0" cellspacing="0" cellpadding="0" width="90%">
                <tr valign="top">
                  <td width="10%" align="justify" rowspan="2"></td>
                  <td width="90%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" noimage="" out="tree_histogram.txt">
  magick tree.gif  -define histogram:unique-colors=true \
           -format %c histogram:info:-
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td align="center" rowspan="2">
                    <a href="../images/tree.gif"><img src="../images/tree.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
                <tr>
                  <td>
                    <table border="0" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <a href="tree_histogram.txt"><img src="tree_histogram.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                        </td>
                      </tr>
                    </table>
                  </td>
                </tr>
              </table>
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
                  <td align="justify" width="100%">
                    <font size="-1"><i>The "<code>info:</code>" output format was added to IM v6.2.4. For IM versions before this use..</i></font>
                    <div align="center">
                      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="95%" bgcolor="#F8F8F8">
                        <tr>
                          <td>
                            <pre class="bg-light text-dark mx-4"><samp>
  magick tree.gif histogram:- | identify -format %c -
</samp></pre>
                          </td>
                        </tr>
                      </table>
                    </div>
                  </td>
                </tr>
              </table>You will note that the format is almost exactly the same as that of the previous TXT, or IM Pixel Enumeration Image format, including the comments on the color values. The only difference is that the X,Y location has been replaced by a count of the number of pixels.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/warning.gif" width="28" height="28"><img src="../img_www/space.gif" width="12" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>This comment can take a very long time to create. As of IM v6.6.1-5, you can add the special setting "<code><a href="https://imagemagick.org/script/command-line-options.php?#define">-define</a> histogram:unique-colors=false</code>" which will turn off this comment generation if you do not need it.</i></font></td>
                </tr>
              </table>The image itself is a histogram graph, 256x200 pixels in size. The x-axis is color value (0-255) and the y-axis is pixel count (normalized to the number of pixels). The histogram for each channel is displayed in the color it represents, and added together. Thus, red and blue overlap to make magenta. In other words with color channel has its own separate histogram.
              <table border="0" cellspacing="0" cellpadding="0" width="100%" align="center">
                <tr valign="top">
                  <td width="100%" align="justify">
                    If you want the image converted to some other format, just save it into that format. "<code>histogram:</code>" is a special image processing format. It will magick the image, then output in the format specified by the filename suffix or further "<code><i>format</i>:</code>" codes.
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick rose: \
          -define histogram:unique-colors=false \
          histogram:histogram.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="histogram.gif"><img src="histogram.gif" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>An image that is very dark will be heavily weighted to the left, while a light image will be heavily weighted to the right. Mid-tones, likewise, are represented in the middle. To see this better here I separate the histograms for each of the color channels. I also strip the histogram text comment (if still present), and resize the image for display.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" noimage="">
  magick histogram.gif -strip -resize 50% -separate  histogram-%d.gif
</code></pre>
                    </td>
                  </tr>
                </table>
                <table>
                  <tr>
                    <td></td>
                  </tr>
                  <tr>
                    <td align="center">
                      <a href="histogram-0.gif"><img src="histogram-0.gif" width="128" height="100" align="middle" vspace="5" hspace="10" border="1" alt="[IM Output]"></a><br>
                      Red
                    </td>
                    <td align="center">
                      <a href="histogram-1.gif"><img src="histogram-1.gif" width="128" height="100" align="middle" vspace="5" hspace="10" border="1" alt="[IM Output]"></a><br>
                      Green
                    </td>
                    <td align="center">
                      <a href="histogram-2.gif"><img src="histogram-2.gif" width="128" height="100" align="middle" vspace="5" hspace="10" border="1" alt="[IM Output]"></a><br>
                      Blue
                    </td>
                  </tr>
                </table>
              </div>For the "<code>rose:</code>" image above you will see that red is spread more showing its vital importance in the image. On the other hand green and blue spikes on the left, showing that is has very little influence on the image at all.
              <table border="0" cellspacing="0" cellpadding="0" width="100%" align="center">
                <tr valign="top">
                  <td width="100%" align="justify">
                    If you are more interesting in the brightness of an image rather than its colors, magick the image to a gray-scale before generating a "<code>histogram:</code>" image.
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick rose: -colorspace Gray \
          -define histogram:unique-colors=false \
          histogram:histogram_gray.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="histogram_gray.gif"><img src="histogram_gray.gif" width="256" height="200" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>As you can see the histogram of a gray-scale image is a little different. As the predominate red color become more of a mid-tone grey color, producing a spike in the center of the histogram. Also the small area of off-white in the image now produces a distinct spike at the extreme right of the graph. The completely empty space at the extreme left also shows that there are no dark patches in the image at all.
              <table border="0" cellspacing="0" cellpadding="0" width="100%" align="center">
                <tr valign="top">
                  <td width="100%" align="justify">
                    On the other hand a better 'global' histogram can be generated by simply separating all the color channels in the original image and appending. The resulting histogram is a representation of all the color values regardless of which channel that value is from.
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick rose: -separate -append \
          -define histogram:unique-colors=false \
          histogram:histogram_values.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="histogram_values.gif"><img src="histogram_values.gif" width="256" height="200" align="middle" vspace="0" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>Unfortunately as "<code>histogram:</code>" is an output format, you will either need to 'pipe' the image into another command, save it to disk, or use the special "<code><a href="#mpr">mpr:</a></code>" save/read, if you want to process the image further. See example in "<code><a href="#mpr">mpr:</a></code>" below. It would good if some method of generating histograms (and other graphs) became available as operators rather than a special output format.
            </dd>
            <dt>
              <a name="mpr" id="mpr"></a> <b><code>mpr:<i>{label}</i></code></b>
            </dt>
            <dd>
              (Memory Program Register) will save the whole image sequence into a named memory register, from which you can later read the image data. As such if you want to save an image for use latter, in a complex image operation you can do so. Writing to a "<code>mpr:</code>" at the end of processing is useless, as the program memory is returned back to the system when the program finishes. As such you will want to use a <a href="#write">Write</a> operation to save the images to a file in the middle of your processing steps, if you need it in a different process. The '<i>label</i>' given to "<code>mpr:</code>" can be anything you like, it is only a label on where the image was saved in memory. It can even be just a simple number for people who do scripting and don't want to deal with names, though names could make your script easier to follow. After you have saved an image see below), you can then read in the image again, from the same 'labelled' memory location, as many times as you like. For example...
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick tree.gif -write mpr:tree  +delete \
          \
          mpr:tree  mpr:tree  mpr:tree   +append  mpr.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="mpr.gif"><img src="mpr.gif" width="96" height="32" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>Note the use of "<code><a href="https://imagemagick.org/script/command-line-options.php?#delete">+delete</a></code>" in the above image processing. In the above it is not necessary (just re-read the "<code>mpr:tree</code>" two times instead of three), but it is very common to <a href="../basics/#delete">Delete</a> all images from the current image sequence after saving the images in a "<code>mpr:</code>" register. Basically the two lines in the above can be thought of as two completely separate "<code>magick</code>" commands, but using a named memory register for the intermediate image rather than disk space. In many ways using "<code>mpr:</code>" is like using <a href="../basics/#clone">Clone</a> or <a href="../basics/#duplicate">Duplicate</a> (which we could have used in the above example), but using "<code>mpr:</code>" allows use to completely remove all the images, to clear the current image list for other work. The best feature of this method is that it also allows you to use settings and operations that only work on image input. For example, using it with the input image "<code><a href="../canvas/#tile">tile:</a></code>" operator to tile an image over a larger area.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick tree.gif -flip   -write mpr:tree  +delete \
          -size 64x64 tile:mpr:tree   mpr_tile.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="mpr_tile.gif"><img src="mpr_tile.gif" width="64" height="64" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>You can also use "<code>mpr:</code>" to grab the output of some of the special output image format filters for further processing. For example here we save the output image from "<code><a href="#histogram">histogram:</a></code>" and then read it back in continue to processing it in the same command,
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick rose: -define histogram:unique-colors=false \
          -write histogram:mpr:hgram  +delete \
          mpr:hgram  -strip  -resize 50%  histogram_resized.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="histogram_resized.gif"><img src="histogram_resized.gif" width="128" height="100" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>The "<code>mpr:</code>" in-memory save is actually the only way you can re-use images already in-memory through special I/O filters such as an output file format like "<code><a href="#histogram">histogram:</a></code>" or an input file format like "<code><a href="../canvas/#tile_memory">tile:</a></code>". The same is true for the special options that take an actual input image, such as "<code><a href="https://imagemagick.org/script/command-line-options.php?#tile">-tile</a></code>" or for "<code><a href="https://imagemagick.org/script/command-line-options.php?#map">Color Mapping</a></code>" images using another image as a source. See <a href="../quantize/#map_common">Multi-image Color Maps</a>. NOTE that such options are being replaced in IMv7 with versions that do not need the image to be read from a file. It is also the only way to use the <a href="../draw/#image">-draw 'image'</a> method to overlay images using a generated in-memory image, though there are lots of other techniques to do this. The "<code>mpr:</code>" image actually saves the <i>whole image sequence</i> and not just one image. It is a bit like taking a snapshot of the current image sequence so you can reload it later on for further processing. This for example allow you to take copies of a whole animation sequence, for duplicating or cloning, without needing to know how many images are actually involved. See <a href="../anim_mods/#composite">Layers Composition</a> for an example of doing this. When you do have multiple images in "<code>mpr:</code>" you can actually still extract individual images from that sequence! Using "<code>mpr:image'[2]'</code>" will pull the third image from a multi-image sequence saved using "<code>-write mpr:image</code>". For example, here I extract the 'storm' image from a set of four images.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  magick eye.gif news.gif storm.gif tree.gif \
          -write mpr:images  -delete 0--1 \
          \
          mpr:images'[2]'   mpr_extract.gif
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="mpr_extract.gif"><img src="mpr_extract.gif" width="32" height="32" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>The <a href="../basics/#clone">Image Cloning</a> operator cannot generally handle an unknown variable number of images, and in fact before the <a href="../basics/#clone">Clone</a> operator was added "<code>mpr:</code>" was the only method available for duplicating in-memory images, without using intermediate disk files.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr valign="top">
                  <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
                  <td align="justify" width="100%"><font size="-1"><i>As of IM v6.8.2 you can also store images in a remote IM caching daemon process. This allows images (and there meta-data) to be passed between separately running IM commands, without needed disk space. See <a href="https://imagemagick.org/script/distribute-pixel-cache.php">Distributed Pixel Cache Daemon</a></i></font></td>
                </tr>
              </table>
            </dd>
            <dt>
              <a name="mpc" id="mpc"></a> <b><code>mpc:</code></b>
            </dt>
            <dd>
              Is a special IM specific disk save format that was originally designed with really large images in mind. Basically is is a memory-mapped disk file of program memory, saved to disk as <b>two</b> binary files, a "<code>.mpc</code>" holding the meta-data of the image, and a "<code>.cache</code>" holding the images pixel-cache.
              <div align="center">
                <b>The "<code>MPC:</code>" format creates two files to save one image</b>
              </div>Such files will not work after IM is recompiled or upgraded, and only for the IM compiled for a specific machine. As such it is only good for temporary 'quick read' files, such as in holding temporary images used by scripted image processing, and not long term storage. For example...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick very_big_image.tif  very_big_image.mpc
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>will create two files on disk. A small "<code>very_big_image.mpc</code>" file and a special memory dump file called "<code>very_big_image.cache</code>". The second file size will likely be very much larger that any other image file format as it is just a raw, uncompressed memory dump. However the file does not need to be 'read in' or 'decoded' but can be directly 'paged' into computer memory, and used exactly as-is, without any processing overhead. Only lots of disk space and disk IO. In other words it only needs disk access time to read, without any file format processing. That is, no decoding of the data needed. Because the image is 'memory-ready' it is especially useful for temporary images of all sizes as it will be usable immediately by the next IM command you issue. But remember, two files are generated and they will be larger than a normal image filesize, so be careful of your disk usage, and script cleanup. My own IM scripts make good use of this feature. For example see the scripts "<a href="../scripts/de-pixelate">de-pixelate</a>", and "<a href="../scripts/divide_vert">divide_vert</a>", which make use of quite a large number temporary image files for image processing operations. This can be extremely useful for scripts or <a href="../basics/#mogrify_compose">Mogrify Alpha Compositing</a> that needs to be able to read the same image, over and over and over again, as IM does not have to decode the image, or use up lots of memory just to store it. This is also very useful for processing a very large image, where you must extract or <a href="../crop/#crop">Crop</a> a smaller section of the image for the for actual processing. However as most image operations actually make clone copies of images during processing, a new in-memory copy, could still be made. As such some care is still needed. A <a href="../crop/#crop">Crop</a> or <a href="../resize/#resize">Resize</a> to much smaller image sizes are the safest operations for MPC large image handling. For more information see <a href="#massive">Really Massive Image Handling</a> below.
            </dd>
            <dt>
              <a name="fd" id="fd"></a>
            </dt>
            <dt><b><code>fd:{file_descriptor}</code></b></dt>
            <dd>This special file name which allows you to specify a specific '<i>file descriptor</i>' the image is to read from or written to. The name '<code>fd:0</code>' is the '<i>standard input</i>' and '<code>fd:1</code>' is the '<i>standard output</i>' of the program. These are equivalent to using a '<code>-</code>' as a file name. However you can specify any '<i>file descriptor</i>' to with to read/write the image. Including '<code>fd:2</code>' for '<i>standard error</i>', or whatever other previously opened file handle the parent program may have arranged. The most common use for this is in very advanced shell scripting, where you may have multiple file streams of images. Or for network daemons that may have multiple file streams open simultaneously.</dd>
            <dt>
              <a name="inline" id="inline"></a>
            </dt>
            <dt><b><code>inline:{base64_file|data:base64_data}</code></b></dt>
            <dd>
              Inline images let you read an image defined in a special base64 encoding. For example to read a base64 encoded image use...
              <div align="center">
                <code>inline:base64_image.txt</code>
              </div>This encoding could be from a file, but it is more typically given directly as the read argument instead of as a file name from some external image source. This is more typically used an alternative to 'blobs' on the command line, or in API image processing. Or put the image data directly on the command line...
              <div align="center">
                <code>inline:data:mime-type;base64,/9j/4AAQSk...knrn//2Q==</code>
              </div>For example lets base64 encode a very small image (there are many programs that will let you do this conversion)...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" noimage="" out="b64_image.txt">
  openssl enc -base64 -in noseguy.gif
</code></pre>
                    </td>
                  </tr>
                </table>
                <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <a href="b64_image.txt"><img src="b64_image.txt.gif" align="middle" vspace="0" hspace="0" border="0" alt="[IM Text]"></a>
                    </td>
                  </tr>
                </table>
              </div>Note base64 data can contain any amount of white space such as returns and newlines. It is simply ignored by the format. It also only uses normal ASCII characters, which is why it is used to encode binary data for email and web pages. It also allows binary data to be stored in programs and scripts without problems. For example I could have the following command in a shell script so the script itself has the image built into it, and thus does not need a separate external image source.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" script="" image="b64_noseguy.gif">
  magick 'inline:data:image/gif;base64,
      R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA
      AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE
      YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r
      pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs=
    '  b64_noseguy.gif
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="b64_noseguy.gif"><img src="b64_noseguy.gif" width="32" height="32" align="middle" vspace="5" hspace="5" border="0" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>Remember with this the image could be used in your script (shell or API). You do not needing to have a separate external image file, making installation of an otherwise simple script more complicated. <i>So why does "<code><a href="#inline">inline:</a></code>" have this rather complicated form?</i> Basically because this is the format used for inline images in HTML web pages. For example in the following the image on the right was included directly inline on the web page, and not as a separate external file, using HTML tag of the form...
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre class="bg-light text-dark mx-4"><samp>
  &lt;IMG SRC="data:image/gif;base64,
        R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA
        AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE
        YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r
        pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs="
      ALT="Nose Guy" WIDTH=32  HEIGHT=32  VSPACE=5 HSPACE=5 BORDER=0 &gt;
</samp></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td><img src="data:image/gif;base64,%20R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA%20AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE%20YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r%20pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs=" alt="Nose Guy" width="32" height="32" vspace="5" hspace="5" border="0"></td>
                </tr>
                <tr>
                  <td align="center"><font size="-1"><i>This will not work with all web browsers, for example it will not work with IE7 and earlier, but will work with IE8. Basically the most modern web browsers understand it.</i></font></td>
                </tr>
              </table>The same type inline data format is also used for 'face' images in EMail headers, and probably many other file types. ASIDE: Thanks to the 'magic' part of ImageMagick, most image file formats do not need to have the mime-type (the '<code>image/gif</code>' part of the long string) included. And in actual fact it is completely ignored by IM in any case). However the comma '<code>,</code>' is still required to mark the end of that part of the inline image data string.
              <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
                <tr>
                  <td width="100%" align="justify">
                    <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                      <tr>
                        <td>
                          <pre><code execute="" script="" image="b64_folder.gif">
  magick 'inline:data:,R0lGODlhEAAOALMAAOazToeHh0tLS/7LZv/0jvb29t/f3//U
       b//ge8WSLf/rhf/3kdbW1mxsbP//mf///yH5BAAAAAAALAAAAAAQAA4AAARe8L1Ek
       yky67QZ1hLnjM5UUde0ECwLJoExKcppV0aCcGCmTIHEIUEqjgaORCMxIC6e0CcguW
       w6aFjsVMkkIr7g77ZKPJjPZqIyd7sJAgVGoEGv2xsBxqNgYPj/gAwXEQA7
    '  b64_folder.gif
</code></pre>
                        </td>
                      </tr>
                    </table>
                  </td>
                  <td>
                    <a href="b64_folder.gif"><img src="b64_folder.gif" width="16" height="16" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>WARNING: Command line option input is restricted to 5000 characters. Also many shells (and particularly PC-DOS input) has total command line length limits. As such this is not suitable for very large base64 images.
            </dd>
            <dt>
              <a name="clipboard" id="clipboard"></a> <b><code>clipboard:</code></b>
            </dt>
            <dd>Read or Write the image to or from the Windows Clipboard. (Windows only).</dd>
            <dt>
              <a name="ephemeral" id="ephemeral"></a> <b><code>ephemeral:{image_file}</code></b>
            </dt>
            <dd>
              Read and then Delete this image file. This is a special image reading file format which will cause IM to delete the given image file after that file has been read into memory. Note that the image in memory will not have been processed or even saved when the read file has been removed. This is very dangerous and should be used with extreme caution. It is mostly used in <a href="#delegate_spawn">Delegate Spawning</a>. Here the background delegate will read the input image, then deletes it when it has the data. This in turn notifies the foreground 'parent' process, that the 'child' is ready to proceed on its own, as it has finished reading the image provided. The main program can then clean-up and continue its image processing separately, or simply exit, as the case may be. The "<code>show:</code>" image output delegate uses this with the "<code>magick display</code>" command, to automatically background an image magick display before the main command continues or exits. (see below) For example I used this in a shell script that calls "<code><a href="../scripts/flicker_cmp">flicker_cmp</a></code>" to display some intermediate results, but then automatically continues (or exit) when the IM has signaled that the program has finished reading its input image by deleting the second image given. If you need that feedback but also need to preserve the image being read, then make a copy, hard link, or symbolic link to the original image, and pass that file as "<code>ephemeral:</code>". that way when it is deleted the orignal image is preserved. NOTE: There is currently no way to get "animate" or "display" to signal when it has finished an animation, or has actually put the image up for magick display. :-( However you can have "magick" read a separate "ephemeral:" image, to notify a controling script that it has reached a specific point in its image processing.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code execute="" noimage="" out="b64_image.txt">
  # Blur an image, and show an on screen comparision before
  # auto-deleting and exiting.
  magick rose: input_image.png
  magick input_image.png -blur 0x5  blurred.png
  flicker_cmp input_image.png ephemeral:blurred.png &

  # wait for the second image to have been read and deleted!
  while [ -f blurred.png ]; do usleep 100; done

  # At this point we can continue (or exit) without problems.
  # while the on screen display continues in background.
  rm -f input_image.png
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>I have also used this in other background programs, as a signal that that background program is ready to continue.
            </dd>
            <dt>
              <a name="show" id="show"></a> <b><code>show:</code>, <code>win:</code> and <code>x:</code></b> -- Display images directly on screen
            </dt>
            <dd>
              These are special output formats that will which will directly display the image result to your screen. Instead of saving the image into a file, it just displays the result. This is very useful for quick testing IM commands to see what the results will be, and is highly recommended for this purpose. However they are only very simple versions of the "<code><a href="../basics/#display">display</a></code>" and "<code><a href="../basics/#animate">animate</a></code>" command. For example, get a fast summary of images in a directory...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick montage *.jpg show:
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>See the areas that are different between two images...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick compare image1.png image2.png show:
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>All the formats listed here, actually call on the "<code><a href="../basics/#display">display</a></code>" program to perform their task. However they each handled the job in different ways. For example '<code>show:</code>' will use a <a href="../files/#delegate_spawn">Spawning Delegate</a> to run a separate "<code><a href="../basics/#display">display</a></code>" program. This means that once the image has been displayed, the original command will continue its processing (typically exiting, unless you use "<code>-write show:</code>" ). On the other hand, using '<code>x:</code>' or '<code>win:</code>' will wait for you to quit the display window before allowing the original command to continue (and exit). Unfortunately none of these methods will display animations very well. For that you are better off piping the animation (in MIFF format) into the "<code><a href="../basics/#animate">animate</a></code>" command.
            </dd>
            <dt>
              <a name="x" id="x"></a> <b><code>x:</code> (as input)</b> - Reading an X Window Display
            </dt>
            <dd>
              You can also read the current X window display using the "<code>x:</code>" operator, in much the same way as you can with the "<a href="../basics/#import">import</a> command. In fact without options it acts exactly like the "import" command. Use the left button to select the window to grab a copy of, or mark out an area using the middle button. For example, to select a window using your mouse, then display the window just grabbed in another window (exit when grabbed window is displayed)...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick x:  show:
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>WARNING. if you grab a window that is unmapped (iconized), or has another window over it, the image contents will contain either a blank area, or the contents of the overlapping window!!! So make sure when grabbing a window that window fully visible on screen. To grab the whole display use '<code>root</code>' for the window name.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick x:'root'  full_screen_dump.jpg
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>Or use the <a href="#read_mods">Read Modifiers</a> to grab a specific area of the display.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick x:'root[300x400+879+122]'  part_screen_dump.jpg
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>Providing a window name you can grab a specific window. For example this will grab the window titled '<code>MailEd</code>'...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick x:'MailEd'  window.jpg
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>However that does really not work well, as often you have multiple windows with the same name, or the name of the window just can't be determined. The better way is to tell IM the exact window wanted using a "X Window ID" which is the number that the X display uses to uniquely identify a specific window (or child window). The X Window ID is typicaly looked up using the "<code>xwininfo</code>" command, but other programs such as "<code>xdotool</code>", and "<code>xwit</code>" as well as other tools like "<code>xprop</code>" can be used to find information about the windows. For example things like, window class, name, title, its size and placement, child windows, and window manager decoration. For example, find all windows with "Mozilla Firefox" in the title or name...
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  xwininfo -root -all | grep "Mozilla Firefox"
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>I can then extract the X Window ID of the window I want from the output of the above. Here is a little more complex bash script I have in my window manager. When I press a button, it looks up the ID of the window with the current 'focus', captures it, then names the file as a PNG in my current directory using the next capture number, according to any previous captures made.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  bash -c "
    id=$(xprop -root _NET_ACTIVE_WINDOW | sed 's/.* //')
    magick x:$id capture-tmp-$$.png
    num=$( ls capture-[0-9]*.png 2&gt;/dev/null | sed -n '$ s/[^0-9]//gp' )
    num=$( printf %03d $(expr $num + 1) )
    mv capture-tmp-$$.png capture-$num.png
  "
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>Most terminal programs will tell you the X Window ID they are using to magick display text in the environment variable "WINDOWID". As such if you run this from a command line of a XTerm, or Gnome Terminal, you will grab a copy of the current terminal window.
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  magick x:$WINDOWID  this_terminal.png
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>Now for some fun... Here I grab the contents of my current terminal, draw some stuff into it, and then use the "<code><a href="../basics/#display">display</a></code>" to draw it back into the same terminal window!
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  window=`xwininfo -children -id $WINDOWID |\
                  sed -n 's/^ *\(0x[^ ]*\).*/\1/p'`; \
  window="${window:-$WINDOWID}"; \
  magick x:$window -background black \
          -draw 'fill black         rectangle 40,40 160,160' \
          -draw 'stroke red         line 50,50 50,150 line 50,150 150,150' \
          -draw 'fill lime          circle 110,100 80,100' \
          -draw 'stroke dodgerblue  line 50,150 150,50' \
          rose: -geometry +180+60 -composite \
          png:- |\
    magick display -window $window -
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>The first command in the above is designed for an "XTerm" window, which requires that the window you "<code>magick display</code>" into, be the child window of the provided "WINDOWID". The second line falls back to original value of "WINDOWID" if no 'child' window is found, as is the case for a "Gnome-Terminal" window. Once the window to use is worked out, it is grabbed, drawn on, and restored into the terminal window! And presto you have instant graphical output directly into the current terminal window. Here is a simpler example, this darkens the window contents each time you run it. Try running this a few times in an actual "xterm" window, and you find the older the command in the terminal window the darker it gets!
              <div align="center">
                <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                  <tr>
                    <td>
                      <pre><code no_execute="">
  window=`xwininfo -children -id $WINDOWID |\
                  sed -n 's/^ *\(0x[^ ]*\).*/\1/p'`; \
  window="${window:-$WINDOWID}"; \
  magick x:$window -background black -colorize 20% png:- |\
    magick display -window $window -
</code></pre>
                    </td>
                  </tr>
                </table>
              </div>And here is a 'screen capture' showing what happened as I repeated the above in my own "xterm" window...
              <div align="center">
                <a href="../img_diagrams/xterm_darken.png"><img src="../img_diagrams/xterm_darken.png" width="329" height="236" align="middle" vspace="2" hspace="5" border="0" alt="[snapshot]"></a>
              </div>Be warned that while the contents of the terminal are modified, it is only temporary. If you iconify, obscure, or change desktop screens, then go back to the terminal, the modifications will be lost as the terminal program re-draws the window, and wipe out your own 'drawing'. The above does not work nearly as well for a "Gnome-Terminal" as for "XTerm"s because the former likes to 're-draw' its window every time it scrolls, where a "XTerm" does not. Imagine IM scripts that display the results of graphs and other things directly in various windows as part of a larger client program. This is in fact how many postscript viewers, and even many web browsers display output from special sub-programs. That is, they have that sub-program take over and directly draw into a provided sub-window. Experiment, and please let me (and others) know what you come up with, either via email or the <a href="https://magick.imagemagick.org/viewforum.php?f=1">IM Users Forum</a>.
            </dd>
          </dl>
          <hr>
          <!-- ---------------------------------------------------------------- -->
          <a name="delegates" id="delegates"></a>
          <h2>Coders and Delegates for Image Formats</h2><b>Coders</b> are dynamic library modules (usually written in the C programming language) that handle the "format:" aspect of image input and output. They can also be used by users to create special purpose filters. They may require the installation of extra external libraries to be installed, which are often called 'delegate libraries'. They are loaded as dynamic modules only as needed, which means the associated libraries used by a coder does not need to be installed, unless you want to actually make use of that coder. These examples will not go into the C programing required for writing coders, but there is an example coder in the source that can be used to create your own coder modules.<br>
          A <b>Delegate</b> is simply a command that IM knows that will allow it to magick between different formats. This allows IM to use that 'simpler' and pre-written command, rather than requiring a more complex binary coder to handle some image file format. To get a list of what delegates are available use the special command...
          <div align="center">
            <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <pre class="bg-light text-dark mx-4"><samp>
  magick -list delegate
</samp></pre>
                </td>
              </tr>
            </table>
          </div>The most well known 'delegate' program Im makes use of is "<code>ghostscript</code>" which will allow IM to read, and magick the very complex Postscript and PDF format vector images into some other raster image file format that IM can read. However '<b>Delegate Commands</b>' are very useful for users too, as it allows you to expand IM so that it can handle special types of images, or to provide alternative methods to read and write those images. The 'commands' themselves are listed in a file named "<code>delegates.xml</code>", and which is located in IM's system configuration directory. But it will also read a "<code>delegates.xml</code>" located in the users personal "<code>.magick</code>" sub-directory of there Linux/UNIX home directory. And it is in this second file that users should place their 'command delegates'. <a name="delegate_example" id="delegate_example"></a> <a name="delegate_input" id="delegate_input"></a>
          <h3>Input Delegate Command Example</h3>For example I can create a personal "<code>delegates.xml</code>" file in the "<code>.magick</code>" sub-directory of my Linux/UNIX home directory, of the form...
          <table border="0" cellspacing="0" cellpadding="5" width="90%" align="center">
            <tr>
              <td>
                <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;delegatemap&gt;
  &lt;delegate decode="flip" command="magick '%i' -flip 'miff:%o'"/&gt;
&lt;/delegatemap&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
              </td>
            </tr>
          </table>
        </div>This is a complete 'delegate' configuration file, but only the middle line is an actual delegate. A very simple one that tells IM that if it sees an image with either a '<code>.flip</code>' suffix or a '<code>flip:</code>' format prefix, it should call the above command, to read the 'flip' format image. For example..
        <table border="0" cellspacing="0" cellpadding="0" width="100%">
          <tr>
            <td width="100%" align="justify">
              <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="100%" bgcolor="#F8F8F8">
                <tr>
                  <td>
                    <pre class="bg-light text-dark mx-4"><samp>
  magick flip:tree.gif   delegate_tree_flip.gif
</samp></pre>
                  </td>
                </tr>
              </table>
            </td>
            <td>
              <a href="delegate_tree_flip.gif"><img src="delegate_tree_flip.gif" width="32" height="32" align="middle" vspace="5" hspace="5" border="1" alt="[IM Output]"></a>
            </td>
          </tr>
        </table>In this case all the delegate command does is use a separate IM "<code>magick</code>" command to 'flip' the image upside down, before the original IM command even reads and processes the image! The delegate assumes the command will understand the image file format given and that it will return ANY image file format that IM itself can understand and process (a <a href="#miff">MIFF</a> image file format in this case). The '<code>%i</code>' and the '<code>%o</code>' parts of the delegate represent temporary filenames the command is the provided input and outptu filenames the delegate should use. These filename are generated by IM, and will be located in a temporary directory. These temporary filenames also do NOT have any image suffixes, so it is important that you prefix the image format type desired, if necessary. It is done this way for security reasons, and because IM itself may only be reading a stream of data, and not an actual file. It also means the delegate command does not have to deal with things like clean up of those files when finished. There are other '%' substitutions for things like a second temporary filename for intermediate temporary files, image density, size, and so on. More detail about these escapes and other delegate options are provided in the comments at the top of the IM installed 'system' "<code>delegate.xml</code>" file. Now this may seem like a rather silly and trivial example, but it basically means you can now use a secondary command to magick ANY data file into ANY image IM understands. IM will then know how to handle that data type automatically given the image suffix, or a format prefix, without you needing to remember all the details. Lots of delegates of this type has already been added to the system file, so it is worth a look.
        <table border="0" cellspacing="0" cellpadding="0" width="90%" align="center">
          <tr valign="top">
            <td><img src="../img_www/reminder.gif" width="20" height="16"><img src="../img_www/space.gif" width="20" height="16"></td>
            <td align="justify" width="100%"><font size="-1"><i>For security reasons delegates in a personal "<code>delegates.xml</code>" file will not override the delegates defined in the system installed "<code>delegates.xml</code>" file. You can only add new unique delegate formats in ".magick/delegates.xml" in your home directory, later duplicate delegates will be ignored.<br>
            <br>
            Of course if the input format is already known internally then of course system delegates are not looked at.<br>
            <br>
            Also as always, sanitise any user (especially web user) input, as you don't want the user to make use of a delegate without you knowing about it.<br>
            <br></i></font></td>
          </tr>
        </table>For example as of IM v6.4.2-6, a "<code>autotrace:</code>' delegate was added to the system delegates file, which will run the "<code><a href="http://autotrace.sourceforge.net/">AutoTrace</a></code>" command while reading ANY input image. IM converts the input image to the required PNG image format needed by the delegate program, filters it though the delegate, then reads the resulting SVG (typically via an external RSVG library), to generate a smooth edged version of the original input bitmap image. See <a href="../transform/#edge_vector">Raster to Vector Converter Example</a>. If a converter generates multiple image files (such a PNG), you will need to merge all those separate images into a single multi-image format such as MIFF, so that IM can read the multiple images from the one output file. Sometimes IM will string together multiple delegate programs to read in an image. For example to read a 'HTML' page as an image, it first calls the delegate "<code>html2ps</code>" to magick it to postscript. Then it converts the generated postscript file into a set of multiple images using the special "<code>ghostscript</code>" program delegate. Of course using two, or more delegates like this can produce other problems due to the complex interactions, miss-installations, and bugs that may be present in the delegate programs. But in general it works, and is a key aspect of what make ImageMagick, magical. <a name="delegate_output" id="delegate_output"></a>
        <h3>Output Delegate Example</h3>Similar things are done when saving to specific image file formats that IM does not directly understand. For example by adding this delegate to your personal "<code>.magick/delegates.xml</code>" file, you can tell IM how to create a '<code>.xyzzy</code>' image file.
        <table border="0" cellspacing="0" cellpadding="5" width="90%" align="center">
          <tr>
            <td>
              <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
  &lt;delegate decode="gif" encode="xyzzy" command='mv "%i" "%o"'/&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
            </td>
          </tr>
        </table>
      </div>Of course this just quickly copies a GIF file format image as a TMP file format, but the command can be any type of image converter, script or shell command sequence you like. With that personal delegate, IM can now create your '<code>.xyzzy</code>' images, having been provided at least one method of going so.
      <div align="center">
        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
          <tr>
            <td>
              <pre><code execute="" out="delegate_rose_xyzzy.txt">
  magick rose: -negate   rose.xyzzy
  magick identify rose.xyzzy
</code></pre>
            </td>
          </tr>
        </table>Note that the identify in the above does not understand the '<code>.xyzzy</code>' suffix (no input delegate has been provided). However as no specific delegate is provided, the file 'magic' (an identification string inside the file itself) tells IM that it is in reality a GIF image format, so IM handles it correctly anyway, without needing a special input delegate or coder. This is actually the the 'MAGIC' part of 'ImageMagick'.<br>
        <a name="delegate_list" id="delegate_list"></a>
        <h3>Delegate Listings</h3>A full list of external delegates that IM can use for converting image formats is read from a special system file called "<code>delegates.xml</code>" as well as a personal "<code>delegates.xml</code>" file (see below). If you can find this file it makes interesting reading. The format of this file however is too complex to do into here, though it is explained in both the system file and the manuals provided both online and with your ImageMagick installation (docs area). A simplified summary of the delegates and conversions that IM is reading from these files can be printed using the "<code><a href="../basics/#list">-list delegate</a></code>" option...
        <div align="center">
          <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
            <tr>
              <td>
                <pre><code no_execute="">
  magick -list delegate
</code></pre>
              </td>
            </tr>
          </table>
        </div>However please note that delegated declared with '<code>stealth="True"</code>' will not be listed, by the "<code><a href="../basics/#list">-list delegate</a></code>" option. All delegates are optional, and more than one can be created for a specific conversion. If one delegate is not available (or it errors and image is not created), then IM will try the next delegate, until one is found that does work, or it runs out of delegates to try, at which point an error will be produced indicating it can not read that image. <a name="delegate_print" id="delegate_print"></a>
        <h3>Printing Delegate</h3>One of the most useful delegates I have ever created was to let me easily print images to a postscript printer. The printer was already set up using the linux "<code>lpr</code>" command and it could accept either a PNG format image, or a postscript file. Here is the simple "<code>PRT:</code>delegate I decided to create.
        <table>
          <tr>
            <td>
              <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
                <tr>
                  <td>
                    <a href="delegate_rose_xyzzy.txt"><img src="delegate_rose_xyzzy.txt.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
                  </td>
                </tr>
              </table>
            </td><!-- <CODE EXECUTE>
  rm -f rose.xyzzy
</CODE>-->
          </tr>
          <tr>
            <td>
              <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
  &lt;delegate decode="ps" encode="prt" command='lpr "%i"'/&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
            </td>
          </tr>
        </table>
      </div>Notice I decided to use postscript format ("<code>decode="ps"</code>") for the image being passed to the "<code>lpr</code>" command on my system. I chose that as I can then use options such as "<code>-density</code>" to adjust the size of the output image. For example I can create a command to grab a window form my screen, modify the image, so as to fit on printed page (as I want it) then print it.
      <div align="center">
        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
          <tr>
            <td>
              <pre><code no_execute="">
  magick x:Loopy -shave 6 -chop 0x24 -modulate 220,0 \
          -bordercolor white -border 50x150 -density 130   prt:
</code></pre>
            </td>
          </tr>
        </table>
      </div>I could have also used "<code>decode="png"</code>", however my system would then enlarge or shrink the image to always completely fill the A4 page. You however may like this.
      <table border="0" cellspacing="0" cellpadding="5" width="90%" align="center">
        <tr>
          <td>
            <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
  &lt;delegate decode="png" encode="prt" command='lpr "%i"'/&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
          </td>
        </tr>
      </table>
    </div><a name="delegate_spawn" id="delegate_spawn"></a>
    <h3>Spawning External Commands</h3>External command delegates does not have to just be for converting images to/from files, but can be used as a quick way to run (or 'spawn') complex commands in the background. Such a delegate will have the attribute '<code>spawn="True"</code>' added to it, and will launch the command, wait for it to delete its input image, then IM will continue as normal, leaving the command running in the background. For example two output delegates "<code>show</code>" and "<code>win</code>" both provide simple ways to display the result of a command in the IM "<code><a href="../basics/#display">display</a></code>" program. For example..
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  magick rose: label:rose -append   show:
</samp></pre>
          </td>
        </tr>
      </table>This will append a label to the built-in 'rose' image and just display it on the screen. When the spawning delegate has read its input image and deleted it (typically using the special "<code><a href="#ephemeral">ephemeral:</a></code>" input format, see above), the launching IM will continue (and exit), leaving the 'display' program running in the background to show the results. Here is the "<code>show</code>" spawning delegate, showing the use of "<code><a href="#ephemeral">ephemeral:</a></code>" in the "<code><a href="../basics/#display_script">display</a></code>" command.
      <div align="center">
        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
          <tr>
            <td>
              <pre><code execute="" out="delegate_spawn.txt">
  magick -list delegate | grep show
</code></pre>
            </td>
          </tr>
        </table>
      </div>Unfortunatally the "<code><a href="../basics/#list">list</a></code>" option does not show the '<code>spawn="True"</code>' flag of the delegate, but it is defined for this delegate. This is a lot more convenient that trying to remember all the special options that a scripted "<code><a href="../basics/#display_script">display</a></code>" command needs. Perhaps you have some complex command that you run all the time. <a name="delegate_postscript" id="delegate_postscript"></a>
      <h3>Postscript and PDF Delegate</h3>By using delegates ImageMagick can make use of external programs to do some of the more complex and specialised image format conversions.For example, while Postscript (PS:), and Encapsulated Postscript (EPS:) can be written directly by ImageMagick. These file formats can not be read by IM. Postscript is a full computer language and requires a very complex interpreter to create images from it. As such it is far beyond the scope of IM to handle the reading of this file format. To solve this IM looks for an external delegate program called "<code>ghostscript</code>" to do the work of converting an PS or EPS format file to some other image format that IM can read easily. Of course that means that if you get an error like...
      <div align="center">
        <b>convert: no decode delegate for this image format `...'</b>
      </div>Basically means that IM was unable to find the appropriate external program to magick your given image format into an image format that IM itself can handle. For Postscript images, that usually means "<code>ghostscript</code>" is not installed, mis-configured, or in an unknown location on your system.
      <table>
        <tr>
          <td></td>
          <td>
            <table border="0" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
              <tr>
                <td>
                  <a href="delegate_show.txt"><img src="delegate_show.txt.gif" align="middle" vspace="0" hspace="5" border="0" alt="[IM Output]"></a>
                </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr valign="top">
          <td><img src="../img_www/expert.gif" width="23" height="26"><img src="../img_www/space.gif" width="17" height="16"></td>
          <td align="justify" width="100%"><font size="-1"><i>The PDF/PS "<code>ghostscript</code>" delegates are in a special format used internally. IM internally examines postscript format images to attempt to determine exactly how to rasterize the file via the given delegates.<br>
          <br>
          In fact, multiple PS delegates are present and selected by IM depending on the situation. For example the ghostscript device used ('<code>bmpsep8</code>' verses '<code>pngalpha</code>') is selected depending on if "<code>-colorspace RGB</code>" had previously been set or not.<br>
          <br>
          For PDF we use the '<code>ps:color</code>' delegate rather than '<code>ps:alpha</code>' because the '<code>pngalpha</code>' ghostscript device only supports an one-to-one page-to-image conversion and PDF's generally are multi-page.</i></font></td>
        </tr>
      </table><a name="taint" id="taint"></a> <a name="delegate_direct" id="delegate_direct"></a>
      <h3>Direct Delegate Format Conversion (Taint)</h3>The delegate system also allows IM to call an external program to convert an image from one format to another format, without any processing of the image by ImageMagick itself. But only if the destination image is readable by IM as an image and the final result of the "<code>magick</code>" was an 'untainted' copy of the image. For example if you try this comamnd to magick a 'Adobe Illustrator' file ("<code>.ai</code>") (which is a type of Postscript), to EPS (encapsulated postscript)...
      <div align="center">
        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
          <tr>
            <td>
              <pre><code no_execute="">
  magick -density 300   map.ai  map.eps
</code></pre>
            </td>
          </tr>
        </table>
      </div>Then IM will magick the "<code>map.ai</code>" to an EPS file (in "<code>/tmp</code>"), a format it understands. Then after reading into memory (after using the 'eps' delegate), it will then find that it does not actually need to modify it (it remains 'untainted'). Because no change was made to the image, and the image was already converted to a 'eps' file file format, IM will short-circuit itself and directly copy the 'eps' file it generated to "<code>map.eps</code>". That is, the EPS file will be just a copy of the original unchanged Adobe Illustrator file! In otherwords IM only used its internal delegates to magick the file (actually just rename it). It never actually processes the image itself, and as such the image remains a pure vector image. This is actually the original purpose of "<code>magick</code>" as a program back in version 1 of ImageMagick. All the other operations and settings were added later over a very long period of time. <a name="taint" id="taint"></a> You can however force IM to actually read-in and write-out the image, as a raster, by using the special "<code><a href="https://imagemagick.org/script/command-line-options.php?#taint">-taint</a></code>" operator to mark it as being modified, without actually modifying it.
      <div align="center">
        <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
          <tr>
            <td>
              <pre><code no_execute="">
  magick -density 300 map.ai  -taint  map.eps
</code></pre>
            </td>
          </tr>
        </table>
      </div>Here the image IM reads does become 'modified' or 'tainted' so it will write out the version of the image in memory to the final EPS file, rather than simply copy the input file.<br>
      <a name="delegate_other" id="delegate_other"></a>
      <h3>Other Delegate Examples</h3>
      <h4>Modifying Postscript Delegate for CMYK postscript</h4>See <a href="http://blog.digitaljohn.co.uk/2007/06/19/imagemagick-cmyk-to-rgb/">Blog of John</a>, <a name="delegate_dcraw" id="delegate_dcraw"></a>
      <h4>DCRaw 8-bit processed camera image Delegate</h4>An alternative delegate for reading 8-bit fully processed 'raw' digital camera images (CRW, CR2, NEF, etc) is...
      <table border="0" cellspacing="0" cellpadding="5" width="90%" align="center">
        <tr>
          <td>
            <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
  &lt;delegate decode="dcraw8" command='dcraw -v -w -O "%o" "%i"'/&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
          </td>
        </tr>
      </table>
    </div>This will read the 'raw' camera image, and magick it to a PNG file format (though you can also just as easily add a '<code>-T</code>' flag and use a TIFF image format). That output image turn is readable by ImageMagick. By adding this delegate can then use it simply, for any ImageMagick image read operation (any API, not just command line), and IM will handle all the file IO and cleanup. For example...
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre><code no_execute="">
  magick dcraw8:image.crw  image.png
</code></pre>
          </td>
        </tr>
      </table>
    </div>If you do not define the filepath of the "<code>dcraw</code>" executable, IM will search the for the program along the users current PATH environment variable, however allowing this could represent a security problem. System installed delegates generally define the command path fully. See comments in this <a href="https://magick.imagemagick.org/viewtopic.php?t=15605">IM Users Forum Discussion</a>.
    <h4>Video decoder delegate using 'ffmpeg'</h4>For example, here is a delegate published by Mikko Koppanen, on his <a href="http://valokuva.org/">Mikko’s blog</a> site. Add this to your personal "<code>delegates.xml</code>" file in "<code>.magick</code>" directory of your home...
    <table border="0" cellspacing="0" cellpadding="5" width="90%" align="center">
      <tr>
        <td>
          <pre><font size="-1"><img src="../img_www/text_top.gif" width="120" height="10">
  &lt;delegate decode="ffmpeg" command="'ffmpeg' -i '%i' -y -vcodec png -ss %s -vframes 1 -an -f rawvideo '%o'" /&gt;
<img src="../img_www/text_bot.gif" width="120" height="10"></font></pre>
        </td>
      </tr>
    </table>IM can now use the "<code>ffmpeg</code>" program to decode the frames from an MPEG video image. For example.
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre><code no_execute="">
  magick "ffmpeg:test1.mpg[40]"  frame_40.png
</code></pre>
          </td>
        </tr>
      </table>
    </div><!--
<H4>A HTML alternative</H4>

The "html2ps" is not known for its image handling abilities.  It has
been reported that it basically ignores image size tags, so that it just does
not perform very well placing images and text together. </P>

There is a technique of running a web browser in a virtual X server to
get a more advanced image of the top of a web page, but this is not thoroughly
tested (mail me for more info if interested). </P>
-->
    <hr>
    <!-- ---------------------------------------------------------------- -->
    <a name="massive" id="massive"></a>
    <h2>Really Massive Image Handling</h2>For handling any sort of large image it would probably be better for you to use a Q8 version of ImageMagick, which has half the memory requirements of the higher quality Q16 version. Check your IM's compiled Q level using "<code>identify -version</code>". For medium sized images you can attempt to use "<code><a href="https://imagemagick.org/script/command-line-options.php?#limit">-limit</a></code>" to increase the processing limits (for example processing "<code>-limit area 8192 -limit memory 8192</code>"), so as to try to avoid IM caching the image data to disk. However your system may reject large memory requests and still force IM to cache the image to disk (about 1000 times slower). To see if IM is using disk cache for the image processing, you can use "<code><a href="https://imagemagick.org/script/command-line-options.php?#debug">-debug</a> cache</code>" to monitor that action. Also see <a href="https://magick.imagemagick.org/viewtopic.php?f=3&amp;t=19642">IM Forum Discussion</a>.
    <h3>Memory/Disk Management</h3>If you are planing to process really large images you may want to make sure IM does not use up all the computers memory, and slowing down the processing of other programs (by spending all its to shuffling between memory and disk swap) simply by asking it to immediately use temporary swap disk files. For example this is a <i>nice</i> way of processing a very large image over a long period of time without stopping you from using your computer for other things. Basically it forces IM to cache everything to disk.
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  env MAGICK_TMPDIR=/data nice -5 \
    magick -limit memory 32 -limit map 32 \
            huge_9Gb_file.psd  -scene 1 +adjoin layer_%d.png
</samp></pre>
          </td>
        </tr>
      </table>
    </div>Of course this assumes that "<code>/data</code>" has enough file and disk space to handle the images memory requirements.
    <h3>Memory Mapped Disk Files</h3>If you have many operations to perform on the same source image and you have plenty of disk space you can use the <a href="#mpc">MPC image format</a> which is expensive to create but has near zero overhead when loading...
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  magick mybigassimage.jpg mybigassimage.mpc
  magick mybigassimage.mpc   -resize 50%  resized.jpg
  magick mybigassimage.mpc   -rotate 90   rotated.jpg
  ...etc...
  rm -f mybigassimage.mpc mybigassimage.cache
</samp></pre>
          </td>
        </tr>
      </table>
    </div>This will let you read a very large image multiple times with a minimal cost, and memory usage. An example of a scripted for of tiling using this method was presented in an IM Forum Discussion <a href="https://magick.imagemagick.org/viewtopic.php?t=18315">Cut large image on tiles</a> and revisited in <a href="https://magick.imagemagick.org/viewtopic.php?f=1&amp;t=20982">Cropping very very large images</a>. Basically the MPC image format file consists of two actual files, an informational "<code>.mpc</code>" file, and a direct memory paged copy of the image in a "<code>.cache</code>". Of course you need to clean up both files when you are finished. This method is designed so that IM does not have to re-parse the image format and cache it to disk, every time you run a new "<code>magick</code>" command. Also if you are accessing only sections of the input image, each command does not need to process the whole image, but can now read just that smaller section from the cahced disk file as needed. If you plan to process a very large MPC copy of the image, it is a good idea to extract or <a href="../crop/#crop">crop</a> a smaller section of the image for actual processing. This is because just about any operation performed on an image, will generally result in a new in-memory copy being made of the result, so an initial crop is a very good idea. If you have the memory you can also try to use a 'memory disk' such as a 'TMPFS' or RamDisk type filesystem. Be warned however that filling that type of disk also directly fills your computers memory. So really you are just swapping one use of memory for another.
    <h3>Processing Images in small sections</h3>While you can use the MPC method above to crop out various sections from a source image for further processing, you still need to read in and write out the the whole image, and for a massive image that can still take a lot of time. IM has also evolved a simpler pipeline processor for images called "<code><a href="../basics/#stream">stream</a></code>". This program has a limited set of image operations that are designed to only process images one scan line (row of pixels) at a time. As such only enough memory to hold a single line of pixels is used when processing images in this way. For example this allows you to extract a smaller area of a very large image for further processing, without needing to read in the whole image into memory first. However the output of "<code><a href="../basics/#stream">stream</a></code>" is raw RGB image values, so some post-processing is recommended.
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  magick stream -map rgb -storage-type char -extract 600x400+1900+2900 image.png - |\
    magick -depth 8 -size 600x400 rgb:- tileimage.png
</samp></pre>
          </td>
        </tr>
      </table>
    </div>You don't have the save the output to a file but can continue processing the smaller image directly. For example...
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  magick stream -map rgb -storage-type char -extract 600x400+1900+2900 image.png - |\
    magick -depth 8 -size 600x400 rgb:-  ...more_processing_here...  tile.png
</samp></pre>
          </td>
        </tr>
      </table>
    </div>This will only process the <code>600x400</code> pixel image extracted without reading in the whole larger image first. <b>Speed concerns...</b>Peter V &lt;peter.v@pv2c.com&gt; noted... In my experience is the approach of using "<code><a href="../basics/#stream">stream</a></code>" for cutting 800MB PNM files the fastest compared to use of MPC files, or using "<code>magick -crop</code>". <b>What formats work...</b>Paul Heckbert (of image distortion fame) noted that the "stream" command works well for certain file formats (in particular, JPEG), but does not work well for other types like PSB, which may be interleaved. I believe it would depend on if the 'coder' for a particular file format provides support for line by line streams of pixels. This may be because the programmer that generated the file format 'coder' just did not get round to, or need 'streaming'. In this case some more work by a programmer familiar with that image file format maybe needed to complete the 'coder' module. Also a vector image file format like SVG or WMV, or an image that is pre-processed by some 'delegate', like digital camera image file formats, could not possibly be 'streamed' because, there are no actual rows of pixels in the image, only drawn objects (lines, polygons and gradient shades). <b>JPEG images sections</b>As per the IM forum discussion <a href="https://magick.imagemagick.org/viewtopic.php?t=18268">Extract a region of an huge jpeg</a> you can use specialized JPEG programs such as the special "<code>jpegtran</code>" and "<code>jpegcrop</code>" developed by <a href="http://jpegclub.org/jpegtran/">JPEG Club</a>, can extract a regions from a JPEG image without actually decoding the data. That is, a lossless crop of a JPEG to another JPEG image. For example..
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  jpegtran -crop 100x100+0+0 -copy none huge.jpeg  crop.jpg
</samp></pre>
          </td>
        </tr>
      </table>
    </div>However there an few cavats. The top-left starting point will be moved to the smaller 8 or 16 multiple, with an appropriate increase in the final image size. That is, because JPEG images uses 'frequency encoded blocks' which are typically either 8x8 pixel or 16x16 pixels in size (determined by the JPEG sampling factor, 1 = 8 pixels, 2 = 16 pixels). These blocks need to be preserved if lossless copies are to be made. For a '<code>+0+0</code>' offset, it is already at an appropriate boundary, so the above should produce an exact 100x100 pixel crop. But for other offsets you will need to so some final cleanup of the extracted region. For example...
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  jpegtran -crop 100x100+123+425 -copy none huge.jpeg  crop.jpg
  magick crop.jpg -gravity SouthEast -crop 100x100+0+0 +repage crop_fixed.png
</samp></pre>
          </td>
        </tr>
      </table>
    </div><a name="massive_pbmplus" id="massive_pbmplus"></a>
    <h3>Processing Images in Tiles (PbmPlus)</h3>To process an massive image in tiles, without ever holding the whole image in memory is a much harder problem. Basically while you are breaking up an image you will need to either hold a whole row of images, or have multiple streams (one for each column of images) open, while the massive image is being broken up, or later being put back together. Most common technique is simply save the each image tile as separate image files on disk. In fact this is often the better way of storing ultra large images as programs can then just read the 'tiles' needed at any given moment for processing, producing a sort of 'disk based' random access image. This type of massive image storage, combined with a pyramid type multiple-resolution structure is actually how "google image maps" work. While IM does not have anything to break breakup (tile crop) massive images using a small amount of memory, the <a href="../formats/#pbmplus">PbmPlus/NetPBM</a> can do this. <b>Pbmpus processing of a small section</b> For example, here I use PbmPlus tools to cut (crop) out a small section of the large image, process it, then compose that piece back into the original image.
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  tifftopnm INPUT.tif input.pam

  pamcut {left} {top} {width} {height} input.pam  part.pam
  # process smaller "part.pam" image here
  pamcomp -xoff={left} -yoff={top} - input.pam output.pam

  pamtotiff output.pam OUTPUT.tif

</samp></pre>
          </td>
        </tr>
      </table>
    </div>The "<code>tifftopnm</code>" does a conversion to an image data stream, and performs a similar job to ImageMagick "<code><a href="../basics/#stream">stream</a></code>" command. The "<code>pamcut</code>" is the equivalent of a <a href="../crop/#crop">Crop Operation</a>, and will extract a smaller area from the input image. Instead of <i>width</i> or <i>height</i>. You can also specify <i>right</i> or <i>bottom</i> bounds of the crop. You could substitute a "<code>magick stream</code>" command with "<code>magick</code> The central part, can be processed using normal ImageMagick, or if you like pain, a chain PbmPlus equivalent tools. The "<code>pamcomp</code>" should overlay the modified part of the image back into the PbmPlus version of the original image. Other possible alternative to "<code>pamcomp</code>", is "<code>pnmpaste</code>", but this has not transparency handling, for pixel bleading. Note that by using composition with pieces it should be posible to distort small tiles and re-join them into a larger image afterwards. <b>Pbmpus diced (tile crop) processing</b> We may be able to use "<code>pamdice</code>" and "<code>pamundice</code>", or other alternatives to generate and merge smaller image tiles that can be processed individually, however this must save files into separate disk files (or named pipes) due to the 'multiple images per row tile problem'. An example script, "<code><a href="../scripts/pam_diced_flip.pl">pam_diced_flip.pl</a></code>" of doing this has been provided by <a href="https://magick.imagemagick.org/memberlist.php?mode=viewprofile&u=17875&quot;">bugbear</a>, to 'flip' or 'rotate' (90 degree only) very large PbmPlus images using smaller tiles. Something that normally requires you to read the whole image into memory. Note that it does use a lot of temporary files, but it has a very small memory footprint.
    <h3>VIPS and NIP, a Massive Image TIFF handler</h3>Jenny Drake &lt; jennydrake @ lineone.net &gt; reports... You may also like to look at the non-IM alternative of "<code><a href="http://www.vips.ecs.soton.ac.uk/index.php">Vips</a></code>" and "<code>nip</code>", developed by the National Portrait Gallery in London, which is designed to work on very large image files (generally TIFF) with low specification computers. "<code>Vips</code>" is the underlying engine and "<code>nip</code>" is the gui. Works on Linux, Windows and sometimes on Mac.
    <hr>
    <!-- ---------------------------------------------------------------- -->
    <a name="image_streams" id="image_streams"></a>
    <h2>Long Streams of Lots of Images, Video sequences</h2>Streams of images is another problem area. Here it isn't the size of the image that is of concern, but the shear number of images involved. So many you generally do not want to load them all into memory, or even save them individually to disk, as normal images. The biggest cultript of such images is of course, video handling, and animations The key to handling such images are the streaming image file formats where images can be simply concatanated together, one after another, into the one file stream. We touched on this briefly above in <a href="#miff_stream">MIFF Image Streaming</a>. Like ImageMagick's own <a href="#miff">MIFF</a> format, the <a href="../formats/#pbmplus">PbmPlus/NetPBM</a> is also a streaming format (almost the same just simpler) but is much more well know and commonly used in video image stream processing. In a forum discussion, <a href="https://magick.imagemagick.org/viewtopic.php?f=2&amp;t=18320">Reading Multiple Images</a>, an user wanted to process a 'stream' of multiple PPM images, generated by a "<code>ffmpeg</code>" video processing program. <a href="../formats/#pbmplus">Pbmplus</a> images (like <a href="#miff">MIFF</a> images, can be simply concatenated together to generate a multi-image stream. At this time IM does not allow you to just read one image from such a stream, process it, and then read another single image. All IM commands will always read the whole stream, and then close it. This is being fixed as part of IMv7 scripted processing. One solution is a small perl script, "<code><a href="../scripts/process_ppm_pipeline">process_ppm_pipeline</a></code>", that will accept a stream of PPM images, and run a separate "<code>magick</code>" command on each image, as it arrives. The output is also a series of PPM images that produces a new stream of images. For example read a video, and 'flip' every frame, one by one...
    <div align="center">
      <table class="table table-sm table-hover table-striped" cellspacing="0" cellpadding="5" width="90%" bgcolor="#F8F8F8">
        <tr>
          <td>
            <pre class="bg-light text-dark mx-4"><samp>
  ffmpeg input.mpg -f image2pipe -vcodec ppm | pnmtopnm -plain |
    process_ppm_pipeline -flip |
      ffmpeg -f image2pipe -vcodec jpeg output.mpg
</samp></pre>
          </td>
        </tr>
      </table>
    </div>The "<code>pnmtopnm -plain</code>" is vital, as the script currently only handles a stream of ascii-PPM images, though with some more smarts it could also be made to handle any binary (raw) <a href="../formats/#pbmplus">Pbmplus</a> image stream, or even a <a href="#miff">MIFF</a> image stream. Such a tool might be even used for processing a multiple streams (columns) of massively large images too. Though this may require a lot more in-depth knownlege in internal processing of the commands incolved. if a way can be found to sub-divide such images into a stream of tiles, and then re-construct the large image again at the end. Eventually I hope to include some mechanism by which you can ask a coder to read and return just one image from a multi-image file stream without closing that stream, so that another image can be read in again later. In this way Im can then process a stream of images, one image at a time. <i>UPDATE: IMv7 can read one image at a time from a stream. With a loop, or using the pipelined commands, it should be posible to generate streaming image filters. More experimentation needed.</i>
    <hr>
    <!-- ---------------------------------------------------------------- -->
  </main>
  <footer class="magick-footer">
    <div class="container-fluid">
      Created: 27 October 2005 (separated from 'basics' page)<br>
      Updated: 10 May 2013<br>
      Author: <a href="https://antofthy.gitlab.io/anthony.html">Anthony Thyssen</a>, &lt;Anthony.Thyssen@gmail.com&gt;<br>
      Examples Generated with: <img src="version.gif" align="absmiddle" alt="[version image]"><br>
      URL: <code>https://imagemagick.org/Usage/files/</code>
    </div>
  </footer>
</body>
</html>