v13i018: ImageMagick - Graphics display programs, Part02/21
cristy at dupont.com
cristy at dupont.com
Wed May 22 18:57:07 AEST 1991
Submitted-by: cristy at dupont.com
Posting-number: Volume 13, Issue 18
Archive-name: imagemagic/part02
#!/bin/sh
# this is img.02 (part 2 of ImageMagick)
# do not concatenate these parts, unpack them in order with /bin/sh
# file ImageMagick/display.man continued
#
if test ! -r _shar_seq_.tmp; then
echo 'Please unpack part 1 first!'
exit 1
fi
(read Scheck
if test "$Scheck" != 2; then
echo Please unpack part "$Scheck" next!
exit 1
else
exit 0
fi
) < _shar_seq_.tmp || exit 1
if test ! -f _shar_wnt_.tmp; then
echo 'x - still skipping ImageMagick/display.man'
else
echo 'x - continuing file ImageMagick/display.man'
sed 's/^X//' << 'SHAR_EOF' >> 'ImageMagick/display.man' &&
X
Note, options \fB-dither\fP and \fB-treedepth\fP affect the color reduction
algorithm.
.TP 5
.B "-compress \fItype\fP"
the type of image compression: \fIQEncoded\fP or \fIRunlengthEncoded\fP.
X
Use this option with \fB-write\fP to specify the the type of image
compression. See \fBMIFF FILE FORMAT\fP for details.
X
Specify \fB\+compress\fP to store the binary image in an uncompressed format.
The default is the compression type of the specified image file.
.TP 5
.B "-pause \fIseconds\fP"
display the next image after pausing.
X
This option is useful when viewing several images in sequence. Each
image will display and wait the number of seconds specified before the
next image is displayed. The default is to display the image
continuously until you terminate it.
.TP 5
.B "-display \fIhost:display[.screen]\fP"
specifies the X server to contact; see \fBX(1)\fP.
.TP 5
.B "-dither"
apply Floyd/Steinberg error diffusion to the image.
X
The basic strategy of dithering is to trade intensity resolution for
spatial resolution by averaging the intensities of several neighboring
pixels. Images which suffer from severe contouring when reducing colors
can be improved with this option.
X
The \fB-colors\fP, \fB-gray\fP, or \fB-monochrome\fP option is required
for this option to take effect.
.TP 5
.B "-enhance"
apply a digital filter to enhance a noisy image.
.TP 5
.B "-gamma \fIvalue\fP"
level of gamma correction.
X
The same color image displayed on two different workstations may look
different due to differences in the display monitor. Use gamma
correction to adjust for this color difference. Reasonable values
extend from 0.8 to 2.3.
.TP 5
.B "-geometry \fI<width>x<height>{\+-}<x offset>{\+-}<y offset>\fP"
preferred size and location of the image window. See \fBX(1)\fP for details
about the geometry specification. By default, the window size is the image
size and the location is choosen by you when it is mapped.
X
If the specified image size is smaller than the actual image size, the
image is first reduced to an integral of the specified image size with
an antialias digital filter. The image is then scaled to the exact
specified image size with pixel replication. If the specified image
size is greater than the actual image size, the image is first enlarged
to an integral of the specified image size with bilinear
interpolation. The image is then scaled to the exact specified image
size with pixel replication.
X
When displaying an image on an X server, the x and y offset in the
geometry specification is relative to the root window. When printing
an image, the x and y offset in the geometry specification is relative
to a Postscript page. See \fB-print\fP for more details.
.TP 5
.B "-gray"
transform the image to gray scale colors.
.TP 5
.B "-inverse"
apply color inversion to image.
X
The red, green, and blue intensities of an image are negated.
.TP 5
.B "-magnify \fIvalue\fP"
specifies an integral factor by which the image should be enlarged. The
default is 2.
X
This value only affects the magnification window which is invoked with
button number 1 after the image is displayed. Refer to \fBBUTTONS\fP
for more details.
.TP 5
.B "-map \fItype\fP"
display image using this Standard Colormap type.
X
Choose from these Standard Colormap types:
X
X default
X best
X red
X green
X blue
X gray
X
The X server must support the Standard Colormap you choose, otherwise an
error occurs. See \fBxcmap(1)\fP for one way of creating Standard Colormaps.
.TP 5
.B "-monochrome"
transform the image to black and white.
X
Monochrome images can benefit from error diffusion. Use \fB-dither\fP with
this option to diffuse the error.
.TP 5
.B "-noise"
reduce the noise in an image with a noise peak elimination filter.
X
The principal function of noise peak elimination filter is to smooth
the objects within an image without losing edge information and without
creating undesired structures. The central idea of the algorithm is to
replace a pixel with its next neighbor in value within a 3 x 3 window,
if this pixel has been found to be noise. A pixel is defined as noise
if and only if this pixel is a maximum or minimum within the 3 x 3 window.
.TP 5
.B "-normalize"
tranform image to span the full the range of colors.
.TP 5
.B "-print \fIfile\fP"
write image as encapsulated Postscript to a file.
X
You can view the file with any Postscript compatible viewer or
printer. The image is displayed as color on viewers and printers that
support color Postscript, otherwise it is displayed as grayscale.
X
If \fIfile\fP already exists, you will be prompted as to whether
it should be overwritten.
X
By default, the image is centered and scaled to fit on the Postscript page.
To specify a specific image size or a particular location on the Postscript
page, use \fB-geometry\fP.
X
By default the image is output in portrait mode. Use \fB-rotate 90\fP to
display the image in landscape mode.
.TP 5
.B "-reflect"
create a "mirror image" by reflecting the image scanlines.
.TP 5
.B "-root"
display image onto the root window.
X
The image will not display on the root window if the image has more
unique colors than the root window colormap allows. Use
\fB-colors\fP to reduce the number of colors.
X
By default the image is tiled onto the root window. If
\fB-backdrop\fP or \fB-geometry\fP are specified, the image is
surrounded by the background color. Refer to \fBX RESOURCES\fP for
details.
.TP 5
.B "-rotate \fIdegrees\fP"
apply Paeth image rotation to the image.
.TP 5
.B "-scale \fI<width factor>x<height factor>\fP"
preferred size factors of the image.
X
This option behaves like \fB-geometry\fP except the width and height values
are relative instead of absolute. The image size is multiplied by the
width and height factors to obtain the final image dimensions. If only
one factor is specified, both the width and height factors assume the
value.
X
Factors may be fractional. For example, a factor of 1.5 will increase the
image size by one and one-half.
.TP 5
.B "-scene \fInumber\fP"
image scene number.
.TP 5
.B "-treedepth \fIvalue\fP"
Normally, this integer value is zero or one. A zero or one tells
\fIDisplay\fP to choose a optimal tree depth for the color reduction
algorithm.
X
An optimal depth generally allows the best representation of the source
image with the fastest computational speed and the least amount of
memory. However, the default depth is inappropriate for some images.
To assure the best representation, try values between 2 and 8 for this
parameter. Refer to \fBCOLOR REDUCTION ALGORITHM\fP for more details.
X
The \fB-colors\fP, \fB-gray\fP, or \fB-monochrome\fP option is required
for this option to take effect.
.TP 5
.B -verbose
print detailed information about the image.
X
This information is printed: image scene number; image name; image
size; the image class (\fIDirectClass\fP or \fIPseudoClass\fP); the total
number of unique colors (if known); and the number of seconds to read and
transform the image. Refer to \fBMIFF FILE FORMAT\fP for a description of
the image class.
X
If \fB-colors\fP is also specified, the total unique colors in the image
and color reduction error values are printed. Refer to \fBMEASURING
COLOR REDUCTION ERROR\fP for a description of these values.
.TP 5
.B "-visual \fItype\fP"
display image using this visual type.
X
Choose from these visual classes:
X
X StaticGray
X GrayScale
X StaticColor
X PseudoColor
X TrueColor
X DirectColor
X default
X \fIvisual id\fP
X
The X server must support the visual you choose, otherwise an error occurs.
If a visual is not specified, the visual class that can display the most
simultaneous colors on the default screen is choosen.
.TP 5
.B "-write \fIfile\fP"
write image to a file.
X
The image is stored in the MIFF image format. If the number of unique
colors in the image exceed 65535, it is stored as \fIDirectClass\fP;
otherwise, it is stored as \fIPseudoClass\fP format. Refer to \fBMIFF
FILE FORMAT\fP for more details.
X
Use \fB-compress\fP to specify the type of image compression.
X
If \fIfile\fP has the extension \fB.Z\fP, the file size is reduced using
Lempel-Ziv coding with \fBcompress\fP. If \fIfile\fP already exists,
you will be prompted as to whether it should be overwritten.
.PP
In addition to those listed above, you can specify these standard X
resources as command line options: -background, -bordercolor,
-borderwidth, -font, -foreground, -iconGeometry, -iconic, -name, or -title.
See \fBX RESOURCES\fP for details.
.PP
Any option you specify on the command line remains in effect until it is
explicitly changed by specifying the option again with a different effect.
For example, to display two images, the first with 32 colors and the
second with only 16 colors, use:
.PP
X display -colors 32 cockatoo.miff -colors 16 macaw.miff
.PP
Change \fI-\fP to \fI\+\fP in any option above to reverse its effect.
For example, specify \fB\+display\fP to apply image transformations
without viewing them on the X server. Or, specify \fB\+compress\fP to store
the binary image in an uncompressed format.
.PP
Specify \fIfile\fP as \fI-\fP for standard input or output. If \fIfile\fP
has the extension \fB.Z\fP, the file is decoded with \fBuncompress\fP.
.SH BUTTONS
.TP 5
.B "Control-1"
Press and drag to pan the image.
.TP 5
.B "1"
Press and drag to select a command from a pop-up menu. Choose from
these commands:
X
X Image Info
X Half Size
X Double Size
X Rotate Right
X Rotate Left
X Reflect Image
X Restore Image
X Restore Window
X Magnify Window
X Next Image
X Quit
.TP 5
.B "2"
Press and drag to define a region of the image to clip. Release the button
to crop the image, or return the pointer to the location of the initial button
press to cancel the cropping operation.
.TP 5
.B "3"
Press and drag to define a region of the image to magnify.
.SH KEYS
.TP 5
.B "1-9"
Press to change the level of magnification.
.TP 5
.B "<"
Press to half the image size.
.TP 5
.B ">"
Press to double the image size.
.TP 5
.B "/"
Press to rotate the image 90 degrees clockwise.
.TP 5
.B "\e"
Press to rotate the image 90 degrees counter-clockwise.
.TP 5
.B "r"
Press to reflect the image scanlines.
.TP 5
.B "o"
Press to restore the image to its original size.
.TP 5
.B "w"
Press to restore the image window to its original size.
.TP 5
.B "m"
Press to map or unmap the magnify window.
.TP 5
.B "i"
Press to display information about the image. Press any key or button to
erase the information.
X
This information is printed: image name; image size; the visual class
(see \fB-visual\fP); and the total number of unique colors in the
image.
.TP 5
.B "n"
Press to display the next image.
.TP 5
.B "q"
Press to discard all images and exit program.
.SH "X RESOURCES"
\fIDisplay\fP options can appear on the command line or in your X
resource file. Options on the command line supercede values specified
in your X resource file. See \fBX(1)\fP for more information on X
resources.
X
All \fIdisplay\fP options have a corresponding X resource. In addition,
the \fIdisplay\fP program uses the following X resources:
.TP 5
.B background (\fPclass\fB Background)
Specifies the preferred color to use for the image window background. The
default is black.
.TP 5
.B borderColor (\fPclass\fB BorderColor)
Specifies the preferred color to use for the image window border. The
default is white.
.TP 5
.B borderWidth (\fPclass\fB BorderWidth)
Specifies the width in pixels of the image window border. The default is 2.
.TP 5
.B font (\fPclass\fB Font)
Specifies the name of the preferred font to use when displaying text in the
within the image window. The default is 9x15, fixed, or 5x8 determined by
the image window size.
.TP 5
.B foreground (\fPclass\fB Foreground)
Specifies the preferred color to use for text within the image window. The
default is white.
.TP 5
.B iconGeometry (\fPclass\fB IconGeometry)
Specifies the preferred size and position of the application when
iconified. It is not necessarily obeyed by all window managers.
.TP 5
.B iconic (\fPclass\fB Iconic)
This resource indicates that you would prefer that the application's
windows initially not be visible as if the windows had be immediately
iconified by you. Window managers may choose not to honor the
application's request.
.TP 5
.B name (\fPclass\fB Name)
This resource specifies the name under which resources for the
application should be found. This resource is useful in shell aliases to
distinguish between invocations of an application, without resorting to
creating links to alter the executable file name. The default is the
application name.
.TP 5
.B title (\fPclass\fB Title)
This resource specifies the title to be used for the image window. This
information is sometimes used by a window manager to provide some sort
of header identifying the window. The default is the image file name.
.SH "COLOR REDUCTION ALGORITHM"
.PP
This section describes how \fIDisplay\fP performs color reduction in an
image. To fully understand this section, you should have a knowledge
of basic imaging techniques and the tree data structure and terminology.
.PP
For purposes of color allocation, an image is a set of \fIn\fP pixels,
where each pixel is a point in RGB space. RGB space is a 3-dimensional
vector space, and each pixel, \fIp\d\s-3i\s0\u\fP, is defined by an
ordered triple of red, green, and blue coordinates, (\fIr\d\s-3i\s0\u,
g\d\s-3i\s0\u, b\d\s-3i\s0\u\fP).
.PP
Each primary color component (red, green, or blue) represents an
intensity which varies linearly from 0 to a maximum value,
\fIc\d\s-3max\s0\u\fP, which corresponds to full saturation of that
color. Color allocation is defined over a domain consisting of the
cube in RGB space with opposite vertices at (0,0,0) and
(\fIc\d\s-3max\s0\u,c\d\s-3max\s0\u,c\d\s-3max\s0\u\fP). \fIDisplay\fP
requires \fIc\d\s-3max\s0\u = 255\fP.
.PP
The algorithm maps this domain onto a tree in which each node
represents a cube within that domain. In the following discussion,
these cubes are defined by the coordinate of two opposite vertices: The
vertex nearest the origin in RGB space and the vertex farthest from the
origin.
.PP
The tree's root node represents the the entire domain, (0,0,0) through
(\fIc\d\s-3max\s0\u,c\d\s-3max\s0\u,c\d\s-3max\s0\u\fP). Each lower level in
the tree is generated by subdividing one node's cube into eight smaller
cubes of equal size. This corresponds to bisecting the parent cube
with planes passing through the midpoints of each edge.
.PP
The basic algorithm operates in three phases: \fBClassification,
Reduction\fP, and \fBAssignment\fP. \fBClassification\fP builds a
color description tree for the image. \fBReduction\fP collapses the
tree until the number it represents, at most, is the number of colors
desired in the output image. \fBAssignment\fP defines the output
image's color map and sets each pixel's color by reclassification in
the reduced tree.
.PP
\fBClassification\fP begins by initializing a color description tree of
sufficient depth to represent each possible input color in a leaf.
However, it is impractical to generate a fully-formed color description
tree in the classification phase for realistic values of
\fIc\d\s-3max\s0\u\fP. If color components in the input image are
quantized to \fIk\fP-bit precision, so that \fIc\d\s-3max\s0\u =
2\u\s-3k\s0\d-1\fP, the tree would need \fIk\fP levels below the root
node to allow representing each possible input color in a leaf. This
becomes prohibitive because the tree's total number of nodes is
.PP
X \fI\s+6\(*S\u\s-9 k\d\di=1\s0 8k\fP\s0\u
.PP
A complete tree would require 19,173,961 nodes for \fIk = 8,
c\d\s-3max\s0\u = 255\fP. Therefore, to avoid building a fully
populated tree, \fIDisplay\fP: (1) Initializes data structures for
nodes only as they are needed; (2) Chooses a maximum depth for the tree
as a function of the desired number of colors in the output image
(currently \fIlog\d\s-34\s0\u(colormap size)\+2\fP). A tree of this
depth generally allows the best representation of the source image with
the fastest computational speed and the least amount of memory.
However, the default depth is inappropriate for some images.
Therefore, the caller can request a specific tree depth.
.PP
For each pixel in the input image, classification scans downward from
the root of the color description tree. At each level of the tree, it
identifies the single node which represents a cube in RGB space
containing the pixel's color. It updates the following data for each
such node:
.TP 5
.B n\d\s-31\s0\u:
Number of pixels whose color is contained in the RGB cube which this
node represents;
.TP 5
.B n\d\s-32\s0\u:
Number of pixels whose color is not represented in a node at lower
depth in the tree; initially, \fIn\d\s-32\s0\u = 0\fP for all nodes
except leaves of the tree.
.TP 5
.B S\d\s-3r\s0\u, S\d\s-3g\s0\u, S\d\s-3b\s0\u:
Sums of the red, green, and blue component values for all pixels not
classified at a lower depth. The combination of these sums and
\fIn\d\s-32\s0\u\fP will ultimately characterize the mean color of a
set of pixels represented by this node.
.PP
\fBReduction\fP repeatedly prunes the tree until the number of nodes with
\fIn\d\s-32\s0\u > 0\fP is less than or equal to the maximum number of colors
allowed in the output image. On any given iteration over the tree, it
selects those nodes whose \fIn\d\s-31\s0\u\fP count is minimal for pruning and
merges their color statistics upward. It uses a pruning threshold,
\fIn\d\s-3p\s0\u\fP, to govern node selection as follows:
.PP
X n\d\s-3p\s0\u = 0
X while number of nodes with (n\d\s-32\s0\u > 0) > required maximum number of colors
X prune all nodes such that n\d\s-31\s0\u <= n\d\s-3p\s0\u
X Set n\d\s-3p\s0\u to minimum n\d\s-31\s0\u in remaining nodes
.PP
When a node to be pruned has offspring, the pruning procedure invokes
itself recursively in order to prune the tree from the leaves upward.
The values of \fIn\d\s-32\s0\u S\d\s-3r\s0\u, S\d\s-3g\s0\u,\fP and
\fIS\d\s-3b\s0\u\fP in a node being pruned are always added to the
corresponding data in that node's parent. This retains the pruned
node's color characteristics for later averaging.
.PP
For each node, \fIn\d\s-32\s0\u\fP pixels exist for which that node
represents the smallest volume in RGB space containing those pixel's
colors. When \fIn\d\s-32\s0\u > 0\fP the node will uniquely define a
color in the output image. At the beginning of reduction,
\fIn\d\s-32\s0\u = 0\fP for all nodes except the leaves of the tree
which represent colors present in the input image.
.PP
The other pixel count, \fIn\d\s-31\s0\u\fP, indicates the total
number of colors within the cubic volume which the node represents.
This includes \fIn\d\s-31\s0\u - n\d\s-32\s0\u\fP pixels whose colors
should be defined by nodes at a lower level in the tree.
.PP
\fBAssignment\fP generates the output image from the pruned tree. The
output image consists of two parts: (1) A color map, which is an
array of color descriptions (RGB triples) for each color present in the
output image; (2) A pixel array, which represents each pixel as an
index into the color map array.
.PP
First, the assignment phase makes one pass over the pruned color
description tree to establish the image's color map. For each node
with \fIn\d\s-32\s0\u > 0\fP, it divides \fIS\d\s-3r\s0\u,
S\d\s-3g\s0\u\fP, and \fPS\d\s-3b\s0\u\fP by \fIn\d\s-32\s0\u\fP. This
produces the mean color of all pixels that classify no lower than this
node. Each of these colors becomes an entry in the color map.
.PP
Finally, the assignment phase reclassifies each pixel in the pruned
tree to identify the deepest node containing the pixel's color. The
pixel's value in the pixel array becomes the index of this node's mean
color in the color map.
.SH "MEASURING COLOR REDUCTION ERROR"
.PP
Depending on the image, the color reduction error may be obvious or
invisible. Images with high spatial frequencies (such as hair or
grass) will show error much less than pictures with large smoothly
shaded areas (such as faces). This is because the high-frequency
contour edges introduced by the color reduction process are masked by
the high frequencies in the image.
.PP
To measure the difference between the original and color reduced images
(the total color reduction error), \fIDisplay\fP sums over all pixels
in an image the distance squared in RGB space between each original
pixel value and its color reduced value. \fIDisplay\fP prints several error
measurements including the mean error per pixel, the normalized mean error,
and the normalized maximum error.
.PP
The normalized error measurement can be used to compare images. In
general, the closer the mean error is to zero the more the quantized
image resembles the source image. Ideally, the error should be
perceptually-based, since the human eye is the final judge of
quantization quality.
.PP
These errors are measured and printed when \fB-verbose\fP and \fB-colors\fI
are specified on the command line:
.TP 5
.B mean error per pixel:
is the mean error for any single pixel in the image.
.TP 5
.B normalized mean square error:
is the normalized mean square quantization error for any single pixel in the
image.
X
This distance measure is normalized to a range between 0 and 1. It is
independent of the range of red, green, and blue values in the image.
.TP 5
.B normalized maximum square error:
is the largest normalized square quantization error for any single
pixel in the image.
X
This distance measure is normalized to a range between 0 and 1. It is
independent of the range of red, green, and blue values in the image.
.SH "MIFF FILE FORMAT"
.PP
The Machine Independent File Format is described in this section.
.PP
A MIFF image file consist of two sections. The first section is
composed of keywords describing the image in text form. The next
section is the binary image data. The two sections are separated by a
\fB:\fP character immediately followed by a \fInewline\fP. Generally,
the first section has a \fIform-feed\fP and \fInewline\fP proceeding
the \fB:\fP character. You can then list the image keywords with
\fImore\fP, without printing the binary image that follows the \fB:\fP
separator.
.PP
Each keyword must be separated by at least one space but can be
separated with control characters such a \fIform-feed\fP or
\fInewline\fP.
.PP
A list of valid keywords follows:
.TP 5
.B "class=\fIDirectClass | PseudoClass\fP"
identifies the type of binary image stored within the file.
X
This keyword is optional. If it is not specified, a \fIDirectClass\fP
image format is assumed. An explanation of \fIDirectClass\fP and
\fIPseudoClass\fP image data follows this list.
.TP 5
.B "colors=\fIvalue\fP"
specifies the number of colors in the image, and for pseudo-color
images the size of the colormap.
X
This keyword is optional. However, if a colormap size is not
specified, a linear colormap is assumed for pseudo-color images.
.TP 5
.B "columns=\fIvalue\fP"
is a required keyword and specifies the number of columns, or width in
pixels, of the image.
.TP 5
.B "compression=\fIQEncoded | RunlengthEncoded\fP"
identifies how the image stored within the file is compressed.
X
This keyword is optional. If it is not specified, the image is assumed
to be uncompressed. A detailed explanation of runlength-encoded and
Q-coder image compression follows this list.
.TP 5
.B "id=\fIImageMagick\fP"
is a required keyword and identifies this file as a MIFF image.
.TP 5
.B "packets=\fIvalue\fP"
specifies the number of compressed color packets in the image data section.
X
This keyword is optional, but recommended, for runlength-encoded image
compression. It is required for Q-encoded image compression. A
detailed explanation of image compression follows this list.
.TP 5
.B "rows=\fIvalue\fP"
is a required keyword and specifies the number of rows, or height in pixels,
of the image.
.TP 5
.B "scene=\fIvalue\fP"
is an optional keyword and is a reference number for sequencing of
images.
X
This keyword is typically useful for animating a sequence of images.
.PP
Comments can be included in the keyword section. Comments must begin with
a \fB{\fP character and end with a \fI}\fP character.
.PP
An example keyword section follows:
.PP
X {
X Rendered via Dore by Sandy Hause.
X }
X id=ImageMagick
X class=PseudoClass colors=256
X compression=RunlengthEncoded packets=27601
X columns=1280 rows=1024
X scene=1
X ^L
X :
.PP
The binary image data that follows the keyword text is stored in one of
two binary classes as specified by the \fBclass\fP keyword:
\fIDirectClass\fP or \fIPseudoClass\fP.
.PP
Use the \fIDirectClass\fP class to store continuous-tone images.
\fIDirectClass\fP requires that the image pixels immediately follow the
keyword text and be stored as binary red, green, and blue intensity
values. The total number of pixels expected is equal to the number of pixel
columns times the number of pixel rows as specified by the \fBcolumns\fP and
\fBrows\fP keywords.
.PP
If the \fBcompression\fP keyword is not specified, a red, green, and blue byte
in that order is expected for each pixel of the image.
.PP
If \fBcompression\fP is \fIQEncoded\fP, each red, green, and blue byte
intensity value is encoded using the Q-coder compression algorithm.
Use the \fBpackets\fP keyword to specify the total number of Q-encoded
packets that comprise the image. Refer to "Sofware implementations of
the Q-Coder", by Mitchell, J. L. and Pennebaker, W.B. (IBM Journal Res.
Development, Volume 32, Number 6, November 1988, pages 753 - 774) for
implementation specific details.
.PP
If \fBcompression\fP is \fIRunlengthEncoded\fP, each red, green, and
blue byte intensity value is followed by a count byte. This value
specifies the number of horizonally contiguous pixels in the image of
that color. The count (0-255) is one less than the actual number of
contiguous pixels; thus a single packet can represent from 1 up to 256
identical pixels. The total number of pixels specified by the
individual count bytes must add up to the number of pixel columns times
the number of pixel rows as specified by the \fBcolumns\fP and
\fBrows\fP keywords. Use \fBpackets\fP to specify the total number of
runlength-encoded packets that comprise the image.
.PP
Use the \fIPseudoClass\fP class to store pseudo-color images.
\fIPseudoClass\fP requires that the image colormap and
pseudo-color pixels immediately follow the keyword text. The colormap
is stored as contiguous red, green, and blue intensity values. The
number of intensity values expected is determined by the \fBcolors\fP
keyword. Note, an image colormap is restricted to at most 65535
entries. The binary pseudo-color image is stored as indexes into the
colormap. If the colormap size exceeds 256 entries, then each colormap
index is two bytes each with the most-significant-byte first. The
total number of pixels expected is equal to the number of pixel columns
times the number of pixel rows as specified by the \fBcolumns\fP and
\fBrows\fP keywords.
.PP
If the \fBcompression\fP keyword is not specified, a colormap index is
expected for each pixel of the image.
.PP
If \fBcompression\fP is \fIQEncoded\fP, each colormap index is
encoded using the Q-coder compression algorithm. Use the \fBpackets\fP
keyword to specify the total number of Q-encoded packets comprise the
image. Refer to "Sofware implementations of the Q-Coder", by Mitchell,
J. L. and Pennebaker, W.B. (IBM Journal Res. Development, Volume 32,
Number 6, November 1988, pages 753 - 774) for implementation specific
details.
.PP
If \fBcompression\fP is \fIRunlengthEncoded\fP, each colormap index
is followed by a count byte. This value specifies the number of
horizonally contiguous pixels in the image of that color. The count
(0-255) is one less than the actual number of contiguous pixels; thus a
single packet can represent from 1 up to 256 identical pixels. The
total number of pixels specified by the individual count bytes must add
up to the number of pixels expected in the image as specified by the
\fBcolumns\fP and \fBrows\fP keywords. Use \fBpackets\fP to specify the
total number of runlength-encoded packets that comprise the image.
.SH FEATURES
Although \fIDisplay\fP will display an image on a server with an immutable
colormap, the image quality may suffer as compared to a server with a
read/write colormap.
.PP
\fIDisplay\fP memory requirements is proportionate to the area of the image.
.PP
\fIDisplay\fP does not complain when it encounters a keyword in an image file
it does not understand.
.SH ENVIRONMENT
.TP 5
.B DISPLAY
To get the default host, display number, and screen.
.SH SEE ALSO
XX(1), xcmap(1), import(1), XtoPS(1), more(1), compress(1)
.SH COPYRIGHT
Copyright 1991 E. I. Dupont de Nemours & Company
.PP
Permission to use, copy, modify, distribute, and sell this software and
its documentation for any purpose is hereby granted without fee,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of E. I. Dupont de Nemours
& Company not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission. E. I. Dupont de Nemours & Company makes no representations
about the suitability of this software for any purpose. It is provided
"as is" without express or implied warranty.
.PP
E. I. Dupont de Nemours & Company disclaims all warranties with regard
to this software, including all implied warranties of merchantability
and fitness, in no event shall E. I. Dupont de Nemours & Company be
liable for any special, indirect or consequential damages or any
damages whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action, arising
out of or in connection with the use or performance of this software.
.SH ACKNOWLEDGEMENTS
The MIT X Consortium for making network transparent graphics a reality.
.PP
Michael Halle, Spatial Imaging Group at MIT, for the initial
implementation of Alan Paeth's image rotation algorithm.
.PP
David Pensak, E. I. Dupont de Nemours & Company, for providing a
computing environment that made this program possible.
.PP
Paul Raveling, USC Information Sciences Institute, for the original
idea of using space subdivision for the color reduction algorithm.
With Paul's permission, the \fBCOLOR REDUCTION ALGORITHM\fP section is
a adaptation from a document he wrote.
.SH AUTHORS
John Cristy, E.I. DuPont de Nemours & Company Incorporated
SHAR_EOF
echo 'File ImageMagick/display.man is complete' &&
chmod 0755 ImageMagick/display.man ||
echo 'restore of ImageMagick/display.man failed'
Wc_c="`wc -c < 'ImageMagick/display.man'`"
test 33436 -eq "$Wc_c" ||
echo 'ImageMagick/display.man: original size 33436, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ImageMagick/xtp/Makefile ==============
if test ! -d 'ImageMagick/xtp'; then
echo 'x - creating directory ImageMagick/xtp'
mkdir 'ImageMagick/xtp'
fi
if test -f 'ImageMagick/xtp/Makefile' -a X"$1" != X"-c"; then
echo 'x - skipping ImageMagick/xtp/Makefile (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ImageMagick/xtp/Makefile (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ImageMagick/xtp/Makefile' &&
# Makefile generated by imake - do not edit!
# $XConsortium: imake.c,v 1.51 89/12/12 12:37:30 jim Exp $
#
# The cpp used on this machine replaces all newlines and multiple tabs and
# spaces in a macro expansion with a single space. Imake tries to compensate
# for this, but is not always successful.
#
X
###########################################################################
# Makefile generated from "Imake.tmpl" and <Imakefile>
# $XConsortium: Imake.tmpl,v 1.77 89/12/18 17:01:37 jim Exp $
#
# Platform-specific parameters may be set in the appropriate .cf
# configuration files. Site-wide parameters may be set in the file
# site.def. Full rebuilds are recommended if any parameters are changed.
#
# If your C preprocessor doesn't define any unique symbols, you'll need
# to set BOOTSTRAPCFLAGS when rebuilding imake (usually when doing
# "make Makefile", "make Makefiles", or "make World").
#
# If you absolutely can't get imake to work, you'll need to set the
# variables at the top of each Makefile as well as the dependencies at the
# bottom (makedepend will do this automatically).
#
X
###########################################################################
# platform-specific configuration parameters - edit sun.cf to change
X
# platform: $XConsortium: sun.cf,v 1.38 89/12/23 16:10:10 jim Exp $
# operating system: SunOS 4.0.3
X
###########################################################################
# site-specific configuration parameters - edit site.def to change
X
# site: $XConsortium: site.def,v 1.21 89/12/06 11:46:50 jim Exp $
X
X SHELL = /bin/sh
X
X TOP = .
X CURRENT_DIR = .
X
X AR = ar cq
X BOOTSTRAPCFLAGS =
X CC = cc
X
X COMPRESS = compress
X CPP = /lib/cpp $(STD_CPP_DEFINES)
X PREPROCESSCMD = cc -E $(STD_CPP_DEFINES)
X INSTALL = install
X LD = ld
X LINT = lint
X LINTLIBFLAG = -C
X LINTOPTS = -axz
X LN = ln -s
X MAKE = make
X MV = mv
X CP = cp
X RANLIB = ranlib
X RANLIBINSTFLAGS =
X RM = rm -f
X STD_INCLUDES =
X STD_CPP_DEFINES =
X STD_DEFINES =
X EXTRA_LOAD_FLAGS =
X EXTRA_LIBRARIES =
X TAGS = ctags
X
X SHAREDCODEDEF = -DSHAREDCODE
X SHLIBDEF = -DSUNSHLIB
X
X PROTO_DEFINES =
X
X INSTPGMFLAGS =
X
X INSTBINFLAGS = -m 0755
X INSTUIDFLAGS = -m 4755
X INSTLIBFLAGS = -m 0664
X INSTINCFLAGS = -m 0444
X INSTMANFLAGS = -m 0444
X INSTDATFLAGS = -m 0444
X INSTKMEMFLAGS = -m 4755
X
X DESTDIR =
X
X TOP_INCLUDES = -I$(INCROOT)
X
X CDEBUGFLAGS = -O
X CCOPTIONS =
X COMPATFLAGS =
X
X ALLINCLUDES = $(STD_INCLUDES) $(TOP_INCLUDES) $(INCLUDES) $(EXTRA_INCLUDES)
X ALLDEFINES = $(ALLINCLUDES) $(STD_DEFINES) $(PROTO_DEFINES) $(DEFINES) $(COMPATFLAGS)
X CFLAGS = $(CDEBUGFLAGS) $(CCOPTIONS) $(ALLDEFINES)
X LINTFLAGS = $(LINTOPTS) -DLINT $(ALLDEFINES)
X LDLIBS = $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
X LDOPTIONS = $(CDEBUGFLAGS) $(CCOPTIONS)
X LDCOMBINEFLAGS = -X -r
X
X MACROFILE = sun.cf
X RM_CMD = $(RM) *.CKP *.ln *.BAK *.bak *.o core errs ,* *~ *.a .emacs_* tags TAGS make.log MakeOut
X
X IMAKE_DEFINES =
X
X IRULESRC = $(CONFIGDIR)
X IMAKE_CMD = $(IMAKE) -DUseInstalled -I$(IRULESRC) $(IMAKE_DEFINES)
X
X ICONFIGFILES = $(IRULESRC)/Imake.tmpl $(IRULESRC)/Imake.rules \
X $(IRULESRC)/Project.tmpl $(IRULESRC)/site.def \
X $(IRULESRC)/$(MACROFILE) $(EXTRA_ICONFIGFILES)
X
###########################################################################
# X Window System Build Parameters
# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
X
###########################################################################
# X Window System make variables; this need to be coordinated with rules
# $XConsortium: Project.tmpl,v 1.63 89/12/18 16:46:44 jim Exp $
X
X PATHSEP = /
X USRLIBDIR = $(DESTDIR)/usr/lib
X BINDIR = $(DESTDIR)/usr/bin/X11
X INCROOT = $(DESTDIR)/usr/include
X BUILDINCROOT = $(TOP)
X BUILDINCDIR = $(BUILDINCROOT)/X11
X BUILDINCTOP = ..
X INCDIR = $(INCROOT)/X11
X ADMDIR = $(DESTDIR)/usr/adm
X LIBDIR = $(USRLIBDIR)/X11
X CONFIGDIR = $(LIBDIR)/config
X LINTLIBDIR = $(USRLIBDIR)/lint
X
X FONTDIR = $(LIBDIR)/fonts
X XINITDIR = $(LIBDIR)/xinit
X XDMDIR = $(LIBDIR)/xdm
X AWMDIR = $(LIBDIR)/awm
X TWMDIR = $(LIBDIR)/twm
X GWMDIR = $(LIBDIR)/gwm
X MANPATH = $(DESTDIR)/usr/man
X MANSOURCEPATH = $(MANPATH)/man
X MANDIR = $(MANSOURCEPATH)n
X LIBMANDIR = $(MANSOURCEPATH)3
X XAPPLOADDIR = $(LIBDIR)/app-defaults
X
X SOXLIBREV = 4.2
X SOXTREV = 4.0
X SOXAWREV = 4.0
X SOOLDXREV = 4.0
X SOXMUREV = 4.0
X SOXEXTREV = 4.0
X
X FONTCFLAGS = -t
X
X INSTAPPFLAGS = $(INSTDATFLAGS)
X
X IMAKE = imake
X DEPEND = makedepend
X RGB = rgb
X FONTC = bdftosnf
X MKFONTDIR = mkfontdir
X MKDIRHIER = /bin/sh $(BINDIR)/mkdirhier.sh
X
X CONFIGSRC = $(TOP)/config
X CLIENTSRC = $(TOP)/clients
X DEMOSRC = $(TOP)/demos
X LIBSRC = $(TOP)/lib
X FONTSRC = $(TOP)/fonts
X INCLUDESRC = $(TOP)/X11
X SERVERSRC = $(TOP)/server
X UTILSRC = $(TOP)/util
X SCRIPTSRC = $(UTILSRC)/scripts
X EXAMPLESRC = $(TOP)/examples
X CONTRIBSRC = $(TOP)/../contrib
X DOCSRC = $(TOP)/doc
X RGBSRC = $(TOP)/rgb
X DEPENDSRC = $(UTILSRC)/makedepend
X IMAKESRC = $(CONFIGSRC)
X XAUTHSRC = $(LIBSRC)/Xau
X XLIBSRC = $(LIBSRC)/X
X XMUSRC = $(LIBSRC)/Xmu
X TOOLKITSRC = $(LIBSRC)/Xt
X AWIDGETSRC = $(LIBSRC)/Xaw
X OLDXLIBSRC = $(LIBSRC)/oldX
X XDMCPLIBSRC = $(LIBSRC)/Xdmcp
X BDFTOSNFSRC = $(FONTSRC)/bdftosnf
X MKFONTDIRSRC = $(FONTSRC)/mkfontdir
X EXTENSIONSRC = $(TOP)/extensions
X
X DEPEXTENSIONLIB = $(USRLIBDIR)/libXext.a
X EXTENSIONLIB = -lXext
X
X DEPXLIB = $(DEPEXTENSIONLIB)
X XLIB = $(EXTENSIONLIB) -lX11
X
X DEPXAUTHLIB = $(USRLIBDIR)/libXau.a
X XAUTHLIB = -lXau
X
X DEPXMULIB =
X XMULIB = -lXmu
X
X DEPOLDXLIB =
X OLDXLIB = -loldX
X
X DEPXTOOLLIB =
X XTOOLLIB = -lXt
X
X DEPXAWLIB =
X XAWLIB = -lXaw
X
X LINTEXTENSIONLIB = $(USRLIBDIR)/llib-lXext.ln
X LINTXLIB = $(USRLIBDIR)/llib-lX11.ln
X LINTXMU = $(USRLIBDIR)/llib-lXmu.ln
X LINTXTOOL = $(USRLIBDIR)/llib-lXt.ln
X LINTXAW = $(USRLIBDIR)/llib-lXaw.ln
X
X DEPLIBS = $(DEPXAWLIB) $(DEPXMULIB) $(DEPXTOOLLIB) $(DEPXLIB)
X
X DEPLIBS1 = $(DEPLIBS)
X DEPLIBS2 = $(DEPLIBS)
X DEPLIBS3 = $(DEPLIBS)
X
###########################################################################
# Imake rules for building libraries, programs, scripts, and data files
# rules: $XConsortium: Imake.rules,v 1.67 89/12/18 17:14:15 jim Exp $
X
###########################################################################
# start of Imakefile
X
BINDIR = $(DESTDIR)/usr/local/bin
PROGRAMS= xtp
SRCS= xtp.c regular.c
OBJS= xtp.o regular.o
X
all:: $(PROGRAMS)
X
X PROGRAM = xtp
X
all:: xtp
X
xtp: $(OBJS) $(DEPLIBS)
X $(RM) $@
X $(CC) -o $@ $(OBJS) $(LDOPTIONS) $(LOCAL_LIBRARIES) $(LDLIBS) $(EXTRA_LOAD_FLAGS)
X
saber_xtp:
X #load $(ALLDEFINES) $(SRCS) $(LOCAL_LIBRARIES) $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
X
osaber_xtp:
X #load $(ALLDEFINES) $(OBJS) $(LOCAL_LIBRARIES) $(SYS_LIBRARIES) $(EXTRA_LIBRARIES)
X
install:: xtp
X $(INSTALL) -c $(INSTPGMFLAGS) xtp $(BINDIR)
X
install.man:: xtp.man
X $(INSTALL) -c $(INSTMANFLAGS) xtp.man $(MANDIR)/xtp.n
X
depend::
X $(DEPEND) -s "# DO NOT DELETE" -- $(ALLDEFINES) -- $(SRCS)
X
lint:
X $(LINT) $(LINTFLAGS) $(SRCS) $(LINTLIBS)
lint1:
X $(LINT) $(LINTFLAGS) $(FILE) $(LINTLIBS)
X
clean::
X $(RM) $(PROGRAM)
X
###########################################################################
# common rules for all Makefiles - do not edit
X
emptyrule::
X
clean::
X $(RM_CMD) \#*
X
Makefile::
X - at if [ -f Makefile ]; then \
X echo " $(RM) Makefile.bak; $(MV) Makefile Makefile.bak"; \
X $(RM) Makefile.bak; $(MV) Makefile Makefile.bak; \
X else exit 0; fi
X $(IMAKE_CMD) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT_DIR)
X
tags::
X $(TAGS) -w *.[ch]
X $(TAGS) -xw *.[ch] > TAGS
X
saber:
X #load $(ALLDEFINES) $(SRCS)
X
osaber:
X #load $(ALLDEFINES) $(OBJS)
X
###########################################################################
# empty rules for directories that do not have SUBDIRS - do not edit
X
install::
X @echo "install in $(CURRENT_DIR) done"
X
install.man::
X @echo "install.man in $(CURRENT_DIR) done"
X
Makefiles::
X
includes::
X
###########################################################################
# dependencies generated by makedepend
X
SHAR_EOF
chmod 0755 ImageMagick/xtp/Makefile ||
echo 'restore of ImageMagick/xtp/Makefile failed'
Wc_c="`wc -c < 'ImageMagick/xtp/Makefile'`"
test 8840 -eq "$Wc_c" ||
echo 'ImageMagick/xtp/Makefile: original size 8840, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ImageMagick/xtp/Imakefile ==============
if test -f 'ImageMagick/xtp/Imakefile' -a X"$1" != X"-c"; then
echo 'x - skipping ImageMagick/xtp/Imakefile (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ImageMagick/xtp/Imakefile (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ImageMagick/xtp/Imakefile' &&
BINDIR = $(DESTDIR)/usr/local/bin
PROGRAMS= xtp
SRCS= xtp.c regular.c
OBJS= xtp.o regular.o
X
AllTarget($(PROGRAMS))
X
ComplexProgramTarget(xtp)
SHAR_EOF
chmod 0755 ImageMagick/xtp/Imakefile ||
echo 'restore of ImageMagick/xtp/Imakefile failed'
Wc_c="`wc -c < 'ImageMagick/xtp/Imakefile'`"
test 143 -eq "$Wc_c" ||
echo 'ImageMagick/xtp/Imakefile: original size 143, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ImageMagick/xtp/xtp.1 ==============
if test -f 'ImageMagick/xtp/xtp.1' -a X"$1" != X"-c"; then
echo 'x - skipping ImageMagick/xtp/xtp.1 (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ImageMagick/xtp/xtp.1 (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ImageMagick/xtp/xtp.1' &&
X
X
X
X9XTP(1) (16 June 1990) XTP(1)
X
X
X
NNNNAAAAMMMMEEEE
X xtp - file transfer program
X
SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
X xxxxttttpppp [ -_o_p_t_i_o_n_s ... ] <_h_o_s_t/_i_p _a_d_d_r_e_s_s> <_h_o_m_e _d_i_r_e_c_t_o_r_y>
X
DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
X _X_t_p is a utility for retrieving, listing, or printing files
X from a remote network site. _X_t_p performs most of the same
X functions as the _f_t_p program, but does not require any
X interactive commands. You simply specify the file transfer
X task on the command line and _x_t_p performs the task
X automatically.
X
EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
X To retrieve file display.tar.Z from host wizard.dupont.com,
X use:
X
X xtp -binary -retrieve display.tar.Z wizard.dupont.com
X
X To retrieve all the files from directory _p_u_b_l_i_c/_d_o_c_u_m_e_n_t_s
X from host wizard.dupont.com, use:
X
X xtp -binary -retrieve documents/ wizard.dupont.com
X public
X
OOOOPPPPTTTTIIIIOOOONNNNSSSS
X ----bbbbiiiinnnnaaaarrrryyyy
X retrieve files as binary.
X
X ----eeeexxxxcccclllluuuuddddeeee _e_x_p_r_e_s_s_i_o_n
X exclude files that match the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n.
X
X ----ddddiiiirrrreeeeccccttttoooorrrryyyy _e_x_p_r_e_s_s_i_o_n
X list the names of files and their attributes that match
X the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n.
X
X ----iiiiddddeeeennnntttt _p_a_s_s_w_o_r_d
X specifies password.
X
X ----pppprrrriiiinnnntttt _e_x_p_r_e_s_s_i_o_n
X print files that match the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n.
X
X ----rrrreeeettttrrrriiiieeeevvvveeee _e_x_p_r_e_s_s_i_o_n
X retrieve files that match the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n.
X
X Retrieved files are stored on your local host directory
X as the full name of the retrieved file. For example,
X if the retrieved file is named _d_o_c_u_m_e_n_t_s/_x_t_p._m_a_n on the
X remote FTP server, it will appear in your home
X directory as _d_o_c_u_m_e_n_t_s/_x_t_p._m_a_n.
X9
X
(printed 12/12/90) Ardent Computer Corporation Page 1
X
X
X
X
X
X
X
X9XTP(1) (16 June 1990) XTP(1)
X
X
X
X ----ttttiiiimmmmeeeeoooouuuutttt _s_e_c_o_n_d_s
X specifies maximum seconds to logon to the remote FTP
X server. If this time expires, the program terminates.
X
X ----uuuusssseeeerrrr _n_a_m_e
X identify yourself to the remote FTP server.
X
X If ----uuuusssseeeerrrr is specified but not ----iiiiddddeeeennnntttt, the password is
X obtained from you interactively.
X
X If neither ----pppprrrriiiinnnntttt or ----rrrreeeettttrrrriiiieeeevvvveeee are specified on the command
X line, a directory of files is listed for the remote network
X host.
X
X Filename searching begins at the home directory. Some
X remote hosts may have thousands of files causing a
X significant delay satisfying your request. You can reduce
X the searching required by specifying <_h_o_m_e _d_i_r_e_c_t_o_r_y> on the
X command line. This limits the filename search to the
X specified directory and any of its subdirectories.
X
X If only the program name is specified on the command line,
X the program command syntax and options are listed.
X
RRRREEEEGGGGUUUULLLLAAAARRRR EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS
X A _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n is zero or more branches, separated by
X ||||. It matches anything that matches one of the branches.
X
X A branch is zero or more pieces, concatenated. It matches a
X match for the first, followed by a match for the second,
X etc.
X
X A piece is an atom possibly followed by ****, ++++, or ????. An atom
X followed by **** matches a sequence of 0 or more matches of the
X atom. An atom followed by ++++ matches a sequence of 1 or more
X matches of the atom. An atom followed by ???? matches a match
X of the atom, or the null pattern.
X
X An atom is a _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n in parentheses (matching a
X match for the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n), a range (see below), ....
X (matching any single character), ^^^^ (matching the null
X pattern at the beginning of the input pattern), $$$$ (matching
X the null pattern at the end of the input pattern), a ''''
X followed by a single character (matching that character), or
X a single character with no other significance (matching that
X character).
X
X A range is a sequence of characters enclosed in [[[[]]]]. It
X normally matches any single character from the sequence. If
X the sequence begins with ^^^^, it matches any single character
X not from the rest of the sequence. If two characters in the
X sequence are separated by ----, this is shorthand for the full
X
X
(printed 12/12/90) Ardent Computer Corporation Page 2
X
X
X
X9
X
X
X9XTP(1) (16 June 1990) XTP(1)
X
X
X
X list of ASCII characters between them (e.g. [[[[0000----9999]]]] matches
X any decimal digit). To include a literal ]]]] in the sequence,
X make it the first character (following a possible ^^^^). To
X include a literal ----, make it the first or last character.
X
SSSSEEEEEEEE AAAALLLLSSSSOOOO
X ftp(1C)
X
CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
X Copyright 1990 E. I. Dupont de Nemours & Company
X
X Permission to use, copy, modify, distribute, and sell this
X software and its documentation for any purpose is hereby
X granted without fee, provided that the above copyright
X notice appear in all copies and that both that copyright
X notice and this permission notice appear in supporting
X documentation, and that the name of E. I. Dupont de Nemours
X & Company not be used in advertising or publicity pertaining
X to distribution of the software without specific, written
X prior permission. E. I. Dupont de Nemours & Company makes
X no representations about the suitability of this software
X for any purpose. It is provided "as is" without express or
X implied warranty.
X
X E. I. Dupont de Nemours & Company disclaims all warranties
X with regard to this software, including all implied
X warranties of merchantability and fitness, in no event shall
X E. I. Dupont de Nemours & Company be liable for any special,
X indirect or consequential damages or any damages whatsoever
X resulting from loss of use, data or profits, whether in an
X action of contract, negligence or other tortious action,
X arising out of or in connection with the use or performance
X of this software.
X
AAAACCCCKKKKNNNNOOOOWWWWLLLLEEEEDDDDGGGGEEEEMMMMEEEENNNNTTTTSSSS
X Steve Singles, University of Delaware, for the initial
X implementation of this program.
X
X Henry Spencer, University of Toronto, for the implementation
X of the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n interpreter and the text in
X RRRREEEEGGGGUUUULLLLAAAARRRR EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS.
X
AAAAUUUUTTTTHHHHOOOORRRR
X John Cristy, E.I. DuPont De Nemours & Company Incorporated
X
X
X
X
X
X
X
X9
X
(printed 12/12/90) Ardent Computer Corporation Page 3
X
X
X
X
SHAR_EOF
chmod 0755 ImageMagick/xtp/xtp.1 ||
echo 'restore of ImageMagick/xtp/xtp.1 failed'
Wc_c="`wc -c < 'ImageMagick/xtp/xtp.1'`"
test 8203 -eq "$Wc_c" ||
echo 'ImageMagick/xtp/xtp.1: original size 8203, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ImageMagick/xtp/README ==============
if test -f 'ImageMagick/xtp/README' -a X"$1" != X"-c"; then
echo 'x - skipping ImageMagick/xtp/README (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ImageMagick/xtp/README (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ImageMagick/xtp/README' &&
XXtp is a utility for retrieving, listing, or printing files from a
remote network site. Xtp performs most of the same functions as the
ftp program, but does not require any interactive commands. You simply
specify the file transfer task on the command line and xtp performs the
transfer automatically.
X
To retrieve file contrib/ImageMagick.tar.Z from host expo.lcs.mit.edu,
use:
X
X xtp -binary -retrieve ImageMagick.tar.Z expo.lcs.mit.edu contrib
X
XXtp requires 4.3 BSD compatibilities. I have successfully executed it on
a SUN, DEC Ultrix, MIPS, IBM RS/6000, and Ardent Titan.
X
The author is cristy at dupont.com. Comments, suggestions, etc, are
welcome, but be kind.
X
---
X
Copyright 1990 E. I. Dupont de Nemours & Company
X
Permission to use, copy, modify, distribute, and sell this software and
its documentation for any purpose is hereby granted without fee,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of E. I. Dupont de Nemours
& Company not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission. E. I. Dupont de Nemours & Company makes no representations
about the suitability of this software for any purpose. It is provided
"as is" without express or implied warranty.
X
E. I. Dupont de Nemours & Company disclaims all warranties with regard
to this software, including all implied warranties of merchantability
and fitness, in no event shall E. I. Dupont de Nemours & Company be
liable for any special, indirect or consequential damages or any
damages whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action, arising
out of or in connection with the use or performance of this software.
X
SHAR_EOF
chmod 0755 ImageMagick/xtp/README ||
echo 'restore of ImageMagick/xtp/README failed'
Wc_c="`wc -c < 'ImageMagick/xtp/README'`"
test 1872 -eq "$Wc_c" ||
echo 'ImageMagick/xtp/README: original size 1872, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ImageMagick/xtp/regular.c ==============
if test -f 'ImageMagick/xtp/regular.c' -a X"$1" != X"-c"; then
echo 'x - skipping ImageMagick/xtp/regular.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ImageMagick/xtp/regular.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ImageMagick/xtp/regular.c' &&
/*
% A regular expression is zero or more branches, separated by `|'. It
% matches anything that matches one of the branches.
%
% A branch is zero or more pieces, concatenated. It matches a match for
% the first, followed by a match for the second, etc.
%
% A piece is an atom possibly followed by `*', `+', or `?'. An atom
% followed by `*' matches a sequence of 0 or more matches of the atom. An
% atom followed by `+' matches a sequence of 1 or more matches of the
% atom. An atom followed by `?' matches a match of the atom, or the null
% pattern.
%
% An atom is a regular expression in parentheses (matching a match for
% the regular expression), a range (see below), `.' (matching any single
% character), `^' (matching the null pattern at the beginning of the input
% pattern), `$' (matching the null pattern at the end of the input pattern),
% a `\' fol- lowed by a single character (matching that character), or a
% single character with no other significance (matching that character).
%
% A range is a sequence of characters enclosed in `[]'. It normally
% matches any single character from the sequence. If the sequence begins
% with `^', it matches any single charac- ter not from the rest of the
% sequence. If two characters in the sequence are separated by `-', this
% is shorthand for the full list of ASCII characters between them (e.g.
% `[0-9]' matches any decimal digit). To include a literal `]' in the
% sequence, make it the first character (following a possible `^'). To
% include a literal `-', make it the first or last character.
%
% If a regular expression could match two different parts of the input
% pattern, it will match the one which begins earliest. If both begin in
% the same placebut match dif- ferent lengths, or match the same length
% in different ways, life gets messier, as follows.
%
% In general, the possibilities in a list of branches are con- sidered in
% left-to-right order, the possibilities for `*', `+', and `?' are
% considered longest-first, nested constructs are considered from the
% outermost in, and concatenated con- structs are considered
% leftmost-first. The match that will be chosen is the one that uses the
% earliest possibility in the first choice that has to be made. If there
% is more than one choice, the next will be made in the same manner
% (earli- est possibility) subject to the decision on the first choice.
% And so forth.
%
% For example, `(ab|a)b*c' could match `abc' in one of two ways. The
% first choice is between `ab' and `a'; since `ab' is earlier, and does
% lead to a successful overall match, it is chosen. Since the `b' is
% already spoken for, the `b*' must match its last possibility-the empty
% pattern-since it must respect the earlier choice.
%
% In the particular case where no `|'s are present and there is only one
% `*', `+', or `?', the net effect is that the longest possible match
% will be chosen. So `ab*', presented with `xabbbby', will match `abbbb'.
% Note that if `ab*' is tried against `xabyabbbz', it will match `ab'
% just after `x', due to the begins-earliest rule. (In effect, the deci-
% sion on where to start the match is the first choice to be made, hence
% subsequent choices must respect it even if this leads them to
% less-preferred alternatives.)
%
% CompileRegularExpression returns NULL for a failure, where failures are
% syntax errors, exceeding implementation limits, or applying `+' or `*'
% to a possibly-null operand.
%
% This is essentially the same routine written and copywrited by Henry
% Spencer, University of Toronto. I made minor programming changes but
% major variable name changes to improve readibility.
%
%
*/
#include <stdio.h>
#include <ctype.h>
#include <malloc.h>
#include <string.h>
#include "regular.h"
X
char
X *code,
X **subpattern_end,
X *p,
X start_code,
X *start_pattern,
X **subpattern;
X
extern char
X *strchr();
X
static char
X *token;
X
static int
X number_parenthesis;
X
static long
X code_size;
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A t o m %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static char *Atom(flagp)
int
X *flagp;
{
X int
X flags;
X
X register char
X *status;
X
X static char
X *Node(),
X *Regular();
X
X static void
X EmitCode();
X
X *flagp=WorstCase;
X switch(*token++)
X {
X case '^':
X {
X status=Node(MatchBeginningOfLine);
X break;
X }
X case '$':
X {
X status=Node(MatchEndOfProgramOfLine);
X break;
X }
X case '.':
X {
X status=Node(MatchAnyCharacter);
X *flagp|=NonNull | Simple;
X break;
X }
X case '[':
X {
X register int
X class,
X class_end;
X
X if (*token != '^')
X status=Node(MatchAnyCharacterOf);
X else
X {
X /*
X Complement of range.
X */
X status=Node(MatchAnyCharacterBut);
X token++;
X }
X if ((*token == ']') || (*token == '-'))
X EmitCode(*token++);
X while ((*token != '\0') && (*token != ']'))
X {
X if (*token != '-')
X EmitCode(*token++);
X else
X {
X token++;
X if ((*token == ']') || (*token == '\0'))
X EmitCode('-');
X else
X {
X class=((int)*(unsigned char *)(token-2))+1;
X class_end=((int)*(unsigned char *)(token));
X if (class > class_end+1)
X Fail("invalid [] range");
X for(; class <= class_end; class++)
X EmitCode(class);
X token++;
X }
X }
X }
X EmitCode('\0');
X if (*token != ']')
X Fail("unmatched []");
X token++;
X *flagp|=NonNull | Simple;
X break;
X }
X case '(':
X {
X status=Regular(1,&flags);
X if (status == NULL)
X return(NULL);
X *flagp|=flags & (NonNull | SpecialStart);
X break;
X }
X case '\0':
X case '|':
X case ')':
X {
X Fail("internal urp");
X break;
X }
X case '?':
X case '+':
X case '*':
X {
X Fail("?+* follows nothing");
X break;
X }
X case '\\':
X {
X if (*token == '\0')
X Fail("trailing \\");
X status=Node(MatchExactly);
X EmitCode(*token++);
X EmitCode('\0');
X *flagp|=NonNull | Simple;
X break;
X }
X default:
X {
X register char
X ender;
X
X register int
X length;
X
X token--;
X length=strcspn(token,Meta);
X if (length <= 0)
X Fail("internal disaster");
X ender=(*(token+length));
X if (length > 1 && MultipleMatches(ender))
X length--;
X *flagp|=NonNull;
X if (length == 1)
X *flagp|=Simple;
X status=Node(MatchExactly);
X while (length > 0)
X {
X EmitCode(*token++);
X length--;
X }
X EmitCode('\0');
X break;
X }
X }
X return(status);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% B r a n c h %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Function Branch Implements the | operator.
%
%
*/
static char *Branch(flagp)
int
X *flagp;
{
X int
X flags;
X
X register char
X *chain,
X *latest,
X *status;
X
X static char
X *Node(),
X *Piece();
X
X static void
X Tail();
X
X *flagp=WorstCase;
X status=Node(MatchThisOrNext);
X chain=NULL;
X while ((*token != '\0') && (*token != '|') && (*token != ')'))
X {
X latest=Piece(&flags);
X if (latest == NULL)
X return(NULL);
X *flagp|=flags & NonNull;
X if (chain == NULL)
X *flagp|=flags & SpecialStart;
X else
X Tail(chain,latest);
X chain=latest;
X }
X if (chain == NULL)
X (void) Node(MatchEmptyString);
X return(status);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% E m i t C o d e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static void EmitCode(opcode)
char
X opcode;
{
X if (code != &start_code)
X *code++=opcode;
X else
X code_size++;
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I n s e r t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Function Insert inserts an operator in front of an already-emitted operand.
%
*/
static void Insert(opcode,operand)
char
X opcode,
X *operand;
{
X register char
X *p,
X *place,
X *q;
X
X if (code == &start_code)
X {
X code_size+=3;
X return;
X }
X p=code;
X code+=3;
X q=code;
X while (p > operand)
X *--q=(*--p);
X place=operand;
X *place++=opcode;
X *place++='\0';
X *place++='\0';
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% M a t c h %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static int Match(regular_expression)
char
X *regular_expression;
{
X char
X *next_token;
X
X register char
X *scan;
X
X static char
X *NextToken();
X
X static int
X Repeat();
X
X scan=regular_expression;
X while (scan != NULL)
X {
X next_token=NextToken(scan);
X switch(OpCode(scan))
X {
X case MatchBeginningOfLine:
X {
X if (p != start_pattern)
X return(0);
X break;
X }
X case MatchEndOfProgramOfLine:
X {
X if (*p != '\0')
X return(0);
X break;
X }
X case MatchAnyCharacter:
X {
X if (*p == '\0')
X return(0);
X p++;
X break;
X }
X case MatchExactly:
X {
X register char
X *operand;
X
X register int
X length;
X
X operand=Operand(scan);
X /*
X Inline the first character for speed.
X */
X if (*operand != *p)
X return(0);
X length=strlen(operand);
X if ((length > 1) && (strncmp(operand,p,length) != 0))
X return(0);
X p+=length;
X break;
X }
X case MatchAnyCharacterOf:
X {
X if ((*p == '\0' || strchr(Operand(scan),*p) == NULL))
X return(0);
X p++;
X break;
X }
X case MatchAnyCharacterBut:
X {
X if ((*p == '\0') || (strchr(Operand(scan),*p) != NULL))
X return(0);
X p++;
X break;
X }
X case MatchEmptyString:
X break;
X case Back:
X break;
X case Open+1:
X case Open+2:
X case Open+3:
X case Open+4:
X case Open+5:
X case Open+6:
X case Open+7:
X case Open+8:
X case Open+9:
X {
X register char
X *save;
X
X register int
X no;
X
X no=OpCode(scan)-Open;
X save=p;
X if (!Match(next_token))
X return(0);
X else
X {
X /*
X Don't set subpattern if some later invocation of the same
X parentheses already has.
X */
X if (subpattern[no] == NULL)
X subpattern[no]=save;
X return(1);
X }
X break;
X }
X case Close+1:
X case Close+2:
X case Close+3:
X case Close+4:
X case Close+5:
X case Close+6:
X case Close+7:
X case Close+8:
X case Close+9:
X {
X register char
X *save;
X
X register int
X no;
X
X no=OpCode(scan)-Close;
X save=p;
X if (!Match(next_token))
X return(0);
X else
X {
X /*
X Don't set subpattern_end if some later invocation of the same
X parentheses already has.
X */
X if (subpattern_end[no] == NULL)
X subpattern_end[no]=save;
X return(1);
X }
X break;
X }
X case MatchThisOrNext:
X {
X register char
X *save;
X
X if (OpCode(next_token) != MatchThisOrNext)
X next_token=Operand(scan);
X else
X {
X do
X {
X save=p;
X if (Match(Operand(scan)))
X return(1);
X p=save;
X scan=NextToken(scan);
X } while ((scan != NULL) && (OpCode(scan) == MatchThisOrNext));
X return(0);
X }
X break;
X }
X case MatchZeroOrMore:
X case MatchOneOrMore:
X {
X register char
X next_tokench,
X *save;
X
X register int
X min,
X no;
X
X /*
X Lookahead to avoid useless match attempts when we know what
X character comes next_token.
X */
X next_tokench='\0';
X if (OpCode(next_token) == MatchExactly)
X next_tokench=(*Operand(next_token));
X min=(OpCode(scan) == MatchZeroOrMore) ? 0 : 1;
X save=p;
X no=Repeat(Operand(scan));
X while (no >= min)
X {
X /*
X If it could work, try it.
X */
X if ((next_tokench == '\0') || (*p == next_tokench))
X if (Match(next_token))
X return(1);
X /*
X Couldn't or didn't -- back up.
X */
X no--;
X p=save+no;
X }
X return(0);
X break;
X }
X case EndOfProgram:
X return(1);
X break;
X default:
X (void) fprintf(stderr,"Regular(3): %s","memory corruption");
X return(0);
X break;
X }
X scan=next_token;
X }
X (void) fprintf(stderr,"Regular(3): %s","corrupted pointers");
X return(0);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% N e x t T o k e n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static char *NextToken(p)
register char
X *p;
{
X register int
X offset;
X
X if (p == &start_code)
X return(NULL);
X offset=Next(p);
X if (offset == 0)
X return(NULL);
X if (OpCode(p) == Back)
X return(p-offset);
X else
X return(p+offset);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% N o d e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static char *Node(opcode)
char
X opcode;
{
X register char
X *ptr,
X *status;
X
X status=code;
X if (status == &start_code)
X {
X code_size+=3;
X return(status);
X }
X ptr=status;
X *ptr++=opcode;
X *ptr++='\0';
X *ptr++='\0';
X code=ptr;
X return(status);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% O p T a i l %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
static void OpTail(p,value)
char
X *p;
X
char
X *value;
{
X static void
X Tail();
X
X /*
X "Operandless" and "op != MatchThisOrNext" are synonymous in practice.
X */
X if ((p == NULL) || (p == &start_code) || (OpCode(p) != MatchThisOrNext))
X return;
X Tail(Operand(p),value);
}
X
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
SHAR_EOF
true || echo 'restore of ImageMagick/xtp/regular.c failed'
fi
echo 'End of ImageMagick part 2'
echo 'File ImageMagick/xtp/regular.c is continued in part 3'
echo 3 > _shar_seq_.tmp
exit 0
--
Dan Heller
O'Reilly && Associates Z-Code Software Comp-sources-x:
Senior Writer President comp-sources-x at uunet.uu.net
argv at ora.com argv at zipcode.com
More information about the Comp.sources.x
mailing list