Parametric font and image definition and generation
by AMALIE J. FRANK
Bell Telephone Laboratories
Murray Hill, New Jersey
require excessive storage and fairly extensive manual
labor to define the images. Described herein is a new
method for defining and generating images in parametric form. This method decreases storage requirements and simplifies the manual operations considerably.
INTRODUCTION
The demand for high graphic arts quality publications
particularly in the areas of education and technology
increases steadily. The associated use of computer controlled photocomposition systems can be likewise expected to accelerate. Considering the high cost of currently available systems, we were motivated to investigate alternative approaches, both from a hardware and
a software point of view. We conducted experiments
with a high resolution electron beam recorder controlled
by a small computer containing 8K words of 16 bits
each, and running at about 500K cycles per second.
The recorder can address a raster grid 16,384 square,
and can draw both horizontal and vertical vectors, but
the vectors must be no greater than four rasters apart
to obtain proper shading. This paper concerns itself
primarily with the software implementation, as constrained by the given hardware configuration.
Focusing on the software implementation, the means
of defining and generating repeated images and fonts
is a prime factor in determining the economics of a
computer photocomposition system. For high quality
publications, a variety of symbols and fonts with
multiple sizes in each font is a necessary feature. There
is, of course, a philosophic question concerning the design of new fonts oriented specifically for computer
generation as opposed to the use of traditional styles,
originally designed for manual stylus, woodblock, or
hot metal techniques. Reserving aesthetic judgment
for the time being, we concentrated on developing an
efficient process for defining and generating any font or
set of images, following the given lines as exactly as
possible. In designing a system for this purpose, three
factors must be considered: the manual operations required to arrive at the image definitions, the computer·
storage required to hold the definitions, and the processing time required to draw the images. For the given
hardware, the computer storage condition assumes
first priority. Previous software systems are found to
PREVIOUS METHODS
In most existing systems, the font definition consists
of either a list of coordinates of the endpoints of the
strokes comprising the images, including any internal
shading strokes, or a list of the coordinates of points
defining the contours of the characters. Such lists occupy a considerable amount of storage. This is further
aggravated as technological advances drive the minimum line width down, thus requiring many more
strokes to shade the same areas. This, of course, can be
offset to some extent by including hardware to defocus
the beam for larger size characters, and thus increase
the beam width, but at the expense of a sharp, clear
image. Another important disadvantage of existing systems is that different sizes of the same font require
separate and distinct lists, themselves varying in size.
For each size in a desired font, the manual operations to
define the font must be repeated, and the resulting
definitions stored individually.
For an example, consider a simple sans-serif font in
8 point size, and assume an average of 75 strokes per
character. If the strokes all are vertical and are specified
in series, then the simplest storage scheme requires for
each stroke 8 bits for the starting position of the stroke
relative to a local origin, and 8 bits for the length of
the stroke. On this basis, a font of 128 characters requires 9,600 words of storage. This increases proportionately for larger-sized characters, and also for more
complex fonts.
Some improvement to the simple encoding scheme
indicated above may be made by incorporating variable
length fields, or by encoding differences between suc135
From the collection of the Computer History Museum (www.computerhistory.org)
136
Fall Joint Computer Conference, 1971
Figure 1-Patch configurations
cessive values. Other techniques arISIng principally
from research in pattern recognition may also be considered. In one of these schemes, the boundaries of the
image are "chain" encoded. Here, the position of a
point is given relative to the previous point in the list,
usually as a value from 0 to 7 which indicates one of
the 8 raster positions immediately surrounding the
previous point. Another approach introduces the concept of the "skeleton" of an image. This scheme is use-
ful in applications such as chromosome analysis where
reduction of the image to a skeletal graph is an objective. However, for photocomposition, it offers no particular advantage over the other encoding schemes
mentioned.
In fact none of these schemes reduces the storage
requirements to a feasible level for the experimental
equipment indicated previously. A new scheme which
proves to be highly effective is described below.
From the collection of the Computer History Museum (www.computerhistory.org)
Parametric Font and Image Definition and Generation
RECTANGLE
TRAPEZOID
i
l
I
NO. OF
LENGTII
STROUS
---.t
14--
~
NO. OF
14--
BOTTOM
LENGTII
STROUS
CURVE
f
#1
i
---.t
#1
)
#2
14--
j
#2
Figure 2-Types of patches
NEW IMAGE DEFINITION
This scheme uses the concept of breaking up an
image into patches. The contours of each patch are
then described by a set of parameters. The parameters
are chosen such that a simple manipulation yields varying sizes of an image.
There are various ways in which an image can be
divided up into patches, and correspondingly various
ways of defining the patch parameters. One such construction was proposed by Mathews and Miller in
1965. 1 Their construction, which was designed for hardware implementation, assumed that curved portions of
an image would be broken up into patches, each one of
which had two curved sides and two other sides which
are straight parallel lines. Each patch requires eight
137
parameters: the initial width, the height, the coordinates of one corner, and the curvature and slope of
each curved side. Rectangles and trapezoids are treated
as special cases.
The design described herein also uses the three
types of patches: rectangles, trapezoids, and patches
with curved boundaries. The curved patch definition is
somewhat freer than that used in the Mathews and
Miller construction, in the sense that it is not constrained to have two sides which are straight parallel
lines. Figure 1 shows some sample patch configurations.
These are described in detail further below. Of greater
significance is the difference in methods used to arrive
at the parameters for a particular image or set of
images. :l\1athews and Miller used trial and error,
which results in considerable effort to divide an image
into patches and to determine the necessary parameters. It is particularly difficult to choose the slopes and
curvatures in such a way that successive patches match
well at their points of juncture, i.e., to insure against
the appearance of cusps at these points. Clearly, a
faster, more analytical method is necessary for producing image definitions in any quantity. This paper describes both a curved patch construction and an associated algorithm for arriving at the necessary parameters
directly. The three types of patches are illustrated in
Figure 2. Rectangles and trapezoids are handled in a
straightforward manner. For a rectangle, the stored
parameters are the width or the height, whichever is
larger, and the number of strokes to be drawn. Vertical
strokes are drawn if the height is greater than the
width, and horizontal strokes otherwise. For a trapezoid, four parameters are stored: the bottom length,
the number of strokes to be drawn, the change in
abscissa of the left hand end of each successive stroke,
and the change in line length for each successive stroke.
These last two parameters are related, of course, to the
angles A and B made by the sides of the trapezoid as
shown in Figure 2.
A curved patch is a somewhat more complicated
matter. We consider a curved patch to consist of two
curved members. Vertical strokes are drawn where the
curved members are considered as functions of X, and
horizontal strokes are drawn where the curved members
are considered as functions of Y. The two curved members mayor may not meet each other at their end
points. Where they do not meet, straight lines are assumed to connect the ends. Each curved member is
described by at least one mathematical function. In
some cases, a curved member is broken up into a number of segments, and each segment is described by a
separate function. First, we must decide what kind of
function is to be used. Second, for a given image or set
of images such as the characters of a particular font,
From the collection of the Computer History Museum (www.computerhistory.org)
138
Fall Joint Computer Conference, 1971
14
14
16
12
18
10
Figure 3-Steps in defining an image
we find a suitable method for determining the parameters of the function for each segment.
Two factors govern the type of function to be used:
storage and execution time. A more complicated function spans a larger segment and carries through more
inflections of the curve, thus requiring a smaller number of segments, and consequently less storage than a
simple function. However, it takes longer to compute.
Since our experiment concentrated on font production
on a rather small computer, we opted to minimize execution time. For this reason, we ruled out superellipses,
as suggested by Mergler and Vargo in their experiments
in font design. 2
We decided initially to experiment with parabolas
of the type: y=ax 2+bx+c or, x= ay2+by+c. The
principal axes of these parabolas are parallel to the Y
and X axes respectively. Roughly speaking, we use the
form y=f(x) for parts of a curve that are U or n
shaped, and the form x=f(y) for parts that are ( or )
shaped. To determine optimally which form to use
where, we follow the steps illustrated in Figure 3. The
upper left corner of this figure shows a donut shaped
image we wish to define. We actually start the process
with the donut shown in the upper right corner. Here
we mark all the points where 45 0 and 1350 lines are
exactly tangent to the donut. There are eight of them.
From the collection of the Computer History Museum (www.computerhistory.org)
Parametric Font and Image Definition and Generation
139
Figure 4-Equalizing the angle error
We then connect corresponding points on the inside
and outside curves with dotted lines. For example,
point 1 is connected to point 11, point 3 is connected
to point 13, etc. This carves up the donut into four
patches. For the top and bottom patches we will fit
parabolas of the form y=f(x), and fill the patches with
vertical strokes. For the left and right patches we will
fit parabolas of the form x=f(y) and fill the patches
with horizontal strokes.
N ext we go to the lower left corner of the figure.
Here we add 9 more points where 0° and 90° lines are
exactly tangent to the donut. Finally, we find the
parabolas which fit between successive points. We fit
one parabola between points 1 and 2, another parabola
between points 2 and 3, etc. The donut in the lower
right corner of the figure shows two of the parabolas
that have been found. Between points 14 and 15 we
fit a parabola of the form y=f(x), and between points
6 and 7 a parabola of the form x=f(y).
GETTING A GOOD FIT
In our experiment we discovered that the process of
finding the actual parameters for the parabolas to be
fit to each particular patch is not a trivial matter. We
took the capital letters of the U nivers font, and actually programmed a number of algorithms before we
arrived at one which yields consistently good results
with a minimum of manual labor . First we tried entering the coordinates of various points along the given
curve. Taking the first four points, we forced the parabola to pass through the two middle points, and be a
least squares fit to the two surrounding points. The resulting parabola was then used for the segment between the two middle points. We then deleted the first
point, added the fifth point in sequence, and repeated
the fitting process. This continued until we ran out of
points. The resulting segments were fair fits, but they
did not include either end segment. These could be
generated by increasing the initial list by two points
lying someplace on an extrapolation of the given curve
member. Pinpointing that someplace proved often to
be like finding a needle in a haystack.
In successive trials, we loosened up the input format
by specifying for each segment separately two "fixed"
points through which the parabola had to pass, and two
"floating" points for the least square fit. This enabled
us to place the two floating points inside or outside
the two fixed points. With sufficient fishing this ap-
From the collection of the Computer History Museum (www.computerhistory.org)
140
Fall Joint Computer Conference, 1971
proach resulted in much better fits, but we were often
bothered by noticeable cusps at the junction of segments. This led us to concentrate on the tangent lines
of a fitted parabola at the end points. From this evolved
our final algorithm, which "equalizes the angle error,"
i.e., makes the angle between the tangent line of the
fitted parabola at one end point and the tangent line
of the given curve at that point equal to the correspondingly defined angle at the other end point. This is
illustrated in Figure 4 and is stated more formally as
follows. Given points A and B, and their derivatives
A' and B', to fit a parabola:
1. Compute the parabola P A which passes through
A and B and has the derivative A' at A. Compute the derivative B A ' of P A at B.
2. Compute the parabola P B which passes through
A and B and has the derivative B' at B. Compute the derivative AB' of P B at A.
3. The tangent lines corresponding to the two derivatives A' and AB' at A form some angle a.
Similarly, the tangent lines corresponding to the
two derivatives B' and B A ' at B form some angle
{j. There exists a family of parabolas which pass
through A and B, and which have derivatives
AF' and BF', whose respective tangent lines lie
somewhere within the angles a and {j respectively. Within this family, choose that parabola
whose tangent lines at A and B "equalize the
angle error," i.e., where the angle (8) made by
the tangent lines corresponding to the derivatives A' and AF' is equal to the angle (8) made
by the tangent lines corresponding to the derivatives B' and B/.
This algorithm proved highly successful. We did note,
however, that points on the curve where the tangent
line is exactly horizontal or exactly vertical were particularly sensitive. Accordingly, all such points are
made end points of curve segments. In this case alone,
we do not equalize the angle error, but force the derivative of the curve at such a point to be exactly zero.
In most cases this procedure gives the visual effect of
continuous curvature at the juncture of adjacent segments, even though the angle made by the tangents of
the two segments at the juncture differs by as much as
10 degrees. Beyond this threshold however, the contour appears disjoint. Where this occurs, the addition
of one more segment normally removes this condition.
The parameters stored for a curved patch consist
essentially of the coordinates of the starting and ending
points of the two curved members relative to a local
origin of the entire letter or image, and a set of three
parameters required for each curve segment in the
patch. Various encoding economies are made, as, for
example, where a patch is preceded by a contiguous
patch, the end points of the previous patch are used as
the starting points of the current patch. We have also
incorporated a mirroring procedure so that patches
which are mirror images of each other share a common
set of parameters.
The curve fitting algorithm to equalize the angle
error computes the coefficients a and b of the parabola
as functions of the coordinates of the end points of the
segment and of the tangent of the given curve at those
points. The actual generation of an image, however, is
not done by evaluating the function y=ax2+bx+c or
X= ay2+by+c successively. Since the distance between
strokes is constant, the computation of the functional
values lends itself readily to implementation with difference equations. Classically, this approach consists
of starting with an initial value of the independent
variable (xo for vertical and Yo for horizontal curved
patches) and an initial functional value (Yo for vertical
and Xo for horizontal curved patches). We then construct each successive functional value from the previous functional value by applying the difference equation coefficients do and k, as shown below for a vertical
curved patch:
Yl=yo+do
d1=do+k
Y2=Yl+d1
d2 =d1+k
YN=YN-l+dN- 1
The difference equation constants are easily derived
from the coefficients a and b, the initial functional
value Yo, and the inter-stroke distance h:
do=ah2 +2ahYo+bh
k=2ah2
Use of difference equations results in less execution
time since additions replace multiplications, and it results in less storage required since only two difference
equation constants are required rather than the three
coefficients a, b, and c. An auxiliary advantage is that
the range of the difference equation constants is considerably smaller than that of the coefficients. The
difference equation constants each fit within one word
as fixed points numbers whereas the coefficients would
probably require a floating point representation or
double precision storage.
In summary, the parameters required for each curved
segment are the coordinates of the starting point, the
two difference equation constants, and the number of
strokes spanning the segment. Figure 5 and Tables I
and II contain a complete example of a parametric
From the collection of the Computer History Museum (www.computerhistory.org)
Parametric Font and Image Definition and Generation
TABLE I-Input Data for Image in Figure 5
POINT
X
Y
744
890
981
1000
868
669
500
0
56
135
524
524
524
744
850
885
894
814
654
500
106
135
418
418
799
744
594
440
126
21
0
440
799
799
799
664
453
652
598
524
440
245
152
139
440
664
664
453
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
4
141
3
ANGLE OF
TANGENT
90
135
165
0
45
75
90
0
1
12
13
20
7
11
R
24
23
R
90
135
165
0
45
75
90
0
10
9
+-ORIGIN
definition. In Figure 5 the types of patches are coded
as follows: R = rectangle, T = trapezoid, V = vertical
curve patch, H = horizontal curve patch, M = mirror
image of other patches. Figure 6 shows an exploded
view of the image generated from this definition. This
same definition may be used to generate the image in
any other size, larger or smaller. Excessive size changes
result in some degradation to the image. See Figure 7
8
Figure 5-Example of parametric definition
for a few examples of sizing. In these cases, the sizing
was done in a strictly proportional manner. The patches
may also be individually sized by varying algorithms
to obtain thinning or thickening of different parts of
an image.
The various images in Figures 1, 2, 3, 5, 6, and 7 are
TABLE II-Computed Parameters for Image in Figure 5
End points
of segment
a
1-2
2-3
3-4
4-5
5-6
6-7
8-9
14-15
15-16
16-17
17-18
18-19
19-20
21-22
Difference Equation
Constants
Parabolic Coefficients
-
-
.00256
.00240
.00078
.00136
.00169
.00074
.00043
.00446
.00414
.00156
.00208
.00218
.00049
.00064
b
c
3.80424
2.62036
0.68705
1.19329
-2.06229
-0.74405
-0.38025
6.63375
4.21743
1.37188
1.83257
-2.63984
-0.49310
-0.56122
-615.17606
273.29839
848.84937
737.47536
644.06991
186.01190
83.65432
-1815.75331
-188.60866
594.18601
492.83464
943.88245
263.27415
227.46939
k
-
-
.08181
.07694
.02498
.04339
.05411
.02381
.01383
.14266
.13243
.04989
.06664
.06989
.01578
.02041
From the collection of the Computer History Museum (www.computerhistory.org)
do
-0.04091
3.79026
0.96187
-0.02170
-3.46570
-0.98810
0.00691
-0.07133
2.92872
1.02268
-0.03332
-3.66281
-0.60750
0.01020
142
Fall Joint Computer Conference, 1971
Figure 6-Exploded view of an image defined and generated by the patch method
actual computer output and were all made using this
new method. The output device used for this purpose
was a Stromberg-Carlson 4060 microfilm recorder.
SUMMARY AND EVALUATION
We may now evaluate the method described with respect to the manual operations, computer storage, and
processing time.
The curve fitting implementation for this study was
initially done on a non-interactive basis. In this case,
the manual operations consist of measuring and keypunching the coordinates of the significant points, i.e.,
all terminal points, inflection points, and points of
tangency with 0, 45, 90, and 135 degree lines, and any
additional points required for smoothing, along with
the angle of the tangent line at these points. Almost all
of these points are chosen to be points of tangency
with 0, 45, 90, and 135 degree lines, so that it is not
actually required to measure the angle in these cases.
Even these manual operations are a decided itnprove-
From the collection of the Computer History Museum (www.computerhistory.org)
Parametric Font and Image Definition and Generation
~1111111""II""llllm~
=
==
~IIIIIIIIIIIIIIII
143
~lllllllllInlllllllUl!!..
=.
~I I I I I I I I I I I I
Figure 7-Exploded views of various sized images derived from image shown in Figure 5
From the collection of the Computer History Museum (www.computerhistory.org)
144
Fall Joint Computer Conference, 1971
ment over previous methods, where many more points
must be specified, and redone for each separate size.
This method has also been implemented in an interactive program designed by Miss Joan E. Miller of Bell
Telephone Laboratories. This interactive procedure
saves substantial time by replacing the measuring and
keyboarding of the various coordinates and tangents
by the faster physical and visual processes of drawing
and manipulating various knobs, pushbuttons and
switches and also by providing a means of immediate
feedback and correction for the curve fitting processes.
In this procedure, we draw the boundaries of the image
by hand on a RAND tablet. This results in a stack of
coordinates in storage, which are then subjected to a
smoothing algorithm, and displayed on a scope. The
next step is to find the significant points of tangency.
This is done by means of a novel feature of this program, which is a tracking dot under knob control. This
dot is not permitted to course the entire scope, but is
constrained to follow the path of the input curve. As it
does so, the tangent of the curve is continuously computed and displayed numerically on the scope. The user
may thus position the tracking dot to any desired point
and register it by pushing a button. After all these
significant points are captured the curve fitting algorithms described previously are applied and the fitted
parabolas immediately displayed. Additional segments
are added as needed. Finally, the parameters describing
the entire image are organized and outputted for use
in the photocomposition phase.
The image definitions for this experiment were stored
and executed as procedures in an interpretive language.
While this adds some overhead to both the storage and
processing, it affords a great degree of flexibility. For
this implementation, the storage required for the 26
capital letters is approximately 700 words. Extending
this to 128 characters, adjusted for smaller characters,
we arrive at a conservative estimate of 3,200 words,
representing a % reduction over the 9,600 indicated
previously. Moreover, we note that font definitions in
parametric form are easily sized. This can be done in
the definition process by transforming the coordinates
of the defining points prior to computing the parameters, or it can be done dynamically at drawing time
by maintaining a "master" set of definitions in one
size and deriving other sizes as required from the
master set. All sized versions of the same image require
the same amount of storage, a valuable feature for
efficient storage management.
Volume timing tests are currently being constructed.
Initial results indicate a through-put rate in the
neighborhood of 100 characters per second. This is satisfactory for many applications where graphic arts
quality output is required using a general purpose computer system, and where economy of operation is a
prime consideration. The speed may be increased, of
course, by microprogramming or hard-wiring or by
using computation equipment with a higher cycling
rate.
We conclude that the method described of defining
images in parametric form has a number of distinct advantages, and while it is particularly desirable in a
minimum equipment configuration, it is generally applicable to a variety of hardware configurations.
REFERENCES
1 M V MATHEWS J E MILLER
Computer editing, typesetting and image generation
Proceedings Fall Joint Computer Conference 1965
pp 389-398
2 H W MERGLER P M VARGO
One approach to computer assisted letter design
The Journal of Typographic Research Volume II
Number 4 October 1968 pp 299-322
3 J S WHOLEY
The coding of pictorial data
IRE Transactions on Information Theory Volume IT-7
Number 2 April 1961 pp 99-104
4 H FREEMAN
On the encoding of arbitrary geometric configurations
IRE Transactions on Electronic Computers EC-lO
Volume 2 June 1961 pp 260-268
5 C T ZAHN
A formal description for two-dimensional patterns
Proceedings of the International Joint Conference on
Artificial Intelligence May 7-9 1969 Washington DC
Gordon and Breach NY 1969
6 U MONTANARI
A note on minimal length polygonal approximation to a
digitized contour
Communications of the ACM Volume 13 Number 1
January 1970 pp 41-47
7 J L PFALTZ A ROSENFELD
Computer representation of planar regions by their skeletons
Communications of the ACM Volume 10 Number 2
February 1967 pp 119-125
8 U MONTANARI
Continuous skeletons from digitized images
Journal of the ACM Volume 16 Number 4 October 1969
pp 534-549
From the collection of the Computer History Museum (www.computerhistory.org)