Photographs and images with a lot of subtle detail are almost always stored as bitmaps. Scanners always produce bitmapped images. Some bitmap images can be converted into scalable formats. High-end graphic packages like \product{CorelDRAW} and \product{\idx{Adobe Illustrator}} can do this, but most cannot. The exceptions are line drawings and other very high contrast images. Bitmaps are also “cheap” to print. Neither the computer nor the printer must do very much work to print a black-and-white bitmap image. (Color bitmap images must be dithered before they can be printed, but that's a separate consideration because it need be done only once, not every time the image is printed.) Bitmapped images are also easy to convert from one format to another.

Unfortunately, bitmap images are very device-dependent. They are stored as a two-dimensional array of dots, which gives them a fixed resolution. A $3\times5$-inch bitmap image that prints correctly on your 300dpi laser printer will only be a $\frac{3}{4}\times1\frac{1}{4}$-inch picture if you make your final copy on a 1200dpi photo-typesetter.

Bitmap images also require considerable memory and disk space to store. The $3\times5$ image described above requires more than 150Kb of memory (if it is uncompressed).

A final consideration is that bitmap images do not scale very well. Enlarging or reducing the image requires either removing some dots (causing a loss of detail) or inserting extra dots (frequently giving slanted lines a very jagged appearance). Rescaling images by exact integer amounts (doubling or tripling its size, for example, but not making it 2$\frac{1}{2}$ times as large) works reasonably well (except for jagged edges). Shaded regions, which are composed of a regular pattern of black and white dots, are frequently disrupted by irregular “blotching” if non-integral scaling is used.

Many graphic images can be represented more compactly as a collection of lines, curves, and other discrete elements. Images of this type are called scalable or vector images. Instead of storing every pixel in a rectangular array, vector images store the encoded instructions for “drawing” the image. This provides a compact representation. A circle, no matter how large, can be represented with just a few data points: the position of the center, the radius, the width and color of the line that forms the circle, and the pattern that fills the circle. It is also easy to change the size of the image; if you halve every measurement, the image is drawn at one half the size with minimal loss of detail.

One drawback of scalable images is that they require considerable computational power to render. Every printer ultimately prints the page as a large bitmap; the print engine has to translate the lines, curves, and fills of a scalable image into a bitmap before this is possible.^[79] Previewing scalable images requires translating them into bitmaps to display them. This can be a noticeably slow process unless you have a very fast computer.

The other significant drawback of scalable images is that they are difficult to translate from one format to another. For example, to translate a PostScript image into something that can be printed on a non-PostScript printer, you have to have a program that understands all of the commands in the PostScript file. A bitmap conversion, on the other hand, doesn't require any understanding of graphics commands; it simply has to know how to rearrange the bits in the array. What it boils down to is this: it's a lot easier to write a translation program to “reverse the order of all the bits in each byte in each row” than it is to write one that can “draw the bezier curve with these three control points using a dashed, light-blue line $\frac{1}{8}$ of an inch wide.”

Plain TeX has no built-in provision for creating pictures or figures. It is possible to do simple diagrams and graphs by writing macros that place individual points on the page. Figure  Figure 6.1 shows several data points plotted in Plain TeX. The input was derived from macros presented in Appendix D of The TeXbook [kn:texbook]; it is shown in Example  Example 6.1.

FIXME:

With special-purpose fonts, it is possible to make more complex figures in Plain TeX. However, LaTeX provides a picture environment which greatly simplifies the process.

The picture environment in LaTeX is implemented on top of the kinds of primitive operations shown in Example  Example 6.1. Working in the picture environment is a lot like working on graph paper: you begin by specifing how big the graph paper is and the distance between lines on the paper (the lines aren't really there; they're just used for reference), and then inside the picture environment, you put picture elements down on the page at the intersections of the lines on the grid.

LaTeX provides picture elements for text, boxes, solid and empty circles, lines, and arrows. Lines and arrows can be drawn at angles, but they are formed by taking characters from a special set of fonts so there is a limited number of angles available. The advantage of using special fonts to draw the lines is that it is relatively efficient.

Figure Figure 6.2 is a simple figure drawn with LaTeX's picture environment. The LaTeX input for this environment is shown in Example Example 6.2.

Figure 6.2. A parallelogram in LaTeX

The epic and eepic styles

Constructing diagrams using picture primitives is very tedious because each element of the picture has to be placed individually. The epic style extends LaTeX's picture environment by adding several higher-level commands for picture construction. These commands allow you to draw solid, dotted, and dashed lines with arbitrary slopes, create matrices and grids with a single command, join several independently placed elements together, and read a list of points from an external file.

The diagrams produced by epic.sty are still limited by the fonts available to LaTeX. The eepic.sty extends epic.sty by using \special commands to construct the more complex figure elements. The \special commands are the same as those used by tpic (see the “the section called “MetaFont”” section in this chapter) and are supported by many DVI drivers.

Figure  Figure 6.3 shows a figure constructed with the epic macros. Figure  Figure 6.3 (a) uses epic.sty, and (b) uses eepic.sty. Notice that eepic.sty provides circles of arbitrary size and smooth lines at any angle. The end points of the radial lines in this figure were calculated by another program and read from a data file by epic. The source for these figures is shown in Example Example 6.3 (both diagrams were created with the same source).

Example 6.3. The epic Input for Figure 6.3

Figure 6.3. A figure created with (a) epic, and (b) eepic

The bezier style

The bezier style allows you to construct curved lines in the LaTeX picture environment. An example is shown in Figure  Figure 6.4. Its source is shown in Example Example 6.4. The grid in this example was created with epic for convenience.

Example 6.4. The Input for Figure 6.4

Figure 6.4. Several bezier curves created with the LaTeX bezier style

PiCTeX is a macro package that you can load on top of Plain TeX or LaTeX.^[80] It does an amazing job of plotting mathematical functions and two-dimensional graphs directly in TeX. An example of PiCTeX (taken from The PiCTeX Manual [mw:pictex]) is shown in Figure  Figure 6.5. The source for this figure is shown in Example Example 6.5.

Figure 6.5. Sample diagrams using PiCTeX

The primary drawback of PiCTeX is that it requires a considerable amount of memory to use. Even relatively simple looking graphs require a big TeX to plot with PiCTeX. PiCTeX also produces very, very large DVI files (the graphs are drawn by interpreting and plotting each pixel individually). This usually results in very large output files from the DVI driver, and some printers may have difficulty printing your documents.

The PiCTeX macros are freely available, but the manual is not. You can purchase the manual directly from the author of PiCTeX or from the TeX User's Group.

XYPic is another add-on macro package for TeX, LaTeX, and other formats. It provides considerably more flexibility than the LaTeX picture environment without resorting to the resource-expensive strategy of PiCTeX.

XYPic provides many more arrows than LaTeX (including curved and self-pointing forms), a wider variety of dashed and dotted lines, provision for lines that bend and go around \linebreak

other picture elements, and annotations for lines and arrows. It seems especially well suited to typesetting commutative diagrams, simple state-transition diagrams, and complex annotated matrices.

The syntax used in XYPic diagrams is not as straightforward as LaTeX's picture environment. An example of a complex XYPic diagram is shown in Figure Figure 6.6. The corresponding source is shown in Example Example 6.6.

Figure 6.6. An XYPic diagram

DraTeX is a macro package that can be loaded on top of Plain TeX or LaTeX and provides many sophisticated drawing features. An example is shown in Figure Figure 6.7. The source is in Example Example 6.7.

Figure 6.7. An DraTeX diagram

DraTeX offers a wide variety of low-level drawing commands: straight lines at arbitrary angles, circles of any size, bezier curves, rectangular or polar coordinate systems, perspective for three-dimensional figures, user-definable shading patterns, clipping, repetition, and user-definable drawing objects and commands. A supporting package, AlDraTeX, provides high-level drawing commands for pie charts, XY charts, bar charts, spread diagrams, grid diagrams, trees, and diagram annotations (arrows, edges, labels).

Although it is a flexible and portable solution, beware that complex figures may require considerable time to compute and will almost certainly require a big TeX. The resulting DVI files tend to be large as well.

DraTeX and AlDraTeX are described in TeX & LaTeX: Drawing and Literate Programming [eg:dratex].

MFPic's picture environment and LaTeX's picture environment are implemented very differently. The commands in MFPic don't attempt to typeset your diagram with special fonts; instead, they write MetaFont commands to another file. This file must be processed with MetaFont before your document can be viewed.

Because MetaFont is used to draw the actual diagram, the MFPic macros are much more flexible than the LaTeX picture creation commands. MFPic macros provide lines (at any angle), rectangles, polygons, circles (of any size), ellipses, cyclic and acyclic curves, arcs, and wedges (all empty, shaded, or filled).

Unlike Fig2MF, described below, MFPic can plot user-specified functions (parametrically or directly, using polygonal or bezier interpolation).

Finally, because MFPic works so directly with TeX, it can include labels and captions in the figure as well as allowing “MetaFont hackers” to insert MetaFont code directly.

The “Fig” in Fig2MF stands for the Fig graphics code (in this case, Fig version 2.1). Fig is a device-independent way of representing figures. Like TeX DVI files, Fig graphics are always translated into a device-dependent form before they are printed. Fig2MF translates Fig graphics into MetaFont code, which can be rendered into a font that is usable by TeX on any platform.

At present, there are a few limitations on Fig2MF: text objects are ignored, and arrowed and non-solid line styles are not supported. The advantage of Fig2MF is that very good interactive drawing programs, like xfig, can be used to create figures.

If the idea of programming directly in MetaFont is appealing to you, start by reading “Simple Drawings in MetaFont” [zw:simple]. This is a short document (freely available) that describes how simple drawings can easily be rendered directly in MetaFont.

In order to use MetaFont creatively, The \MF{}book [kn:mfbook] is really a necessity, but you can get a feel for the picture creation process in MetaFont without it.

Documents that require complex graphics may be difficult to produce as a single TeX document. You may exceed the memory limitations of your version of TeX if you try to put too many figures on a given page, or you may wish to include graphics from incompatible macro packages (suppose you are using the Lollipop format for example, and you want to include a LaTeX picture).

You can always leave blank space in your document, print the graphic on a separate page, and then combine the two pages with scissors, glue, and a photocopy machine. However, there are many times when this is inappropriate (not to mention the aesthetic sensibilities it may disturb).

Another solution is to use a program that can perform cut-and-paste operations on the output files before they are printed. If you use Plain TeX or LamSTeX, one option is DVIpaste. DVIpaste can insert parts of one DVI file into another. It is part of the LamSTeX distribution. The documentation for DVIpaste contains a good example of its use. Unfortunately, DVIpaste relies on macros that are incompatible with most other macro packages.

Some DVI drivers like dvimsp,^[81] which comes with emTeX, can translate DVI files into bitmapped images that can then be incorporated into your document directly. Figures Figure 4.11, Figure 4.13, and  Figure 4.15 in Chapter Chapter 4, Chapter 4, were inserted into this book using dvidot.

Several of the most commonly encountered scalable image formats are PostScript (usually encapsulated), HPGL (Hewlett-Packard's Plotter language), DXF (Autocad's vector format), and the Fig graphics language. PostScript and HPGL are used by specific printers and plotters, DXF files are created by many computer-aided design programs, and Fig is a graphic language understood by several free editing tools---it is always converted into something else before it is printed. Many programs that can edit scalable images have their own vendor-specific formats. Luckily, these programs can usually produce PostScript or HPGL output as well.

PostScript images are the most commonly encountered scalable images. Drawing packages that output PostScript generally produce encapsulated PostScript (EPS). Similarly, most PostScript clip-art is distributed in EPS format. Encapsulated PostScript is a subset of the PostScript language. One of the most important features of EPS images is a bounding box. The bounding box identifies the size of the EPS image. This information is used to determine the scaling factor required to get an image of the correct size.

Generic PostScript can sometimes be converted into encapsulated PostScript. For example, the ps2epsi program that comes with Ghostscript attempts to convert generic PostScript into encapsulated PostScript.

Some software produces reasonable PostScript figures, but fails to include the bounding box. For those situations, the bbfig program that comes with dvips may help. bbfig uses the printer to calculate a bounding box that you can insert into the figure. After you have printed the figure, you can construct a bounding box by hand, if necessary (sometimes bbfig gets confused). Simply measure the height and width of the figure and its position on the page (measured from the bottom-left corner). The bounding box is a rectangle measured from the lower-left corner of the figure to the upper-right corner. An example is shown in Figure  Figure 6.8.

Figure 6.8. A PostScript bounding box example

The bounding box is measured in PostScript points. There are 72 PostScript points to the inch, so the image in Figure  Figure 6.8 has the following bounding box:

If you are printing your document on a PostScript printer, you will find that PostScript images are easy to handle; every PostScript DVI driver that I have seen allows you to incorporate encapsulated PostScript with one or more \special commands. The section “the section called “Bitmapped Image Formats”” later in this chapter describes two ways of incorporating encapsulated PostScript images into Plain TeX or LaTeX documents for printing on a PostScript printer.

PostScript output on non-PostScript devices is much more difficult, although it can be achieved with a PostScript interpreter like Ghostscript.^[82] For a detailed description of how PostScript images can be converted into another format with Ghostscript, see the “the section called “Image Magick”” section later in this chapter.

Hewlett-Packard HPGL is the plotter language developed by HP for its line of pen-based plotting devices. Many computer-aided design and drafting programs can produce HPGL. In addition to plotters, the HP LaserJet III and more recent HP LaserJet printers also understand HPGL. On an HP LaserJet III or later model printer, you can print HPGL directly if your DVI driver allows you to include printer-specific data. This ability was introduced in version 1.4t of the emTeX dvihplj driver.

If your DVI driver does not support printer-specific files or your printer does not understand HPGL, there are at least two conversion programs (hp2xx and hp2ps) that may be able to convert your HPGL drawings into another form you can use.

The Fig graphics language was designed to represent pictures and figures in an easy to interpret and portable manner. The Fig and xfig drawing programs work with Fig graphics. Several other programs, like gnuplot, can also produce Fig graphics. See the “the section called “The epic and eepic styles”” section for more information.

Including bitmapped images is easier than including scalable images because no real interpretation of commands is necessary. Over the years, lots of different ways have been developed for including bitmapped images in TeX documents. Since the development of the bm2font program, most of these methods have become obsolete. As a result, this section examines only a few methods.

If you are using Plain TeX or LaTeX and printing your documents on a PostScript printer, there are several (essentially equivalent) style files that you can use to include your figures.

One is epsfig.sty, which can be used as a LaTeX style option or be inserted directly into Plain TeX documents with \input.^[83] The epsfig style option is supported by LaTeX2e as well.

After the style file is loaded, you can use the macro \epsfig to include your figure. The complete syntax for \epsfig is:

  \epsfig{figure=, height=, width=, rheight=, rwidth=, 
          bbllx=, bblly=, bburx=, bbury=,
          clip=, angle=, silent=}

In practice, only a few of these options are commonly used. Here is a description of each:

The parameters to the \epsfig macro have to obey TeX's strict parsing rules. In particular, you must not put spaces around the equal sign in any option. The clip= and silent= options have no values, but you must include the equal sign anyway.

For example, Figure  Figure 6.9 was inserted by \epsfig using the following commands:

\begin{figure}
  \epsfig{figure=figs/sample.eps}
  \caption{An example of an encapsulated figure.}
  \label{fig.psfigure}
\end{figure}

Figure 6.9. An example of an encapsulated figure

Figure  Figure 6.10 demonstrates a few of other epsfig options:

\begin{figure}
  \epsfig{figure=figs/sample.eps,width=6cm,angle=45}
  \caption{Another example of an encapsulated figure 
           (resized and rotated)}
  \label{fig.psfigurerot}
\end{figure}

Figure 6.10. Another example of an encapsulated figure (resized and rotated)

Image Magick is a collection of eight programs for manipulating images. These programs work with MIFF files by default. MIFF is the “machine-independent file format” developed by the package's author. If you are going to manipulate images with these tools, the author recommends converting them to MIFF format first. The convert program reads and writes a large number of image formats, so conversion to and from MIFF format is straightforward.

Image Magick requires the Independent JPEG Group's JPEG library in order to manipulate JPEG images. Similarly, Sam Leffler's TIFF software library is required to manipulate TIFF images. Both of these are compile-time options. If you did not build Image Magick, you may not be able to manipulate JPEG or TIFF images. To manipulate PostScript images, Ghostscript must be available.

The programs described below are the Image Magick tools that allow you to manipulate images in ways that may be necessary or useful for creating printable images. Other tools, like animate, included in the Image Magick distribution, aren't described here because they have no bearing on printability.

The PBMplus package is a large collection of image translation programs. This package was written originally for unix, but has since been ported to MS-DOS and OS/2.

PBMplus defines three file formats:

Translation from one format to another is accomplished by translating into the appropriate portable format first, and then translating the portable bitmap into the destination format.

The following image formats are supported by the PBMPlus tools:

The PBMplus tools translate the image into the appropriate portable format (PBM, PGM, or PPM) depending on the nature of the image. Similarly, the tools can all work with “lower” formats. (PPM tools can work with PGM and PBM files, and PGM tools can work with PBM files.) For example, there is no “pbmtopcx,” however the ppmtopcx tool will create a black and white PCX file if you use a PBM file as the input. Once converted into a portable format, the image can be translated back into (almost) any of the supported formats.

In addition to image conversion, the PBMPlus tools include programs to perform a wide variety of image manipulations.

xv is an interactive image viewing/converting tool that runs on X11 servers (including MS-DOS implementations of X11 such as Desqview/X).

You can view GIF, PBM, XBM, Sun rasterfile, JPEG, and TIFF images. You can save any image in one of those formats or in encapsulated PostScript. In addition, you can capture any visible portion of the X11 server window interactively with xv.

Like most of the tools described here, xv includes a number of image manipulation tools (cropping, scaling, editing the color map, etc.). If you try to view an image that is larger than your display, xv automatically scales it to fit. I find that xv's interactive nature makes it easier to use for image manipulation than the command-driven tools.

The xloadimage program is another X11 picture display tool. Like xv and Image Magick's display, it has a number of picture manipulation options (although they are not interactive).

One advantage of xloadimage is that it does not rescale images that are too large to fit within the display. Instead, it places them in a scrollable window. I find this behavior superior to xv's solution of rescaling a very large image even though you are interested only in a small section of it.

Image Alchemy is a shareware tool for converting graphic images between various formats. Although the manual mentions a version for Sun workstations, I have only seen the MS-DOS version.

Note that the unregistered shareware version of this program will only convert images which are 640$\times$480 pixels or smaller.

The following is a list of the graphic formats recognized by version 1.5 of Image Alchemy:

Image Alchemy can also perform a number of image manipulations like rescaling, cropping, and color map changes.

ColorView is a shareware MS-DOS program for displaying and converting graphic images. Although designed to work with VESA SuperVGA adapters, ColorView can also work with plain VGA adapters. It does require a 80286 or a more powerful processor.

ColorView can read JPEG, GIF (87 and 89), BMP, and RLE images. It can write GIF (87), 8-bit BMP, 24-bit BMP, JPEG, and RLE images. It can perform image translation without displaying the images, so a VGA or SuperVGA adapter is not required for translation.

This is the Independent JPEG Group's JPEG Software. The compression tool can convert GIF, PPM, and Targa (TGA) images into JPEG format. The decompression tool converts JPEG images into GIF, PPM (or PGM), or Targa formats.

The pmjpeg program is an OS/2 2.x program that can read and display JPEG, TIFF, Targa, GIF, PCX, and Windows or OS/2 BMP images. In addition, pmjpeg can write images in any of these formats except Windows BMP. pmjpeg can also capture all or part of the desktop. Some of the other features of pmjpeg are color map editing, contrast enhancement, image cropping, scaling, rotation, batch translation of images into JPEG format, cyclic slideshow presentations, and the ability to reduce an image to the system palette colors.

txt2pcx is a memory-resident MS-DOS utility that captures text-mode screens as PCX graphic images. See the discussion of screen capturing in the “the section called “GoScript”” section of this chapter for more information about why this is sometimes desirable.

Ghostscript is distributed by the Free Software Foundation (FSF). It is one of the few freely available programs that can convert PostScript images into other formats.

Ghostscript is a (mostly) complete PostScript interpreter. Converting an entire page of PostScript into another format is straightforward with Ghostscript. The following example converts the PostScript file file.ps into a monochrome GIF image called image1.gif:

\$ gs -r300 -sDEVICE=gifmono -sOutputFile=image1.gif file.ps
 

The parameter -r300 indicates that Ghostscript should generate output at a resolution of 300dpi. This controls the size of the bitmap. If you plan to print the resulting bitmap, you should specify the same resolution as your printer. If file.ps contains more than one page, you can use a <!-- d in the output file's name to identify how multiple pages --> should be handled. For example, if file.ps contains three pages, the following command will extract the first page into image1.gif, the second page into image2.gif, and the third page into image3.gif:^[84]

\$ gs -r300 -sDEVICE=gifmono -sOutputFile=image\%d.gif file.ps
 

For incorporating images into TeX, it is more common to convert an encapsulated PostScript (EPS) image into a bitmapped format than it is to convert entire pages. Encapsulated PostScript is described earlier in this chapter in the section “the section called “Using a Lot of Help”.” It is slightly more difficult to convert encapsulated PostScript because of the bounding box. To convert this into a bitmap of exactly the right size, you have to tell Ghostscript to move the image to the upper-left corner of the page (where Ghostscript always begins its conversion) and tell it how big the image is in pixels.

The following steps are necessary to produce exactly the right size bitmap of the encapsulated PostScript figure:

The Perl script shown in Example  Example 6.8 automates this process.

The primary disadvantage of Ghostscript is that the selection of free PostScript fonts is quite limited. The only freely available fonts are: IBM Courier, Bitstream Courier, Bitstream Charter, Adobe Utopia, URW Antiqua, URW Grotesk Bold, Nimbus Roman No9, and Nimbus Sans. Unless you have the PostScript sources for other fonts used in your figures (PFA or PFB and AFM files), Ghostscript will use crude approximations of the desired font.

GoScript is a commercial PostScript interpreter sold by LaserGo, Inc. GoScript is available for MS-DOS systems only. A special version is available for Microsoft Windows.

The primary advantage of a commercial interpreter is that it comes with more high-quality fonts. The GoScript program comes with “clones” of the 13 standard PostScript fonts:

The GoScript Plus program includes clones of all 35 standard fonts (the standard 13 plus AvantGarde, Bookman, Helvetica-Narrow, New Century Schoolbook, Palatino in four styles, Zapf Chancery Italic, and Zapf Dingbats). For MS-DOS users, this program has the additional advantage of being quite a bit faster than Ghostscript.

Although GoScript can use any PostScript Type 1 or Type 3 font, the fonts supplied with GoScript are not in a standard PostScript format, so they cannot be used with other applications.

On a 300dpi LaserJet printer, GoScript did not seem to align the baseline of bitmapped PostScript fonts with great accuracy. This is unfortunate, because the Computer Modern fonts created with MetaFont for TeX are bitmapped.

hp2xx converts scalable images in HPGL into other formats. HPGL is Hewlett-Packard's command language for controlling pen-based plotters. (HP's LaserJet series of printers, starting with the LaserJet III, also understand HPGL.)

Many computer-aided drafting packages can save diagrams in HPGL format. Other software that works with scalable images is likely to be able to save in HPGL format as well. Because HPGL support is uncommon in printers, you will probably have to convert HPGL diagrams into another format to include them in your TeX documents. hp2xx output comes in three flavors: scalable graphics, TeX commands, and bitmapped graphics.

xfig is an editing tool for scalable images stored in the Fig format, described in the “the section called “The epic and eepic styles”” section of this chapter. An example of a drawing being constructed with xfig is shown in Figure  Figure 6.11.

Figure 6.11. Editing an image with xfig

The objects in Fig are arcs, circles, open and closed splines, ellipses, regular and irregular polygons, polylines, boxes, arc-boxes (boxes with rounded corners), text, and encapsulated PostScript. Compound objects can be constructed by binding these objects together.

As a consequence of Fig's device independence, it can be translated into a number of different output formats. A completed Fig drawing can be rendered in PostScript, PiCTeX, \linebreak

LaTeX's picture environment, MetaFont, or any of the pic, epic, eepic, box, eepicemu and \special environments. Figures can also be saved as X11 bitmaps. Not all of the output formats support all of the features of Fig. For example, arbitrarily sloped lines are not supported by the LaTeX picture environment, and encapsulated PostScript makes sense only for PostScript output.

xfig supports rotation, flipping, scaling, and duplication of objects. However, it imposes some limitations on the figures that you create. Objects that contain boxes, arc-boxes, circles, or ellipses can be rotated only in 90 degree increments. Text objects cannot be flipped over.

When objects are placed on the “canvas,” you can elect to have xfig restrict their placement to $\frac{1}{16}$, $\frac{1}{4}$, or $\frac{1}{2}$-inch intervals. Restricted placement makes alignment of a large number of objects easier. Unrestricted placement is also allowed, and there is an alignment operator that can center (vertically and horizontally) any number of objects. A nonprinting grid is available in several sizes, independent of the restriction on object placement. In a similar way, xfig can be instructed to draw sloped lines within specific limits (for example, only allowing lines at slopes supported by LaTeX's picture environment). Precise numeric-coordinate placement of individual objects is also supported.

xfig provides access to the standard 35 PostScript fonts as well as the standard LaTeX fonts. Eight-bit input, allowing access to international symbols, is also provided.

idraw, the InterViews drawing editor, is an X Windows application for editing encapsulated PostScript figures. Figure  Figure 6.12 shows a drawing constructed with idraw.

Figure 6.12. Editing an image with idraw

The objects in idraw are lines, ellipses, open and closed splines, irregular polygons, polylines, rectangles, and text. Compound objects can be constructed by gluing these objects together. Fonts, brushes, and patterns can be customized and extended with X-defaults. idraw supports the full complement of rotation, flip, scale, and duplicate operations with or without grid lines and optional gravity.

Unfortunately, the “gravity” option, which allows you to create horizontally and vertically aligned objects, is not preserved when a file is saved. It is very difficult to recover the alignment of a file when it has been saved and reloaded.

Graphics in TIFF, encapsulated PostScript, X11 bitmap format, and Unidraw format can be imported into idraw figures.

tgif, like xfig and idraw, is an editor for scalable drawings. The “gif\,” in tgif has nothing to do with the bitmap GIF format. The captured screen in Figure  Figure 6.13 shows a drawing being constructed with tgif.

Figure 6.13. Editing an image with tgif

tgif stores objects as a set of Prolog “facts.” Several programs are provided for interpretation of tgif objects outside of tgif. Only four output types are built into tgif: PostScript, encapsulated PostScript (EPS), X11 bitmaps, and X11 pixmaps.

tgif has a number of interesting features including the ability to design hierarchical drawings in either a “top down” or “bottom up” manner, and the separation of an object's representation from its instantiation. In addition, arbitrary text-based attributes can be attached to each object. tgif uses these attributes in a number of ways, such as the execution of system commands based upon object attributes.

The objects supported by tgif are arcs, ellipses, rectangles, rounded-corner rectangles, polylines, polygons, open and closed splines, text, X11 bitmaps, some forms of X11 pixmaps, and encapsulated PostScript. These objects can be grouped together.

tgif supports only five fonts (Times, Courier, Helvetica, New Century Schoolbook, and Symbol) at a few fixed sizes. The fill patterns, line styles, text-styles, and other attributes are similarly fixed (although more generous in number).

bitmap and pixmap are standard tools distributed with the X11 Window System. The pixmap tool provides a superset of the functions in bitmap, including support for color images. An example of the bitmap program editing a small X icon is shown in Figure  Figure 6.14.

Figure 6.14. An example of bitmap editing an icon

Free or inexpensive bitmap editors are available for almost every computer system. The selection of a particular package depends in large part on what kinds of diagrams you need to create.

The primary disadvantage of bitmap editing is that it is difficult to create bitmaps large enough to be used at printer resolution. Even a “full screen” image on a high-resolution monitor is only a couple of inches across (at best) on a laser printer.

texcad is an MS-DOS program (distributed with emTeX) for editing LaTeX picture environments. xtexcad is a similar program that runs under the X11 Window system.

The LaTeX picture environment suffers from two limitations: it can only draw relatively simple diagrams, and it is very difficult to use. texcad and xtexcad remove the second limitation. With one of these programs, the LaTeX picture environment becomes a viable option for many diagrams.