The natural unit of length in HP-GL is 1/40 mm = 0.025 mm, so a typical
A4 page covers roughly 11000 x 7500 natural units. Typically, coordinates in
HP-GL commands will be found in the range 0 ... 12000. hp2xx will tell
you the maximum and minimum coordinates ("picture limits")
it finds in your HP-GL picture for both x and y direction.
These values usually roughly cover this range.
Even if your HP-GL source plots in user-specific coordinates (realized
via HP-GL command `SC;' (SCale) ), this remains true, since
hp2xx internally transforms all points back to natural coordinates.
Whenever the above range is grossly violated, you may suspect corrupted
data, because no real plotter would be able to plot such a file.
If you ever discover a picture limit equalling plus or minus 10^10,
your HP-GL probably didn't draw anything. Initially, hp2xx's internal
picture limits are set to impossibly large (or small) values, i. e., +- 10^10,
but the first plot command will set them to values found therein, and successive
plots push the limits outward. Example: xmax starts at -10^10,
the first plot command may change it to 2536, the next to 3470, the next
20 command fall short, etc. Eventually, xmax assumes the largest
value and stays there. Knowledge about these details may sometimes
be crucial (see section Scaling to true size).
hp2xx uses the picture limits internally for scaling and fitting the
data into the supplied limiting rectangle (see section Sizing your output).
You can also affect the picture limits yourself for special effects
(see section Fixed scaling).
As noted earlier, hp2xx does not draw to scale, but rather it fits
a picture into a given limiting window. While this is very handy in most
applications, it may be undesirable when a series of pictures must be drawn
to the same scale. Unless all pictures possess the same picture limits
(modulo offsets), e.g., because all of them are surrounded by some fixed
frame, hp2xx would scale them all up differently to fit each of them
tightly into the limiting window.
There are two simple cures: First, make use of the true size option `-t'.
If the original HP-GL sizes do not fit, adjust picture limits to
guarantee a constant scaling: Make a preview of all pictures and note
the coordinate ranges hp2xx reports. Then, determine picture limits
which cover all of these individual limits. Finally, run hp2xx
to create your desired outputs using options `-xXyY' to tell
hp2xx about the picture limits it should use. If the pictures
do not share common offsets, you may have to correct for offsets
manually. Use the preview mode for testing. You'll get the same scale
as long as the limiting window and (xmax - xmin) and
(ymax - ymin) remain constant for all pictures.
WARNING: hp2xx does not clip lines. If the picture limits which
you manually can pre-set via options `-xXyY' are chosen too narrow,
they will be pushed outside just as described in the last section,
resulting in a different scale. Check the coordinate ranges hp2xx
reports. The should match the values supplied by options `-xXyY'!
Earlier releases of hp2xx (binaries) did not offer option
`-t', which does everything you'll need for producing output with
exactly the sizes shown on a real plotter. The following paragraph
shows how to manually emulate the working of this option. Though outdated,
I left it in the manual as background material:
Sometimes you might want to create pictures sized exactly as if they
were drawn on a real plotter. There is a little trick which allows
you to do so using hp2xx: As notes above, the natural unit of
length in HP-GL is 0.025 mm. Therefore, you can calculate the true
picture size from the picture limits reported by hp2xx. Transform
these data into mm and simply specify the limiting window accordingly!
Example:
`hp2xx truesize.hp' reports the following coordinate ranges:
xmin = 250, xmax = 5250, ymin = 100, ymax = 3100.
Thus, the picture is (xmax - xmin) * 0.025 mm = 125 mm wide
and ymax - ymin) * 0.025 mm = 75 mm high, and
`hp2xx -w125 -h75 truesize.hp' will draw it in true size.
hp2xx allocates memory for an internal bitmap dynamically.
Large pictures, high resolution, and use of colors may combine to
let your computer run out of memory (especially on non-swapping operating
systems like DOS).
In this case, hp2xx swaps the bitmap to disk, slowing down
considerably. Redirecting swapping to a fast disk, preferably a RAM disk,
might speed up things. You can replace the default swap file
`hp2xx.swp' using `-s `swapfile''.
NOTE: If for some reason hp2xx is aborted during swapping, you might
have to delete the swap file manually.
Here are some basics about the generation of dots and lines within
hp2xx. I mention them, because there is something left to be
improved here...
Some HP-GL codes cause hp2xx to generate points rather than lines
of length zero. There is a subtle difference between both. Depending
on the current output format, special code for points will be generated,
and occasionally, a point will look different from a zero-length line.
Use `-m epic' for such an example.
Line thicknesses can vary. Especially for thick lines, the matter of
line caps (how lines are ended, e.g. with a round cap) becomes relevant.
hp2xx does not do an elaborate job here. If line caps matter to you,
use `-m eps', edit the resulting Encapsulated PostScript file, look
for a line with setlinecap in it (near line 45), and select the
line cap of your choice by modifying the PostScript command setlinecap
accordingly. You can also use Metafont (via `-m mf') and replace
the picked pen "pencircle" by some other type. However, both methods
are far from convenient.
The internal rasterization done by hp2xx is a simple process
and may someday be replaced by something more efficient: A "draw point"
command essentially sets a single pel in the internal buffer.
If line with grows (2 - 4 units), a square of 2 to 4 pels length will
be set. Vector drawing is broken down to point drawing by the
Bresenham algorithm. Therefore, there is no notion of controlled
line caps. The shapes of line ends simply result from plotting these squares.
In addition, plotting all those pels is not really efficiently implemented,
so if anybody out there looks for a good place for speeding up hp2xx,
this code (located in file `picbuf.c') is a good place to start.
Currently there are no plans by me to introduce different line caps
into hp2xx, so waiting for them will be of no use.
This is just a brief note, not a real manual entry -- sorry.
PIC
PAC
DJ_GR
OS2
PM
TeX was designed for typesetting, not for handling graphics. Putting
graphics directly into TeX therefore is always somewhat clumsy.
hp2xx offers four different compromises to do that, and much
better, though more indirect ways.
`-m mf' generates Metafont source code. Run Metafont
and gftopk, and you'll end up with a special pk font
containing the single letter Z which represents your picture. Placing
this Z somewhere in your document using standard TeX commands
draws your picture there.
If you want to avoid fiddling with additional programs and fonts, if you
work with LaTeX, and if you do not need high-quality plots,
the macros within epic.sty may help you.
`-m tex' causes hp2xx to generate
appropriate TeX source code which you can `\input{}' into
LaTeX sources.
For emTeX users, there are yet another two way: `-m em'
creates TeX code containing many commands like `\special{em:...}'
for line drawing. The line drawing task will therefore be handled not by
TeX itself but by the emTeX drivers which can handle arbitrary
line slopes etc. Similarly, `-m cad' produces code based on
the same principle, but compatible with program `TeXcad.exe', which is
distributed as a part of emTeX, and which offers editing and drawing
features for the desired HP-GL figure(s).
Please note that all methods for generation of graphics within
TeX are compromises which usually work only for simple graphics.
You'll probably prefer using external methods like including EPS vector
graphics files with Tom Rokicki's dvips driver, or PCX files via the
emTeX drivers, or you'll generate special fonts with convenient
programs like F. Sowa's bm2font. hp2xx can help you in all
of these cases. The following table shows the pros and cons of the
various approaches (all are based on PD software):
Internal methods (all allowing DVI previewing of graphs): via Metafont+:Machine-independent; fully compatible with TeX-:Slow; capacity problems with Metafont / gftopk / some DVI drivers if used with large and/or complex graphics viaepic.sty+:Machine-independent; single-step, native LaTeX approach; PD software-:Slow; requires LaTeX; low-quality lines; just one line thickness; complex graphs may exceed TeX capacity via emTeX's\special{em:...}+:No TeX capacity problem; good line quality; single-step procedure; rasterization on demand, giving optimal resolution-:Slows down drivers; driver capacity may be exceeded; emTeX required External methods: via PCX file inclusion:+:Easy and fast; DVI preview of graphics-:Requires emTeX drivers (only available on DOS and OS/2) via special fonts:+:Easy, fast, and trouble-free font generation viabm2font; DVI preview of graphics (!); portable-:Many files for fonts etc.; confusing for novices via EPS:+:High-quality results; easy; no burden for TeX or drivers-:No DVI preview; PostScript printer (or, e.g., GhostScript) required; PostScript previewing is slower than DVI previewing.