![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to user.ms CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / vol2 / ideal|
Return to user.ms CVS log | Up to [Research Unix] / researchv10dc / vol2 / ideal |
1.1 root 1: .so ../ADM/mac
2: .XX ideal 79 "Ideal \(em A Picture-specification Language"
3: ...\" Thu May 1 10:28:25 EDT 1986
4: ...\"refer first
5: ...TR 103
6: ...RP 80-11272-13 11173 39199-11
7: ...ND December 17, 1981
8: .hy 14 \" set hyphenation: 2=not last lines; 4= no -xx; 8=no xx-
9: .ds id \f2ideal\fP
10: .ds [. [
11: .ds .] ]
12: .nr DV 0 \" for .P1/.P2
13: .de Ks
14: .SP
15: .KS
16: ..
17: .de Ke
18: .KE
19: .SP
20: ..
21: .de IS \" do not touch these!
22: .br
23: .nf
24: ..
25: .de IE
26: ..
27: .de Ts
28: .nr PS -1
29: .nr VS -1
30: .QS
31: ..
32: .de Te
33: .nr PS +1
34: .nr VS +1
35: .QE
36: ..
37: .EQ
38: delim $$
39: .EN
40: ......graphics
41: .TL
42: Ideal \(em A Picture-specification Language
43: .br
44: User and Reference Manual\(dg
45: .AU "MH 2C-518" 5292
46: Christopher J. Van Wyk
47: .AI
48: .MH
49: .AB
50: This manual describes how to use the existing implementation of \*(id,
51: a programming language to be used for describing
52: pictures.
53: The main use of \*(id is as a preprocessor to
54: .I troff ,
55: so that pictures and text may reside in the same
56: file and be typeset together.
57: .I Ideal
58: can also produce device-independent descriptions
59: of pictures which, for example, can be displayed through
60: the
61: .UX
62: system plot filters.
63: .AE
64: .FS
65: \(dg This is a revised version of |reference(van wyk ideal cstr).
66: .FE
67: .NH 1
68: Introduction
69: .PP
70: .I Ideal
71: is a language for describing pictures.
72: It is intended primarily to operate as a
73: preprocessor to
74: .I troff |reference(troff latest reference),
75: much like
76: .I eqn |reference(latest eqn),
77: .I tbl |reference(latest tbl)
78: and
79: .I pic |reference(latest pic).
80: .PP
81: I have explained the principles that motivate
82: the form of \*(id elsewhere|reference(ideal thesis)|reference(ideal acm).
83: This document describes how to use
84: the existing implementation of \*(id
85: and treats several examples in depth.
86: .Ts
87: Paragraphs like this that appear in smaller
88: type may be skipped on first reading:
89: they present sidelights that
90: may be ignored safely by beginners.
91: .Te
92: .NH 1
93: Overview of \*(id
94: .PP
95: To take advantage of \*(id's capabilities,
96: you must believe that
97: .ce 1
98: .I "complex numbers are good" .
99: .IP \(bu
100: Complex numbers have a natural correspondence
101: to points in the Cartesian ($x-y$) coordinate
102: system.
103: .IP \(bu
104: Using complex numbers obviates the need for
105: distinguishing between ``points'' and ``dimensions.''
106: .IP \(bu
107: Complex numbers capture readily such common
108: operations as translation, rotation, and
109: reflection in the plane.
110: .LP
111: .I Ideal
112: programs define pictures by means of
113: a system of simultaneous equations in the
114: significant points of the picture and
115: a set of drawing instructions to be
116: carried out with respect to those points.
117: .I Ideal
118: solves the system of equations,
119: then draws the picture using the points
120: so determined.
121: .PP
122: All variables in \*(id programs are complex
123: numbers, with the usual operations:
124: .IP \(bu
125: component-wise addition and subtraction:
126: $(a,b) ~ +- ~ (c,d) ~ = ~ (a +- c , b +- d)$
127: .IP \(bu
128: vector multiplication:
129: $(a,b)*(c,d) ~ = ~ (ac - bd , ad + bc)$
130: .IP \(bu
131: vector division:
132: $(a,b)/(c,d) ~ = ~ (ac + bd , -ad + bc)/( c sup 2 + d sup 2 )$
133: .IP \(bu
134: component manipulation:
135: $roman "re" ((a,b)) ~ = ~ a$,
136: $roman "im" ((a,b)) ~ = ~ b$,
137: and
138: $roman "conj" ((a,b)) ~ = ~ (a,-b)$
139: .IP \(bu
140: vector magnitude calculation:
141: $roman "abs" ((a,b)) ~ = ~ sqrt { { a sup 2 } + { b sup 2 } }$
142: .IP \(bu
143: unit vector function:
144: $roman "cis" ( theta ) ~ = ~ cos theta + i sin theta$
145: .LP
146: A non-standard notation that has proved useful is
147: $alpha [ x , y ]$, for complex $x$ and $y$,
148: defined by $x + alpha ( y - x )$, and
149: meaning ``$alpha$ of the way from $x$ to $y$.''
150: .PP
151: Scalars are treated as vectors with null imaginary component.
152: For example,
153: .CW 1
154: is treated as
155: .CW (1,0) .
156: .PP
157: The scale of the coordinate system in which \*(id
158: programs are written is entirely a matter
159: of convenience.
160: The \*(id processor proper
161: produces output in the same coordinate
162: system as the input.
163: Postprocessors (``filters'') scale this coordinate
164: system to make sense for the device on which the
165: picture is displayed.
166: .PP
167: Some of the pictures below include captions keyed
168: to the associated programs.
169: Some of the labels are not produced by the program:
170: I added them to help explain the picture.
171: Such labels are parenthesized.
172: For pictures and programs that have not been
173: labeled, you may find that labeling them yourself
174: helps you understand the program.
175: .NH 1
176: Elements of the \*(id Language
177: .PP
178: This section presents statements that make up the
179: fundamental units of \*(id programs, so the
180: displayed program text represents fragments of
181: complete programs.
182: Text that appears between
183: .CW /*
184: and
185: .CW */
186: is a comment.
187: .NH 2
188: Boxes
189: .PP
190: The building blocks of \*(id programs are called
191: .I boxes ,
192: which readers familiar with programming may think
193: of as procedures or subroutines.
194: In fact,
195: the picture drawn by an \*(id program must itself
196: be a box,
197: called
198: .I main ;
199: we suppress this extra level
200: of box-nesting for all of Section 3.
201: .NH 3
202: Defining Boxes
203: .PP
204: Here is a simple box
205: and one instance of it:
206: .Ks
207: .IS
208: ...libfile rect
209: ...width 0.5
210: ...colwid 8.0
211: main {
212: put A:rect {
213: ht = 0.5;
214: wd = 1;
215: sw = 0;
216: };
217: right '(sw) ' at A.sw;
218: right '(nw) ' at A.nw;
219: left ' (se)' at A.se;
220: left ' (ne)' at A.ne;
221: }
222: .IF
223: .P1
224: rect {
225: var ne, nw, se, sw,
226: wd, ht;
227: nw = sw + (0,1)*ht;
228: ne = nw + wd;
229: se = sw + wd;
230: conn ne to nw to sw to se to ne;
231: }
232: .P2
233: .Ke
234: .LP
235: It is called
236: .I rect ,
237: has six local complex variables:
238: .I ne ,
239: .I nw ,
240: .I se ,
241: .I sw ,
242: .I wd ,
243: and
244: .I ht ,
245: three equations among these variables,
246: and an instruction to draw four lines.
247: .NH 3
248: Placing Boxes
249: .PP
250: To ask for an instance of
251: .I rect ,
252: we use a
253: .I \fIput\fP statement with a
254: .I "parameter section"
255: containing enough additional
256: equations that the local variables of
257: this instance of
258: .I rect
259: are determined uniquely.
260: For example, we might give the dimensions
261: .I ht "" (
262: and
263: .I wd )
264: and one of the corners
265: (say
266: .I sw ):
267: .Ks
268: .IS
269: ...width 0.25
270: main {
271: put rect {
272: sw = 0;
273: ht = 1;
274: wd = 0.5;
275: };
276: }
277: .IF
278: .P1
279: put rect {
280: ht = 2;
281: wd = 1;
282: sw = 0;
283: };
284: .P2
285: .Ke
286: Any of the following \fIput\fP statements would draw the same rectangle:
287: (C programmers will recognize the
288: .CW /*
289: and
290: .CW */
291: comment brackets.)
292: .P1
293: /* giving one corner, one dimension
294: and a relation on the dimensions */
295: put rect {
296: ht = 2;
297: wd = 0.5*ht;
298: nw = (0,2);
299: };
300: .P2
301: .P1
302: /* giving two adjacent corners
303: and the perpendicular dimension */
304: put rect {
305: nw = (0,2);
306: sw = 0;
307: wd = 1;
308: };
309: .P2
310: .P1
311: /* giving two diagonal corners
312: and a relation on the dimensions */
313: put rect {
314: ne = (1,2);
315: sw = 0;
316: wd = 0.5*ht;
317: };
318: .P2
319: .P1
320: /* giving three corners */
321: put rect {
322: ne = (1,2);
323: nw = (0,2);
324: se = 1;
325: };
326: .P2
327: .P1
328: /* giving the center of a side,
329: a corner, and another dimension */
330: put rect {
331: (nw+sw)/2 = (0,1);
332: nw = (0,2);
333: wd = 1;
334: };
335: .P2
336: .LP
337: The \fIput\fP statement is to \*(id what a procedure
338: call is to a conventional programming language.
339: The difference is that none of the variables
340: of a box must be specified to be a parameter
341: whose value is expected in any call:
342: any of the box's variables may be set by the
343: \fIput\fP statement, and \*(id will determine the
344: rest by means of the equations
345: in the definition of the box.
346: This means we can give whatever
347: information we know about this instance of the box,
348: as long as it is enough to determine everything uniquely.
349: This mechanism is useful because we often want to
350: set down a rectangle by giving one of its corners,
351: but not necessarily the same corner each time;
352: in a conventional programming language, we would
353: need to provide a different procedure for each
354: corner, and the code to solve for the other
355: corners from it.
356: (Almost certainly, not all of the \fIput\fP statements
357: above are equally useful; but it is good to be
358: able to use any of them when the need arises.)
359: .Ts
360: Here is how \*(id solves the system of equations
361: implicit in a program:
362: First, all equations are placed on a queue.
363: Every time a box is called, the solutions
364: to these equations may\(emand probably will\(embe
365: different, so all the equations of a box
366: are enqueued separately for each time that
367: box is put.
368: (Of course, different copies of the equation
369: refer to different copies of the variable,
370: but \*(id keeps that straight.)
371: During processing, \*(id maintains two classes
372: of variables: dependent and independent.
373: Each dependent variable is represented as a
374: linear combination of independent variables
375: plus a constant term.
376: (Variables whose values are known are a trivial
377: case of dependent variables.)
378: All variables start out independent.
379: As long as there are equations on the queue, \*(id
380: examines the head equation:
381: if, after substituting for all dependent variables,
382: the equation is linear, \*(id determines new
383: information from it if possible\(emthat is, \*(id
384: tries to make one variable dependent
385: on the others, thus reducing the number of
386: independent variables\(emor decides
387: whether it is redundant or inconsistent;
388: if the equation remains non-linear after substitution, \*(id
389: adds it to the end of the queue and proceeds.
390: If \*(id ever goes through the whole queue without
391: discovering any new information, the system cannot
392: be solved
393: (by \*(id, anyway)
394: and \*(id complains bitterly.
395: If there are any independent variables left after
396: this processing, \*(id will complain too, because
397: there is no way they can become known.
398: .Te
399: .PP
400: The variables
401: .I wd
402: and
403: .I ht
404: above are complex numbers just like the corners,
405: so we can rotate the rectangle
406: by giving them complex non-real values:
407: .Ks
408: .IS
409: ...width 0.5
410: main {
411: put rect {
412: sw = 0;
413: wd = (1,1)/abs((1,1));
414: ht = 2*wd;
415: };
416: }
417: .IF
418: .P1
419: put rect {
420: sw = 0;
421: wd = (1,1)/abs((1,1));
422: ht = 2*wd;
423: };
424: .P2
425: .Ke
426: .LP
427: (The double parentheses are needed in
428: .CW abs((1,1))
429: because
430: .CW abs(1,1)
431: is parsed as a function with two arguments.)
432: One point about this example often confuses new users:
433: the vectors
434: .I wd
435: and
436: .I ht
437: point in the
438: .I same
439: direction.
440: It is in the definition of
441: .I rect
442: that the $ht$ vector is rotated ninety degrees
443: and added to the southern points to arrive
444: at the northern points.
445: Thus, if we give a
446: .I ht
447: that is perpendicular to
448: .I wd ,
449: we get a very flat rectangle.
450: .PP
451: On the other hand, the definition of
452: .I rect
453: does not assure that
454: .I ht
455: and
456: .I wd
457: will point in the same direction.
458: This \fIput\fP statement
459: draws a parallelogram:
460: .Ks
461: .IS
462: ...width 0.25
463: main {
464: put rect {
465: ht = 1;
466: wd = (1,1)/abs((1,1));
467: sw = 0;
468: };
469: }
470: .IF
471: .P1
472: put rect {
473: ht = 1;
474: wd = (1,1)/abs((1,1));
475: sw = 0;
476: };
477: .P2
478: .Ke
479: .LP
480: Some people who feel that
481: a box called
482: .I rect
483: should draw only rectangles
484: are disturbed by this example.
485: One remedy is to add another equation
486: to the definition of
487: .I rect ,
488: asserting that two adjacent sides
489: are perpendicular; \*(id will complain if this equation
490: is not satisfied
491: (although it won't stop drawing).
492: One such equation is
493: .P1
494: wd/abs(wd) = ht/abs(ht);
495: .P2
496: .PP
497: Here is a definition for box
498: .I arrow
499: that keeps the head of the arrow symmetrical
500: about its shaft:
501: .Ks
502: .IS
503: arrow {
504: var hd, tl, head, wing;
505: head = 0.2;
506: wing = head*(tl-hd)/abs(tl-hd);
507: conn hd to tl;
508: conn hd + cis(25)*wing to hd to hd + cis(-25)*wing;
509: }
510: main {
511: put arrow {
512: hd = 0;
513: tl = (1,1);
514: };
515: }
516: .IF
517: .P1
518: arrow {
519: var hd, tl, head, wing;
520: head = 0.1;
521: wing = head*(tl-hd)/abs(tl-hd);
522: conn hd to tl;
523: conn hd + cis(25)*wing to hd to hd + cis(-25)*wing;
524: }
525: .P2
526: .Ke
527: .LP
528: Note the definition of
529: .I wing
530: in the example above:
531: the second part of the expression is a unit vector
532: that points from
533: .I tl
534: to
535: .I hd ;
536: this is multiplied by
537: .I head ,
538: the length of the ``wings'' on the arrowhead.
539: .Ts
540: When a \fIput\fP statement is interpreted, the equations in
541: its parameter section are processed before
542: the equations in its definition.
543: Thus, if there are inconsistent equations
544: between the \fIput\fP statement
545: and the box definition, the equations in
546: the \fIput\fP statement take precedence.
547: This can be useful to provide
548: default values for variables of a box.
549: For instance, if the definition of
550: .I rect
551: gave such default values to
552: .I ht
553: and
554: .I wd ,
555: they would take effect unless overridden
556: by equations in the parameter section
557: of the \fIput\fP statement.
558: .Te
559: .Ts
560: .I Ideal
561: ignores inconsistent equations, but it
562: does generate error messages about them.
563: To avoid this error message
564: about a particular equation, use a
565: tilde
566: .CW ~
567: instead of an equals
568: sign in the equation.
569: The tilde does
570: .I not
571: give the equation any lower ``priority''
572: than an equation with an equals sign:
573: all it does is shut off the error message.
574: So, the two ordered systems
575: .CW "x = 1" ,
576: .CW "x ~ 2"
577: and
578: .CW "x ~ 2" ,
579: .CW "x = 1"
580: are
581: .I different .
582: In the former, $x$ receives the value 1, and no error
583: message appears when the second equation is processed;
584: in the latter, $x$ receives the value 2, and an error
585: is generated when the second equation is encountered.
586: .Te
587: .NH 2
588: Special Boxes\(emCircles and Arcs
589: .PP
590: Boxes to draw circles and circular arcs are defined
591: in special library files.
592: .NH 3
593: Circles
594: .PP
595: The box named
596: .I circle
597: has five local variables:
598: .I center ,
599: .I radius ,
600: .I z1 ,
601: .I z2 ,
602: and
603: .I z3 .
604: The last three may be any points on the circle.
605: As above, we must give enough information to
606: determine a circle;
607: giving two points on it is insufficient, and
608: giving three collinear points is inconsistent.
609: Here are three ways to draw
610: a circle of radius one centered at the origin.
611: .Ks
612: .IS
613: ...width 0.5
614: ...libfile circle
615: dot {
616: var center;
617: center = ZAP.center;
618: put ZAP:circle {
619: radius = 0.1;
620: };
621: }
622: main {
623: put A:circle {
624: center = 0;
625: radius = 1;
626: };
627: left ' (z1)' at cis(0);
628: right '(z2) ' at cis(135);
629: right '(z3) ' at cis(245);
630: put dot {center = cis(0);};
631: put dot {center = cis(135);};
632: put dot {center = cis(245);};
633: }
634: .IF
635: .P1
636: /* giving center and radius */
637: put circle {
638: center = 0;
639: radius = 1;
640: };
641: .P2
642: .Ke
643: .P1
644: /* giving center and a point on the circle */
645: put circle {
646: center = 0;
647: z1 = 1; /* could also have given z2 or z3 */
648: };
649: .P2
650: .P1
651: /* giving three points on the circle */
652: put circle {
653: z1 = (1,0);
654: z2 = cis(135);
655: z3 = cis(235);
656: };
657: .P2
658: .LP
659: Once the circle has been determined, all five of its
660: internal variables are known.
661: So, if we ask for a circle giving three points, the
662: radius and center will be known afterward.
663: On the other hand, if we ask for a circle by giving
664: the center and the radius, the three points $z1$, $z2$,
665: and $z3$, will be known, and will be on the circle,
666: but there is no guarantee where they will be.
667: .NH 3
668: Arcs
669: .PP
670: Box
671: .I arc
672: has eight local variables:
673: .I center ,
674: .I radius ,
675: .I start ,
676: .I midway ,
677: .I end ,
678: .I startang ,
679: .I midang ,
680: and
681: .I endang .
682: It is an arc centered at point
683: .I center
684: with radius
685: .I radius ,
686: starting at point
687: .I start
688: at an angle
689: .I startang ,
690: passing through point
691: .I midway
692: at an angle
693: .I midang ,
694: and ending at point
695: .I end
696: at an angle
697: .I endang .
698: (All angles are measured with respect to $center$,
699: in degrees, with the positive $x$-axis taken to be
700: zero degrees, and the counterclockwise direction to
701: be positive.)
702: Note that $midway$ is
703: .I not
704: necessarily the midpoint of the arc!
705: If neither
706: .I midway
707: nor
708: .I midang
709: is given, the arc is drawn
710: counterclockwise from
711: .I start
712: to
713: .I end .
714: Once again, a variety of \fIput\fP statements draw the same arc:
715: .Ks
716: .IS
717: ...libfile arc
718: main {
719: put A:arc {
720: start = 1;
721: end = cis(235);
722: center = 0;
723: };
724: left ' (start)' at A.start;
725: right '(midway) ' at cis(180);
726: left ' (end)' at A.end;
727: put dot {center = A.start;};
728: put dot {center = cis(180);};
729: put dot {center = A.end;};
730: }
731: .IF
732: .P1
733: /* giving center, radius, and
734: starting and ending angles */
735: put arc {
736: center = 0;
737: radius = 1;
738: startang = 0;
739: endang = 235;
740: };
741: .P2
742: .Ke
743: .P1
744: /* giving center, starting point,
745: and ending angle */
746: put arc {
747: center = 0;
748: start = 1;
749: endang = 235;
750: };
751: .P2
752: .Ks
753: .IS
754: main {
755: put A:arc {
756: start = 1;
757: end = cis(235);
758: center = 0;
759: };
760: left ' (end)' at A.start;
761: right '(midway) ' at cis(180);
762: left ' (start)' at A.end;
763: put dot {center = A.start;};
764: put dot {center = cis(180);};
765: put dot {center = A.end;};
766: }
767: .IF
768: .P1
769: /* giving three points on the arc */
770: put arc {
771: start = cis(235);
772: midway = -1;
773: end = 0;
774: };
775: .P2
776: .Ke
777: .NH 2
778: Other Elements of \*(id Pictures
779: .PP
780: .I Ideal
781: pictures also may contain text and splines.
782: .NH 3
783: Text Captions
784: .PP
785: There are three commands to place text with respect to a point.
786: The
787: .I left
788: command left-justifies the text with respect to the specified location:
789: the text will start there.
790: The
791: .I right
792: command right-justifies the text so that it ends at the specified
793: location.
794: The default is to center the text at the point.
795: (The arrows in this picture point to the locations of the named points.)
796: .Ks
797: .P1
798: left "some text" at x;
799: .P2
800: .P1
801: \&"some centered text" at y;
802: .P2
803: .P1
804: right "some other text" at z;
805: .P2
806: .IS
807: ...colwid 6.0
808: ...width 4.0
809: arrow {
810: var tl, hd, head, perp, headang;
811: conn tl to hd;
812: perp = head*(tl-hd)/abs(tl-hd);
813: conn hd + cis(headang)*perp to hd to hd + cis(-headang)*perp;
814: head ~ 0.1;
815: headang ~ 25;
816: var start, end;
817: start = tl;
818: end = hd;
819: }
820: main {
821: var x, y, z;
822: var offset;
823: offset = (1,-1);
824: x = 0;
825: left 'some text' at x;
826: put arrow {
827: start = x + offset;
828: end = x;
829: left ' (x)' at start;
830: };
831: y = 3;
832: 'some centered text' at y;
833: put arrow {
834: start = y + offset;
835: end = y;
836: left ' (y)' at start;
837: };
838: z = 6;
839: right 'some other text' at z;
840: put arrow {
841: start = z + offset;
842: end = z;
843: left ' (z)' at start;
844: };
845: }
846: .IE
847: .Ke
848: .LP
849: To include a double quote mark in a string, escape it with a back-slash.
850: If you have a line running through a point at which you place some text,
851: you may want to add a space to one end of the text so that the line
852: doesn't chop through the text.
853: The string may include
854: .I troff
855: special characters (like
856: .CW \e(bu )
857: and commands to other preprocessors (notably
858: .I eqn ),
859: but \*(id should be run before any other preprocessors.
860: .NH 3
861: Splines
862: .PP
863: .I Ideal
864: provides quadratic splines that are drawn with a
865: B-spline basis:
866: the user supplies a sequence of guiding points, and \*(id
867: draws a smooth curve that is tangent to the polygonal
868: path they define at the midpoint of each segment;
869: the spline also starts at the first point and ends at the last.
870: .Ks
871: .IS
872: ...colwid 8.0
873: ...width 1.0
874: ...maxx 2.0
875: ...minx -1.0
876: ...maxy 2.0
877: ...miny 0.0
878: main {
879: var x, y, z, w;
880: x = 0;
881: y = 1;
882: z = (-1,1);
883: w = (2,2);
884: spline x to y to z to w;
885: right '(x) ' at x;
886: left ' (y)' at y;
887: right '(z) ' at z;
888: left ' (w)' at w;
889: put dot {center = x;};
890: put dot {center = y;};
891: put dot {center = z;};
892: put dot {center = w;};
893: }
894: .IF
895: .P1
896: spline x to y to z to w;
897:
898:
899: .P2
900: .Ke
901: .NH 1
902: Putting Boxes Together
903: .PP
904: In this section we present several complete \*(id
905: programs to show how to build up
906: pictures from boxes.
907: .NH 2
908: Naming Instances of Boxes
909: .PP
910: Most pictures involve more than placements of simple boxes.
911: And when pictures involve several boxes, certain geometrical
912: relationships should exist among them.
913: We can refer to the local variables of a box that has been put\(emall
914: we need to do is name the \fIput\fP statement.
915: Here is a simple example showing a diagram that could be used to illustrate
916: Pythagoras's Theorem for isoceles triangles:
917: .Ks
918: .IS
919: ...libfile rect
920: ...width 1.0
921: main {
922: put first: rect {
923: sw = 0;
924: ht = wd = 1;
925: };
926: put next: rect {
927: nw = first.se;
928: ht = wd = first.ht;
929: };
930: put last: rect {
931: sw = first.ne;
932: se = next.ne;
933: ht = wd;
934: };
935: }
936: .IF
937: .P1
938: main {
939: put first: rect {
940: sw = 0;
941: ht = wd = 1;
942: };
943: put next: rect {
944: nw = first.se;
945: ht = wd = first.ht;
946: };
947: put last: rect {
948: sw = first.ne;
949: se = next.ne;
950: ht = wd;
951: };
952: }
953: .P2
954: .Ke
955: .LP
956: First we place an instance of
957: .I rect
958: called
959: .I first .
960: Then we place another
961: .I rect
962: with its upper left corner ($ne$)
963: at the lower right of
964: .I first .
965: Finally, we draw a third square,
966: two of whose adjacent points are
967: identified with points on the first
968: two squares placed.
969: We could have used any two adjacent points on
970: .I last :
971: if we had placed
972: $last.ne$ at $first.ne$
973: and $last.nw$ at $next.ne$, \*(id
974: would have figured all the relationships
975: out right, although the program might be quite
976: inscrutable to humans.
977: .PP
978: How can we circumscribe a triangle?
979: If we name the \fIput\fP statement that produces
980: the instance, we can just give its three
981: vertices as values for $z1$, $z2$, and $z3$
982: in an instance of
983: .I circle .
984: .Ks
985: .IS
986: ...libfile circle
987: triangle {
988: var z1, z2, z3;
989: conn z1 to z2 to z3 to z1;
990: }
991: main {
992: put T: triangle {
993: z1 = 0;
994: z2 = 1;
995: z3 = (2,2);
996: };
997: put circle {
998: z1 = T.z1;
999: z2 = T.z2;
1000: z3 = T.z3;
1001: };
1002: }
1003: .IF
1004: .P1
1005: triangle {
1006: var z1, z2, z3;
1007: conn z1 to z2 to z3 to z1;
1008: }
1009:
1010: main {
1011: put T: triangle {
1012: z1 = 0;
1013: z2 = 1;
1014: z3 = (2,2);
1015: };
1016: put circle {
1017: z1 = T.z1;
1018: z2 = T.z2;
1019: z3 = T.z3;
1020: };
1021: }
1022: .P2
1023: .Ke
1024: .NH 2
1025: Parameter Section Commands
1026: .PP
1027: Any \*(id statement may appear in the parameter
1028: section of a \fIput\fP statement.
1029: This section illustrates some uses of this feature.
1030: .PP
1031: Suppose we will need to draw
1032: pictures of a linked list before and after
1033: insertion of a new node.
1034: We might start with this definition
1035: of a
1036: .I listnode :
1037: .Ks
1038: .IS
1039: ...width 1.0
1040: ...colwid 8.0
1041: listnode {
1042: put info: rect {
1043: var hook;
1044: hook = (nw + sw)/2;
1045: ht = lht;
1046: wd = lwd/2;
1047: };
1048: put next: rect {
1049: var c;
1050: c = (nw + se)/2;
1051: sw = info.se;
1052: ht = lht;
1053: wd = lwd/2;
1054: };
1055: }
1056: main {
1057: put listnode {
1058: info.sw = 0;
1059: var lht, lwd;
1060: lht = 1;
1061: lwd = 2;
1062: };
1063: }
1064: .IF
1065: .P1
1066: listnode {
1067: put info: rect {
1068: var hook;
1069: hook = (nw + sw)/2;
1070: ht = lht;
1071: wd = lwd/2;
1072: };
1073: put next: rect {
1074: var c;
1075: c = (nw + se)/2;
1076: sw = info.se;
1077: ht = lht;
1078: wd = lwd/2;
1079: };
1080: }
1081: .P2
1082: .Ke
1083: .LP
1084: This version of
1085: .I listnode
1086: depends on
1087: .I rect .
1088: Notice that it references two variables
1089: ($lwd$ and $lht$) that are not local to
1090: itself:
1091: these variables must be defined in any
1092: environment in which $listnode$ is put.
1093: (They are global to it.)
1094: We have added statements that define new
1095: variables ($hook$ in $first$ and $c$ in $next$)
1096: that are local to the particular instance of
1097: .I rect .
1098: .PP
1099: Now we draw the list as it is before insertion:
1100: .Ks
1101: .IS
1102: arrow {
1103: var hd, tl, head, wing;
1104: head = 0.2;
1105: wing = head*(tl-hd)/abs(tl-hd);
1106: conn hd to tl;
1107: conn hd + cis(25)*wing to hd to hd + cis(-25)*wing;
1108: }
1109: ...width 2.0
1110: main {
1111: var lht, lwd;
1112: lht = 1;
1113: lwd = 2*lht;
1114: put first: listnode {
1115: info.sw = 0;
1116: };
1117: put last: listnode {
1118: info.sw = 2[first.info.sw,first.next.se];
1119: conn next.sw to next.ne;
1120: };
1121: put new: listnode {
1122: info.nw = 2[first.next.ne,first.next.se];
1123: };
1124: put arrow {
1125: hd = last.info.hook;
1126: tl = first.next.c;
1127: };
1128: put arrow {
1129: hd = new.info.hook;
1130: tl = hd - 1;
1131: right 'new ' at tl;
1132: };
1133: put arrow {
1134: hd = first.info.hook;
1135: tl = hd - 1;
1136: right 'list ' at tl;
1137: };
1138: }
1139: .IF
1140: .P1
1141: main {
1142: var lht, lwd;
1143: lht = 1;
1144: lwd = 2*lht;
1145: put first: listnode {
1146: info.sw = 0;
1147: };
1148: put last: listnode {
1149: info.sw = 2[first.info.sw,first.next.se];
1150: conn next.sw to next.ne;
1151: };
1152: put new: listnode {
1153: info.nw = 2[first.next.ne,first.next.se];
1154: };
1155: put arrow {
1156: hd = last.info.hook;
1157: tl = first.next.c;
1158: };
1159: put arrow {
1160: hd = new.info.hook;
1161: tl = hd - 1;
1162: right "new " at tl;
1163: };
1164: put arrow {
1165: hd = first.info.hook;
1166: tl = hd - 1;
1167: right "list " at tl;
1168: };
1169: }
1170: .P2
1171: .Ke
1172: .LP
1173: Here we have added statements directly to the
1174: parameter section of two of the calls to
1175: .I arrow
1176: to avoid either naming each instance of
1177: .I arrow
1178: or naming the tails of these arrows so that
1179: text could be placed there.
1180: We have also added a statement to draw the
1181: null pointer in box
1182: .I last .
1183: .PP
1184: The program to draw the list after insertion of the
1185: new node remains largely unchanged:
1186: the nodes haven't moved; only the arrows hooking them
1187: together have moved.
1188: .Ks
1189: .IS
1190: main {
1191: var lht, lwd;
1192: lht = 1;
1193: lwd = 2*lht;
1194: put first: listnode {
1195: info.sw = 0;
1196: };
1197: put last: listnode {
1198: info.sw = 2[first.info.sw,first.next.se];
1199: conn next.sw to next.ne;
1200: };
1201: put new: listnode {
1202: info.nw = 2[first.next.ne,first.next.se];
1203: };
1204: put arrow {
1205: hd = new.info.nw;
1206: tl = first.next.c;
1207: };
1208: put arrow {
1209: hd = last.info.sw;
1210: tl = new.next.c;
1211: };
1212: put arrow {
1213: hd = new.info.hook;
1214: tl = hd - 1;
1215: right 'new ' at tl;
1216: };
1217: put arrow {
1218: hd = first.info.hook;
1219: tl = hd - 1;
1220: right 'list ' at tl;
1221: };
1222: }
1223: .IF
1224: .P1
1225: main {
1226: var lht, lwd;
1227: lht = 1;
1228: lwd = 2*lht;
1229: put first: listnode {
1230: info.sw = 0;
1231: };
1232: put last: listnode {
1233: info.sw = 2[first.info.sw,first.next.se];
1234: conn next.sw to next.ne;
1235: };
1236: put new: listnode {
1237: info.nw = 2[first.next.ne,first.next.se];
1238: };
1239: /* These two arrows are different: */
1240: put arrow {
1241: hd = new.info.nw;
1242: tl = first.next.c;
1243: };
1244: put arrow {
1245: hd = last.info.sw;
1246: tl = new.next.c;
1247: }
1248: /* These are the same as before: */
1249: put arrow {
1250: hd = new.info.hook;
1251: tl = hd - 1;
1252: right "new " at tl;
1253: };
1254: put arrow {
1255: hd = first.info.hook;
1256: tl = hd - 1;
1257: right "list " at tl;
1258: };
1259: }
1260: .P2
1261: .Ke
1262: .NH 2
1263: A Shorter Version
1264: .PP
1265: The previous example is somewhat long-winded
1266: because it demonstrates many features of \*(id
1267: that really aren't needed.
1268: For instance, it would probably have made better
1269: sense to define
1270: .I listnode
1271: as a basic element rather than building it out
1272: of
1273: .I rect s.
1274: This would reduce the need for delving deep
1275: into the internals of boxes from outside
1276: (e.g.
1277: .I first.info.hook ).
1278: Here is the same example reworked:
1279: .Ks
1280: .IS
1281: ...width 2
1282: listnode {
1283: var n, s, e, w, ne, nw, se, sw, next;
1284: n = s + (0,1)*lht;
1285: ne = n + 0.5*lwd = nw + lwd;
1286: se = s + 0.5*lwd = sw + lwd;
1287: e = (ne + se)/2;
1288: w = (nw + sw)/2;
1289: next = (ne + s)/2;
1290: conn nw to ne to se to sw to nw;
1291: conn n to s;
1292: }
1293:
1294: main {
1295: var lht, lwd;
1296: lht = 1;
1297: lwd = 2;
1298: put first: listnode {
1299: sw = 0;
1300: };
1301: put last: listnode {
1302: sw = 2[first.sw,first.se];
1303: conn s to ne;
1304: };
1305: put new: listnode {
1306: nw = 2[first.ne,first.se];
1307: };
1308: put arrow {
1309: hd = new.nw;
1310: tl = first.next;
1311: };
1312: put arrow {
1313: hd = last.sw;
1314: tl = new.next;
1315: };
1316: put arrow {
1317: hd = new.w;
1318: tl = hd - 1;
1319: right "new " at tl;
1320: };
1321: put arrow {
1322: hd = first.w;
1323: tl = hd - 1;
1324: right "list " at tl;
1325: };
1326: }
1327: .IE
1328: .P1
1329: listnode {
1330: var n, s, e, w, ne, nw, se, sw, next;
1331: n = s + (0,1)*lht;
1332: ne = n + 0.5*lwd = nw + lwd;
1333: se = s + 0.5*lwd = sw + lwd;
1334: e = (ne + se)/2;
1335: w = (nw + sw)/2;
1336: next = (ne + s)/2;
1337: conn nw to ne to se to sw to nw;
1338: conn n to s;
1339: }
1340:
1341: main {
1342: var lht, lwd;
1343: lht = 1;
1344: lwd = 2;
1345: put first: listnode {
1346: sw = 0;
1347: };
1348: put last: listnode {
1349: sw = 2[first.sw,first.se];
1350: conn s to ne;
1351: };
1352: put new: listnode {
1353: nw = 2[first.ne,first.se];
1354: };
1355: put arrow {
1356: hd = new.nw;
1357: tl = first.next;
1358: };
1359: put arrow {
1360: hd = last.sw;
1361: tl = new.next;
1362: };
1363: put arrow {
1364: hd = new.w;
1365: tl = hd - 1;
1366: right "new " at tl;
1367: };
1368: put arrow {
1369: hd = first.w;
1370: tl = hd - 1;
1371: right "list " at tl;
1372: };
1373: }
1374: .P2
1375: .Ke
1376: Notice that equations need not be just a left side and a right side:
1377: they may include several expressions that should be equal.
1378: ...........
1379: .NH 1
1380: Iteration of \*(id Constructs
1381: .NH 2
1382: Pens
1383: .PP
1384: In Donald Knuth's \s-2METAFONT\s0|reference(knuth metafont)
1385: system, pens are different
1386: shapes\(emcircles, ellipses, and polygons\(emthat draw along
1387: curves.
1388: .I Ideal
1389: includes pens as a generalization of this idea:
1390: .I any
1391: box may be used to draw along a line.
1392: For instance, users may define ``dashed'' or ``dotted'' pens.
1393: A pen statement looks like this:
1394: .SP
1395: .P1
1396: conn $x$ to $y$
1397: using $n$ $pen$ {
1398: ...
1399: } <$a$,$b$>;
1400: .P2
1401: (The only keywords in this statement are $conn$, $"to"$, and $using$.)
1402: .I Pen
1403: may be any box.
1404: .I Ideal
1405: will place $n$ copies of
1406: .I pen
1407: in the space from $x$ to $y$.
1408: $a$ and $b$ are expressions known to
1409: .I pen .
1410: The first instance of
1411: .I pen
1412: will have $a$ at $x$, and
1413: the last instance of
1414: .I pen
1415: will have $b$ at $y$;
1416: every instance in between will have
1417: its $a$ at the preceding one's $b$,
1418: and its $b$ at the succeeding one's $a$,
1419: as shown in this picture:
1420: .Ks
1421: .IS
1422: ...colwid 6.0
1423: ...width 4.0
1424: ...libfile rect
1425: pen {
1426: var e, w, c;
1427: var s;
1428: e = r.e;
1429: s = r.s;
1430: w = r.w;
1431: c = r.c;
1432: put r: rect {
1433: ht = wd = 1;
1434: };
1435: left ' \f2a\fP' at w;
1436: right '\f2b\fP ' at e;
1437: }
1438: main {
1439: put first: pen {
1440: w = 0;
1441: right '\f2x\fP ' at w;
1442: '1' at s+(0,0.1);
1443: };
1444: put second: pen {
1445: w = first.e;
1446: '2' at s+(0,0.1);
1447: };
1448: '...' at (second.e + ipth.w)/2;
1449: put ipth: pen {
1450: w = 2[second.w,second.e];
1451: '\f2i\fP\-1' at s+(0,0.1);
1452: };
1453: put ith: pen {
1454: w = ipth.e;
1455: '\f2i\fP' at s+(0,0.1);
1456: };
1457: put inth: pen {
1458: w = ith.e;
1459: '\f2i\fP+1' at s+(0,0.1);
1460: };
1461: '...' at (inth.e + last.w)/2;
1462: put last: pen {
1463: w = 2[inth.w,inth.e];
1464: '\f2n\fP' at s+(0,0.1);
1465: left ' \f2y\fP' at e;
1466: };
1467: }
1468: .IE
1469: .Ke
1470: .PP
1471: Here is an example box that contains an angular wavy path:
1472: .Ks
1473: .IS
1474: ...colwid 9.0
1475: ...width 1.0
1476: wavy {
1477: var start, end, perp, pt1, pt2, ht;
1478: perp = (0,1)*(start - end)/abs(start - end);
1479: pt1 = 0.25[start,end] + perp*ht;
1480: pt2 = 0.75[start,end] - perp*ht;
1481: conn start to pt1 to pt2 to end;
1482: }
1483: main {
1484: put wavy {
1485: start = 0;
1486: end = 1;
1487: ht = 0.2;
1488: right '(start) ' at start;
1489: left ' (end)' at end;
1490: };
1491: }
1492: .IE
1493: .P1
1494: wavy {
1495: var start, end, perp, pt1, pt2, ht;
1496: perp = (0,1)*(start - end)/abs(start - end);
1497: pt1 = 0.25[start,end] + perp*ht;
1498: pt2 = 0.75[start,end] - perp*ht;
1499: conn start to pt1 to pt2 to end;
1500: }
1501: .P2
1502: .Ke
1503: .LP
1504: Here we use
1505: .I wavy
1506: as a pen to indicate that part of a rectangle is missing.
1507: .Ks
1508: .IS
1509: main {
1510: var ne, nw, se, sw;
1511: var n1, s1, n2, s2;
1512: sw = 0;
1513: ne = nw + 2;
1514: se = sw + 2;
1515: ne = se + (0,1);
1516: n2 - 0.4 = n1 = 0.6[nw,ne];
1517: s2 - 0.4 = s1 = 0.4[sw,se];
1518: conn n1 to nw to sw to s1;
1519: conn n1 to s1
1520: using int(5*abs(n1-s1)) wavy {
1521: ht = -0.1;
1522: } <start,end>;
1523: conn n2 to ne to se to s2;
1524: conn n2 to s2
1525: using int(5*abs(n2-s2)) wavy {
1526: ht = -0.1;
1527: } <start,end>;
1528: }
1529: .IF
1530: .P1
1531: main {
1532: var ne, nw, se, sw;
1533: var n1, s1, n2, s2;
1534: ne = nw + 2;
1535: se = sw + 2;
1536: ne = se + (0,1);
1537: n2 - 0.4 = n1 = 0.6[nw,ne];
1538: s2 - 0.4 = s1 = 0.4[sw,se];
1539: conn n1 to nw to sw to s1;
1540: conn n1 to s1
1541: using int(5*abs(n1-s1)) wavy {
1542: ht = -0.1;
1543: } <start,end>;
1544: conn n2 to ne to se to s2;
1545: conn n2 to s2
1546: using int(5*abs(n2-s2)) wavy {
1547: ht = -0.1;
1548: } <start,end>;
1549: }
1550: .P2
1551: .Ke
1552: .LP
1553: We can change
1554: .I wavy
1555: to contain a smooth wave
1556: by changing the word
1557: .I conn
1558: in the fifth line of its definition to
1559: .I spline ,
1560: and use the same instructions above to draw
1561: the picture with the new pen.
1562: .Ks
1563: .IS
1564: wavy {
1565: var start, end, perp, pt1, pt2, ht;
1566: perp = (0,1)*(start - end)/abs(start - end);
1567: pt1 = 0.25[start,end] + perp*ht;
1568: pt2 = 0.75[start,end] - perp*ht;
1569: spline start to pt1 to pt2 to end;
1570: }
1571: main {
1572: var ne, nw, se, sw;
1573: var n1, s1, n2, s2;
1574: sw = 0;
1575: ne = nw + 2;
1576: se = sw + 2;
1577: ne = se + (0,1);
1578: n2 - 0.4 = n1 = 0.6[nw,ne];
1579: s2 - 0.4 = s1 = 0.4[sw,se];
1580: conn n1 to nw to sw to s1;
1581: conn n1 to s1
1582: using int(5*abs(n1-s1)) wavy {
1583: ht = -0.1;
1584: } <start,end>;
1585: conn n2 to ne to se to s2;
1586: conn n2 to s2
1587: using int(5*abs(n2-s2)) wavy {
1588: ht = -0.1;
1589: } <start,end>;
1590: }
1591: .IE
1592: .Ke
1593: .NH 2
1594: Pens as For-Statements
1595: .PP
1596: If \*(id had a for-statement, the pen statement
1597: .P1
1598: conn $x$ to $y$
1599: using $n$ $pen$ {
1600: ...
1601: } <$a$,$b$>;
1602: .P2
1603: .LP
1604: would be equivalent to
1605: .P1
1606: for $i$ = 1 to $n$ {
1607: put $pen$ {
1608: $a$ = (($i$-1)/$n$)[$x$,$y$];
1609: $b$ = ($i$/$n$)[$x$,$y$];
1610: ...
1611: };
1612: }
1613: .P2
1614: .Ts
1615: This means a pen statement can be used to synthesize
1616: a for-statement in an \*(id program.
1617: Here is a pen statement to draw a dashed arc:
1618: .Ks
1619: .IS
1620: ...libfile arc
1621: main {
1622: conn 0 to 180
1623: using 10 arc {
1624: center = 0;
1625: radius = 1;
1626: }<startang, 9+endang>;
1627: }
1628: .IF
1629: .P1
1630: conn 0 to 180
1631: using 10 arc {
1632: center = 0;
1633: radius = 1;
1634: }<startang, 9+endang>;
1635: .P2
1636: .Ke
1637: .Te
1638: .Ts
1639: To draw a set of concentric circles
1640: we can say:
1641: .Ks
1642: .IS
1643: ...libfile circle
1644: main {
1645: conn 1 to 6
1646: using 5 circle {
1647: center = 0;
1648: } <radius, radius+1>;
1649: }
1650: .IF
1651: .P1
1652: main {
1653: conn 1 to 6
1654: using 5 circle {
1655: center = 0;
1656: } <radius,radius+1>;
1657: }
1658: .P2
1659: .Ke
1660: .Te
1661: .Ts
1662: In the first example, the second expression in angle
1663: brackets is important: it means that each ``dash''
1664: covers nine degrees.
1665: In the second example, this expression is redundant:
1666: its only purpose is to prevent \*(id from generating
1667: a stream of error messages about inconsistent equations.
1668: This contorted way of simulating for-statements
1669: is necessary only because pens are meant to do
1670: the right thing at each end of and all along a path that is
1671: being drawn with some box, and not as general
1672: iteration constructs.
1673: .Te
1674: .Ts
1675: Why doesn't \*(id have
1676: for-statements?
1677: Notice that every variable in an \*(id program
1678: is assigned a value exactly once.
1679: Obviously the index of a for-statement must be
1680: an exception to that rule.
1681: Generating the index internally prevents the
1682: need to have two kinds of variables\(emchanging
1683: and fixed.
1684: The local variables of boxes placed by pen statements
1685: cannot be referenced outside the pen statement,
1686: because the boxes are not named when they are placed.
1687: A general for-statement could lead to the need to
1688: generate automatically names for different instances of boxes,
1689: a hard problem that I don't understand well enough yet.
1690: .Te
1691: ..........
1692: .NH 2
1693: Filling Regions
1694: .PP
1695: Because any box can be used as a pen, we can shade regions.
1696: (We can have not only dashed and dotted ink, but checkered paint!)
1697: Take box
1698: .I wavy ,
1699: for instance.
1700: First we construct a box
1701: .I brush ,
1702: which consists of seven copies of
1703: .I wavy
1704: going horizontally:
1705: .Ks
1706: .IS
1707: wavy {
1708: var start, end, perp, pt1, pt2, ht;
1709: perp = (0,1)*(start - end)/abs(start - end);
1710: pt1 = 0.25[start,end] + perp*ht;
1711: pt2 = 0.75[start,end] - perp*ht;
1712: conn start to pt1 to pt2 to end;
1713: }
1714: brush {
1715: var top, bot;
1716: var bwd, bht;
1717: var leftpt, rightpt;
1718: leftpt = 0.5*(top+bot) - bwd/2;
1719: rightpt = 0.5*(top+bot) +bwd/2;
1720: conn leftpt to rightpt
1721: using 7 wavy {
1722: ht = bht;
1723: }<start,end>;
1724: }
1725: main {
1726: put brush {
1727: leftpt = 0;
1728: rightpt = 7;
1729: bht = 0.3;
1730: };
1731: }
1732: .IF
1733: .P1
1734: brush {
1735: var top, bot;
1736: var bwd, bht;
1737: var leftpt, rightpt;
1738: leftpt = 0.5*(top+bot) - bwd/2;
1739: rightpt = 0.5*(top+bot) + bwd/2;
1740: conn leftpt to rightpt
1741: using 7 wavy {
1742: ht = bht;
1743: }<start,end>;
1744: }
1745: .P2
1746: .Ke
1747: Then we use ``brush'' to draw vertically
1748: over the region of interest.
1749: .Ks
1750: .IS
1751: background {
1752: conn (0,1) to (0,-1)
1753: using 6 brush {
1754: bwd = 2;
1755: bht = 0.1;
1756: }<top,bot>;
1757: }
1758: main {
1759: put background {
1760: };
1761: }
1762: .IF
1763: .P1
1764: conn (0,1) to (0,-1)
1765: using 6 brush {
1766: bwd = 2;
1767: bht = 0.1;
1768: }<top,bot>;
1769:
1770:
1771:
1772:
1773: .P2
1774: .Ke
1775: .NH 1
1776: Opaque Boxes
1777: .PP
1778: .I Ideal
1779: includes statements to blot out pieces
1780: of a picture.
1781: In this section we will sometimes place opaque boxes
1782: without explicitly drawing any background.
1783: In such cases, assume
1784: that we have painted over
1785: the area with pens as above.
1786: .NH 2
1787: Opaque Polygons
1788: .PP
1789: .I Ideal
1790: needs to know the vertices of a polygon in order
1791: to opaque the area it covers.
1792: The vertices are specified as a list in a
1793: .I boundary
1794: statement.
1795: For instance, to opaque a rectangular region using the
1796: .I rect
1797: box defined in Section 3, we could use the following statement:
1798: .Ks
1799: .IS
1800: ...libfile rect
1801: wavy {
1802: var start, end, perp, pt1, pt2, ht;
1803: perp = (0,1)*(start - end)/abs(start - end);
1804: pt1 = 0.25[start,end] + perp*ht;
1805: pt2 = 0.75[start,end] - perp*ht;
1806: conn start to pt1 to pt2 to end;
1807: }
1808: brush {
1809: var top, bot;
1810: var bwd, bht;
1811: var leftpt, rightpt;
1812: leftpt = 0.5*(top+bot) - bwd/2;
1813: rightpt = 0.5*(top+bot) +bwd/2;
1814: conn leftpt to rightpt
1815: using 7 wavy {
1816: ht = bht;
1817: }<start,end>;
1818: }
1819: background {
1820: conn (0,1) to (0,-1)
1821: using 7 brush {
1822: bwd = 2;
1823: bht = 0.1;
1824: }<top,bot>;
1825: }
1826: main {
1827: put background {
1828: };
1829: put rect {
1830: opaque;
1831: boundary = sw, se, ne, nw;
1832: sw = (-0.4,-0.4);
1833: wd = ht = 1;
1834: };
1835: }
1836: .IF
1837: .P1
1838: put rect {
1839: opaque;
1840: boundary= sw, se, ne, nw;
1841: sw = (-0.4,-0.4);
1842: wd = ht = 1;
1843: };
1844:
1845:
1846:
1847:
1848: .P2
1849: .Ke
1850: .LP
1851: The sides of the rectangle are drawn by
1852: .I rect :
1853: they are not supplied automatically by the opaquing routine.
1854: If we wanted to save only the interior of the rectangle,
1855: we could use almost the same statement:
1856: .Ks
1857: .IS
1858: ...minx -1.0
1859: ...maxx 1.0
1860: ...miny -1.0
1861: ...maxy 1.0
1862: main {
1863: put background {
1864: };
1865: put rect {
1866: opaque exterior;
1867: boundary = sw, se, ne, nw;
1868: sw = (-0.4,-0.4);
1869: wd = ht = 1;
1870: };
1871: }
1872: .IF
1873: .P1
1874: put rect {
1875: opaque exterior;
1876: boundary = sw, se, ne, nw;
1877: sw = (-0.4,-0.4);
1878: wd = ht = 1;
1879: };
1880: .P2
1881: .Ke
1882: .PP
1883: If we plan to opaque a lot of rectangles,
1884: we should include a
1885: .I boundary
1886: in the definition of
1887: .I rect .
1888: Such a default
1889: .I boundary
1890: would be referenced only if the parameter section
1891: of the \fIput\fP statement included an opaque statement
1892: .I and
1893: did not include its own
1894: .I boundary .
1895: .NH 2
1896: Opaque Circular Arc Polygons
1897: .PP
1898: The edges of opaque regions can also be circular arcs.
1899: .Ts
1900: This generalization of the simple boundary statement
1901: is the most recent addition to \*(id.
1902: It avoids treating circles and their sectors and segments
1903: as special cases, and makes opaquing circular
1904: arc polygons much easier.
1905: .Te
1906: .LP
1907: To specify a circular arc edge, one gives its endpoints
1908: and a point through which it passes;
1909: this ``pass-through'' point is marked in the boundary
1910: list by the symbol ``\f8^\fP''.
1911: For example, the boundary list for the sector shown below is
1912: .Ks
1913: .IS
1914: ...libfile arc
1915: main {
1916: put background {
1917: };
1918: put arc {
1919: center = (-1,-1);
1920: radius = 2;
1921: startang = 30;
1922: endang = 60;
1923: boundary = center,
1924: center+radius*cis(startang),
1925: ^center+radius*cis(0.5*(startang+endang)),
1926: center+radius*cis(endang);
1927: opaque;
1928: conn start to center to end;
1929: };
1930: }
1931: .IF
1932: .P1
1933: boundary = center, cis(30), ^ cis(45), cis(60);
1934:
1935:
1936:
1937:
1938:
1939: .P2
1940: .Ke
1941: .PP
1942: Another common opaque arc is the segment:
1943: .Ks
1944: .IS
1945: main {
1946: put background {
1947: };
1948: put arc {
1949: center = (-1,-1);
1950: radius = 2;
1951: startang = 0;
1952: endang = 90;
1953: boundary = start,
1954: ^center + radius*cis(0.5*(startang+endang)),
1955: end;
1956: opaque;
1957: conn start to end;
1958: };
1959: }
1960: .IF
1961: .P1
1962: boundary = cis(0), ^ cis(45), cis(90);
1963:
1964:
1965:
1966:
1967:
1968:
1969:
1970:
1971:
1972:
1973: .P2
1974: .Ke
1975: .PP
1976: One can construct an opaque circle out of two semicircular edges:
1977: .Ks
1978: .IS
1979: ...libfile circle
1980: main {
1981: put background {
1982: };
1983: put circle {
1984: radius = 0.5;
1985: center = 0;
1986: opaque;
1987: };
1988: put circle {
1989: radius = 1;
1990: center = 0;
1991: opaque exterior;
1992: };
1993: }
1994: .IF
1995: .P1
1996: boundary = cis(0), ^ cis(90), cis(180), ^ cis(270);
1997:
1998:
1999:
2000:
2001:
2002:
2003: .P2
2004: .Ke
2005: .LP
2006: Here, the outer circle has an opaque exterior,
2007: while the inner circle has an opaque interior.
2008: .NH 2
2009: Order is Important
2010: .PP
2011: Without the ability to opaque,
2012: the order in which boxes are put does not matter.
2013: But when some boxes are opaque, order obviously
2014: .I does
2015: matter.
2016: Put statements are executed
2017: in the order in which they appear in the box definition.
2018: When an opaque box is drawn, the opaquing is done
2019: .I first ,
2020: then the lines of the box are drawn;
2021: so, for instance, an opaque
2022: .I listnode
2023: does include the line down its middle separating its
2024: .I info
2025: field from its
2026: .I next
2027: field.
2028: .NH 2
2029: Some Hard Facts
2030: .PP
2031: Neither text nor splines can be used to opaque objects,
2032: nor will they be clipped properly if they are in a
2033: picture and an opaque box is placed over them.
2034: .Ts
2035: The problem with text is that \*(id operates as a
2036: .I troff
2037: preprocessor,
2038: so it cannot determine anything about the size of the
2039: text, and it needs to know that if it is to do anything
2040: involving opaquing and text.
2041: .Te
2042: .Ts
2043: The problem with splines is more subtle.
2044: When a line or circular arc is chopped,
2045: it is easy to specify the lines or circular arcs that remain.
2046: But when a spline is chopped, the guiding points of the resulting curve pieces
2047: are hard to determine.
2048: .Te
2049: .NH 1
2050: Paper Commands
2051: .PP
2052: .I Ideal
2053: includes two commands that are analogous
2054: to the way people draw on paper.
2055: .NH 2
2056: Construct
2057: .PP
2058: The
2059: .I construct
2060: statement looks just like a \fIput\fP statement,
2061: with the keyword
2062: .I put
2063: replaced by
2064: .I construct .
2065: It is best to think of it as laying a sheet of
2066: tracing paper over the current drawing.
2067: Anything constructed will be drawn on this sheet.
2068: When you return to the layer underneath,
2069: you may refer to any of the local variables
2070: (for example, with a \fIput\fP statement), but the lines and curves
2071: in the constructed picture don't show.
2072: .Ks
2073: .IS
2074: ...maxy 2.0
2075: ...minx -1.0
2076: ...maxx 1.0
2077: ...libfile rect arrow
2078: main {
2079: construct A: rect {
2080: sw = 0;
2081: wd = ht = 1;
2082: };
2083: construct B: rect {
2084: n = A.s - (0,1);
2085: wd = ht = 1;
2086: };
2087: 'top' at A.c;
2088: 'bottom' at B.c;
2089: put arrow {
2090: hd = B.n;
2091: tl = A.s;
2092: };
2093: }
2094: .IF
2095: .P1
2096: main {
2097: construct A: rect {
2098: sw = 0;
2099: wd = ht = 1;
2100: };
2101: construct B: rect {
2102: n = A.s - (0,1);
2103: wd = ht = 1;
2104: };
2105: 'top' at A.c;
2106: 'bottom' at B.c;
2107: put arrow {
2108: hd = B.n;
2109: tl = A.s;
2110: };
2111: }
2112: .P2
2113: .Ke
2114: .LP
2115: Here we have used ``invisible boxes'' to place the
2116: arrow around the text without drawing the boxes.
2117: .NH 2
2118: Draw
2119: .PP
2120: The
2121: .I construct
2122: command may also be used to localize the
2123: effects of opaque boxes.
2124: We saw above how to draw a filled polygon:
2125: paint over the area, then opaque the exterior
2126: of the polygon.
2127: But how can we draw
2128: .I two
2129: filled polygons in the same picture?
2130: .PP
2131: One solution is to
2132: construct them both, then use the
2133: .I draw
2134: command to add them to the main picture.
2135: The
2136: .I draw
2137: command transfers the contents of the
2138: named sheet of tracing paper to the sheet below.
2139: .Ks
2140: .IS
2141: ...libfile circle
2142: ...width 2.0
2143: ...colwid 10.0
2144: null {
2145: }
2146: pentagon {
2147: var center, radius,
2148: pt1, pt2, pt3, pt4, pt5;
2149: pt1 = center + radius;
2150: pt2 = center + cis(72)*radius;
2151: pt3 = center + cis(144)*radius;
2152: pt4 = center + cis(-144)*radius;
2153: pt5 = center + cis(-72)*radius;
2154: conn pt1 to pt2 to pt3 to pt4 to pt5 to pt1;
2155: boundary = pt1, pt2, pt3, pt4, pt5;
2156: }
2157: main {
2158: construct A: null {
2159: conn (0,1) to 0
2160: using 7 brush {
2161: bwd = 1;
2162: bht = 0.1;
2163: }<top,bot>;
2164: put pentagon {
2165: center = (0,0.5);
2166: radius = (0,0.5);
2167: opaque exterior;
2168: };
2169: };
2170: construct B: null {
2171: conn (0.5,0.5) to (1.5,0.5)
2172: using 5 brush {
2173: bwd = (0,1);
2174: bht = 0.1;
2175: }<top,bot>;
2176: put circle {
2177: center = (1,0.5);
2178: radius = 0.5;
2179: opaque exterior;
2180: };
2181: };
2182: draw A;
2183: draw B;
2184: }
2185: .IF
2186: .P1
2187: null {
2188: }
2189:
2190: pentagon {
2191: var center, radius,
2192: pt1, pt2, pt3, pt4, pt5;
2193: pt1 = center + radius;
2194: pt2 = center + cis(72)*radius;
2195: pt3 = center + cis(144)*radius;
2196: pt4 = center + cis(-144)*radius;
2197: pt5 = center + cis(-72)*radius;
2198: conn pt1 to pt2 to pt3 to pt4 to pt5 to pt1;
2199: boundary = pt1, pt2, pt3, pt4, pt5;
2200: }
2201:
2202: main {
2203: construct A: null {
2204: conn (0,1) to 0
2205: using 7 brush {
2206: bwd = 1;
2207: bht = 0.1;
2208: }<top,bot>;
2209: put pentagon {
2210: center = (0,0.5);
2211: radius = (0,0.5);
2212: opaque exterior;
2213: };
2214: };
2215: construct B: null {
2216: conn (0.5,0.5) to (1.5,0.5)
2217: using 5 brush {
2218: bwd = (0,1);
2219: bht = 0.1;
2220: }<top,bot>;
2221: put circle {
2222: center = (1,0.5);
2223: radius = 0.5;
2224: opaque exterior;
2225: };
2226: };
2227: draw A;
2228: draw B;
2229: }
2230: .P2
2231: .Ke
2232: .LP
2233: Even \fIput\fP statements can be added to the parameter sections
2234: of
2235: .I construct
2236: (and \fIput\fP) statements!
2237: Believe it or not, box
2238: .I null
2239: defined above is one of the most useful:
2240: it gives us a way to name a set of commands and variables
2241: so that we may reference them later, yet it doesn't
2242: require us to define a box that will be used only once.
2243: .PP
2244: Given
2245: .I construct
2246: and
2247: .I draw ,
2248: why do we need a special box
2249: .I hole
2250: to opaque a circular area without drawing anything?
2251: Why not just construct an opaque circle, then draw it
2252: on the main picture?
2253: The problem is that the effect of opaquing is localized
2254: just as much as the drawing, so an opaque constructed
2255: circle won't opaque anything that lies underneath.
2256: ........
2257: .NH 1
2258: Library Files
2259: .PP
2260: Library files are available to draw common figures and for special
2261: figures like circles and arcs.
2262: To include a library file as part of an \*(id program,
2263: include the line
2264: .P1
2265: \&...libfile $name$
2266: .P2
2267: in your \*(id program (between the
2268: .CW .IS
2269: and
2270: .CW .IE
2271: lines that mark its
2272: start and end.)
2273: This section describes available library files that have been alluded
2274: to up to now.
2275: .NH 2
2276: Rectangle
2277: .PP
2278: File
2279: .I rect
2280: contains the definition of box
2281: .I rect ,
2282: which looks like the definition in Section 3, with
2283: five more variables: $n$, $s$, $e$, $w$, and $c$,
2284: which are the four compass points and the center,
2285: respectively.
2286: .P1
2287: rect {
2288: var ne, nw, sw, se,
2289: n, e, w, s, c,
2290: ht, wd;
2291: ne = se + (0,1)*ht;
2292: nw = sw + (0,1)*ht;
2293: ne = nw + wd;
2294: n = (ne+nw)/2;
2295: s = (se+sw)/2;
2296: e = (ne+se)/2;
2297: w = (nw+sw)/2;
2298: c = (ne+sw)/2;
2299: ht ~ 1;
2300: wd ~ 1.5;
2301: boundary = ne, nw, sw, se;
2302: conn ne to nw to sw to se to ne;
2303: }
2304: .P2
2305: .NH 2
2306: Arrow
2307: .PP
2308: File
2309: .I arrow
2310: contains the definition of box
2311: .I arrow
2312: as given in Section 3.
2313: .P1
2314: arrow {
2315: var tl, hd, head, perp, headang;
2316: conn tl to hd;
2317: perp = head*(tl-hd)/abs(tl-hd);
2318: conn hd + cis(headang)*perp to hd to hd + cis(-headang)*perp;
2319: head ~ 0.1;
2320: headang ~ 25;
2321: }
2322: .P2
2323: .NH 2
2324: Wavy
2325: .PP
2326: Library file
2327: .I wavy
2328: contains the definition for the familiar
2329: .I wavy .
2330: .P1
2331: wavy {
2332: var start, end, perp, pt1, pt2, ht;
2333: perp = (0,1)*(start - end)/abs(start - end);
2334: pt1 = 0.25[start,end] + perp*ht;
2335: pt2 = 0.75[start,end] - perp*ht;
2336: conn start to pt1 to pt2 to end;
2337: }
2338: .P2
2339: .NH 2
2340: Dash
2341: .PP
2342: Library file
2343: .I dash
2344: contains the definition of box
2345: .I dash ,
2346: which may be useful for drawing dashed lines:
2347: .P1
2348: dash {
2349: var start, end;
2350: conn start to 0.25[start,end];
2351: conn 0.75[start,end] to end;
2352: }
2353: .P2
2354: ..........
2355: .NH 2
2356: Circles
2357: .PP
2358: Box
2359: .I circle
2360: resides in a library file of the same name, and
2361: has the local variables described in Section 3:
2362: $center$, $radius$, $z1$, $z2$, and $z3$.
2363: .Ts
2364: Box
2365: .I circle
2366: actually consists of variable declarations
2367: and a put of box
2368: .I CIRCLE .
2369: So, if you will have many circles of a particular radius,
2370: it might be easier for you to define your own, say, $circle3$:
2371: .P1
2372: ...libfile CIRCLE
2373: circle {
2374: var center, radius, z1, z2, z3;
2375: put CIRCLE {
2376: radius = 3;
2377: }
2378: }
2379: .P2
2380: .Te
2381: .NH 2
2382: Arcs
2383: .PP
2384: Box
2385: .I arc
2386: is contained in a library file of the same name,
2387: with local variables as described in Section 3:
2388: $center$, $radius$, $start$, $midway$, $end$,
2389: $startang$, $midang$, and $endang$.
2390: .Ts
2391: As above,
2392: .I arc
2393: calls on
2394: a box called
2395: .I ARC .
2396: .Te
2397: .NH 1
2398: Examples
2399: .NH 2
2400: B-Trees
2401: .PP
2402: This example depicts a B-tree|reference(btree) whose nodes have many children.
2403: .Ks
2404: .IS
2405: ...colwid 6.0
2406: ...width 3.0
2407: ...libfile rect
2408: arrow {
2409: var tl, hd, headvec, head;
2410: headvec = hd + head*(tl - hd)/abs(tl - hd);
2411: conn tl to hd;
2412: conn hd + cis(20)*(headvec - hd)
2413: to hd
2414: to hd + cis(-20)*(headvec - hd);
2415: }
2416:
2417: dot {
2418: var s, e;
2419: '\(bu' at 0.5[s, e] - (0,0.1);
2420: }
2421:
2422: per {
2423: var s, e;
2424: '.' at 0.5[s, e];
2425: }
2426:
2427: main {
2428: var rw, rh;
2429: rw = 2;
2430: rh = 1;
2431: var hmv, vmv;
2432: hmv = 0.6;
2433: vmv = 0.3;
2434: var ah;
2435: ah = 0.2;
2436: put root:rect{
2437: sw = (0,1);
2438: wd = rw;
2439: ht = 1;
2440: };
2441: put next:rect{
2442: sw = youngest.sw + 2*(hmv, vmv);
2443: wd = rw;
2444: ht = rh;
2445: };
2446: put youngest:rect{
2447: sw = bro.sw + (hmv, vmv);
2448: wd = rw;
2449: ht = rh;
2450: opaque;
2451: };
2452: put bro:rect{
2453: sw = eldest.sw + (hmv, vmv);
2454: wd = rw;
2455: ht = rh;
2456: opaque;
2457: };
2458: put eldest:rect{
2459: im(nw) = im(3[root.nw,root.sw]);
2460: re(0.5[nw, next.nw]) = re(0.5[root.nw, root.ne]);
2461: wd = rw;
2462: ht = rh;
2463: opaque;
2464: put arrow{
2465: head = ah;
2466: tl = 0.0[sw, se] + 0.5 * (nw - sw);
2467: hd = tl - (0, 1) * cis(-27);
2468: };
2469: put arrow{
2470: head = ah;
2471: tl = 0.33[sw, se] + 0.5 * (nw -sw);
2472: hd = tl - (0,1) * cis(-9);
2473: };
2474: put arrow{
2475: head = ah;
2476: tl = 0.67[sw, se] + 0.5 * (nw - sw);
2477: hd = tl - (0,1) * cis(9);
2478: };
2479: put arrow{
2480: head = ah;
2481: tl = 1.0[sw, se] + 0.5 * (nw -sw);
2482: hd = tl - (0,1) * cis(27);
2483: };
2484: };
2485: put arrow{
2486: head = ah;
2487: tl=root.sw + 0.5 * (root.nw - root.sw);
2488: hd=eldest.nw;
2489: };
2490: put arrow{
2491: head = ah;
2492: tl=0.1[root.sw,root.se] + 0.5 * (root.nw - root.sw);
2493: hd=bro.nw;
2494: };
2495: put a:arrow{
2496: head = ah;
2497: tl=0.2[root.sw,root.se] + 0.5 * (root.nw - root.sw);
2498: hd=youngest.nw;
2499: };
2500: put b:arrow{
2501: head = ah;
2502: tl = 0.5[root.ne, root.se];
2503: hd = next.nw;
2504: };
2505: put arrow{
2506: head = ah;
2507: hd = root.nw;
2508: tl = 0.5[root.nw, root.ne] + (0, 1.0);
2509: };
2510: conn next.nw to youngest.nw using 3 dot{}<s, e>;
2511: conn next.se to youngest.se using 3 dot{}<s, e>;
2512: conn b.tl to a.tl using 4 per{}<s, e>;
2513: }
2514: .IE
2515: .Ke
2516: .P1
2517: \&...libfile rect
2518: arrow {
2519: var tl, hd, headvec, head;
2520: headvec = hd + head*(tl - hd)/abs(tl - hd);
2521: conn tl to hd;
2522: conn hd + cis(20)*(headvec - hd)
2523: to hd
2524: to hd + cis(-20)*(headvec - hd);
2525: }
2526:
2527: dot {
2528: var s, e;
2529: '\e(bu' at 0.5[s, e] - (0,0.1);
2530: }
2531:
2532: per {
2533: var s, e;
2534: '.' at 0.5[s, e];
2535: }
2536:
2537: main {
2538: var rw, rh;
2539: rw = 2;
2540: rh = 1;
2541: var hmv, vmv;
2542: hmv = 0.6;
2543: vmv = 0.3;
2544: var ah;
2545: ah = 0.2;
2546: put root: rect {
2547: sw = (0,1);
2548: wd = rw;
2549: ht = 1;
2550: };
2551: put next: rect {
2552: sw = youngest.sw + 2*(hmv, vmv);
2553: wd = rw;
2554: ht = rh;
2555: };
2556: put youngest: rect {
2557: sw = bro.sw + (hmv, vmv);
2558: wd = rw;
2559: ht = rh;
2560: opaque;
2561: };
2562: put bro: rect {
2563: sw = eldest.sw + (hmv, vmv);
2564: wd = rw;
2565: ht = rh;
2566: opaque;
2567: };
2568: put eldest: rect {
2569: im(nw) = im(3[root.nw,root.sw]);
2570: re(0.5[nw, next.nw]) = re(0.5[root.nw, root.ne]);
2571: wd = rw;
2572: ht = rh;
2573: opaque;
2574: put arrow {
2575: head = ah;
2576: tl = 0.0[sw, se] + 0.5 * (nw - sw);
2577: hd = tl - (0, 1) * cis(-27);
2578: };
2579: put arrow {
2580: head = ah;
2581: tl = 0.33[sw, se] + 0.5 * (nw -sw);
2582: hd = tl - (0,1) * cis(-9);
2583: };
2584: put arrow {
2585: head = ah;
2586: tl = 0.67[sw, se] + 0.5 * (nw - sw);
2587: hd = tl - (0,1) * cis(9);
2588: };
2589: put arrow {
2590: head = ah;
2591: tl = 1.0[sw, se] + 0.5 * (nw -sw);
2592: hd = tl - (0,1) * cis(27);
2593: };
2594: };
2595: put arrow {
2596: head = ah;
2597: tl=root.sw + 0.5 * (root.nw - root.sw);
2598: hd=eldest.nw;
2599: };
2600: put arrow {
2601: head = ah;
2602: tl=0.1[root.sw,root.se] + 0.5 * (root.nw - root.sw);
2603: hd=bro.nw;
2604: };
2605: put a: arrow {
2606: head = ah;
2607: tl=0.2[root.sw,root.se] + 0.5 * (root.nw - root.sw);
2608: hd=youngest.nw;
2609: };
2610: put b: arrow {
2611: head = ah;
2612: tl = 0.5[root.ne, root.se];
2613: hd = next.nw;
2614: };
2615: put arrow {
2616: head = ah;
2617: hd = root.nw;
2618: tl = 0.5[root.nw, root.ne] + (0, 1.0);
2619: };
2620: conn next.nw to youngest.nw using 3 dot{}<s, e>;
2621: conn next.se to youngest.se using 3 dot{}<s, e>;
2622: conn b.tl to a.tl using 4 per{}<s, e>;
2623: }
2624: .P2
2625: .NH 2
2626: A Sector Grid
2627: .PP
2628: Norm Schryer used this figure to show how numerical integration
2629: is used to find the area of planar regions.
2630: .Ks
2631: .IS
2632: ...colwid 8.0
2633: ...width 2.0
2634: ...libfile hole
2635: gridline {
2636: var a,b;
2637: var neg, pos;
2638: conn a - neg to a + pos;
2639: }
2640:
2641: main {
2642: var n;
2643: n = 21;
2644: conn (0,0) to (0,1+1/(n-1)) using n gridline {neg = 0; pos = 1;} <a,b>;
2645: conn (0,0) to (1+1/(n-1),0) using n gridline {neg = 0; pos = (0,1);} <a,b>;
2646: put hole {
2647: radius = 1;
2648: center = (0,0);
2649: opaque exterior;
2650: };
2651: }
2652: .IF
2653: .P1
2654:
2655:
2656:
2657:
2658:
2659: \&...libfile hole
2660: gridline {
2661: var a,b;
2662: var neg, pos;
2663: conn a - neg to a + pos;
2664: }
2665:
2666: main {
2667: var n;
2668: n = 21;
2669: conn (0,0) to (0,1+1/(n-1))
2670: using n gridline {
2671: neg = 0;
2672: pos = 1;
2673: } <a,b>;
2674: conn (0,0) to (1+1/(n-1),0)
2675: using n gridline {
2676: neg = 0;
2677: pos = (0,1);
2678: } <a,b>;
2679: put hole {
2680: radius = 1;
2681: center = (0,0);
2682: opaque exterior;
2683: };
2684: }
2685: .P2
2686: .Ke
2687: .NH 2
2688: Polygon Clipping
2689: .PP
2690: This example from |reference(pavlidis image processing)
2691: illustrates all possible positions of a line
2692: segment with respect to a polygon.
2693: .Ks
2694: .ps 8
2695: .EQ
2696: delim $$
2697: gsize 8
2698: define P12 " P sub 1 ( P sub 2 ) "
2699: define P21 " P sub 2 ( P sub 1 )"
2700: .EN
2701: .IS
2702: ...width 4.5
2703: ...colwid 6.0
2704: ...libfile circle
2705: box spot{
2706: var loc;
2707: put circle{
2708: var center, radius;
2709: center = loc;
2710: radius = 0.02;
2711: opaque;
2712: };
2713: }
2714: box vert{
2715: var midd, llength;
2716: conn midd+llength to midd-llength;
2717: }
2718: box poly{
2719: var c1,p1,p2,p3,p4,p5,r1,tp,bp,ta,tb;
2720: p1 = c1+r1;
2721: p2 = cis(65)[c1,p1];
2722: p3 = cis(170)[c1,p1];
2723: p4 = cis(190)[c1,p1];
2724: p5 = cis(300)[c1,p1];
2725: tp = c1+(0,ta)*r1;
2726: bp = c1+(0,tb)*r1;
2727: conn p1 to p2;
2728: conn p2 to p3;
2729: conn p3 to p4;
2730: conn p4 to p5;
2731: conn p5 to p1;
2732: put vert{ midd=c1; llength=(0,1.6)*r1; };
2733: put spot{ loc=tp; };
2734: put spot{ loc=bp; };
2735: left '$P12$' at tp+0.1;
2736: left '$P21$' at bp+0.1;
2737: }
2738: ...minx -1
2739: ...maxx 6
2740: ...miny -1
2741: ...maxy 12
2742: box main {
2743: put poly{
2744: c1 =(1,9); r1 = (1,0); ta=1.1; tb=1.4;
2745: left '$++--$' at p2-1.5;
2746: right '(a)' at c1-(0.7,1.2);
2747: };
2748: put poly{
2749: c1 =(3.5,9); r1 = (1,0); ta=1.1; tb=0.2;
2750: left '$+---$' at p2+0.5;
2751: left '$(-+--)$' at p2+(0.5,-0.15);
2752: right '(b)(b1)' at c1-(0.7,1.2);
2753: };
2754: put poly{
2755: c1 =(1,5); r1 = (1,0); ta=1.1; tb=-1;
2756: left '$+--+$' at p2-1.5;
2757: left '$(-++-)$' at p2-(1.5,0.15);
2758: right '(c)(c1)' at c1-(0.7,1.2);
2759: };
2760: put poly{
2761: c1 =(3.5,5); r1 = (1,0); ta=0.2; tb=-1;
2762: left '$---+$' at p2+(0.5,-0.3);
2763: left '$(--+-)$' at p2+(0.5,-0.45);
2764: right '(d)(d1)' at c1-(0.7,1.2);
2765: };
2766: put poly{
2767: c1 =(1,1); r1 = (1,0); ta=-1; tb=-1.4;
2768: left '$--++$' at p4-(0,0.5);
2769: right '(e)' at c1-(0.7,1.2);
2770: };
2771: put poly{
2772: c1 =(3.5,1); r1 = (1,0); ta=0.2; tb=-0.2;
2773: left '$----$' at p1+0.2;
2774: right '(f)' at c1-(0.7,1.2);
2775: };
2776: }
2777: .IE
2778: .Ke
2779: .ps
2780: .P1
2781: \&.ps 8
2782: .EQ
2783: delim off
2784: .EN
2785: \&.EQ
2786: gsize 8
2787: define P12 " P sub 1 ( P sub 2 ) "
2788: define P21 " P sub 2 ( P sub 1 )"
2789: \&.EN
2790: \&...libfile circle
2791: \&...minx -1
2792: \&...maxx 6
2793: \&...miny -1
2794: \&...maxy 12
2795: box spot{
2796: var loc;
2797: put circle{
2798: var center, radius;
2799: center = loc;
2800: radius = 0.02;
2801: opaque;
2802: };
2803: }
2804: box vert{
2805: var midd, llength;
2806: conn midd+llength to midd-llength;
2807: }
2808: box poly{
2809: var c1,p1,p2,p3,p4,p5,r1,tp,bp,ta,tb;
2810: p1 = c1+r1;
2811: p2 = cis(65)[c1,p1];
2812: p3 = cis(170)[c1,p1];
2813: p4 = cis(190)[c1,p1];
2814: p5 = cis(300)[c1,p1];
2815: tp = c1+(0,ta)*r1;
2816: bp = c1+(0,tb)*r1;
2817: conn p1 to p2;
2818: conn p2 to p3;
2819: conn p3 to p4;
2820: conn p4 to p5;
2821: conn p5 to p1;
2822: put vert{ midd=c1; llength=(0,1.6)*r1; };
2823: put spot{ loc=tp; };
2824: put spot{ loc=bp; };
2825: left '$P12$' at tp+0.1;
2826: left '$P21$' at bp+0.1;
2827: }
2828: box main {
2829: put poly{
2830: c1 =(1,9); r1 = (1,0); ta=1.1; tb=1.4;
2831: left '$++--$' at p2-1.5;
2832: right '(a)' at c1-(0.7,1.2);
2833: };
2834: put poly{
2835: c1 =(3.5,9); r1 = (1,0); ta=1.1; tb=0.2;
2836: left '$+---$' at p2+0.5;
2837: left '$(-+--)$' at p2+(0.5,-0.15);
2838: right '(b)(b1)' at c1-(0.7,1.2);
2839: };
2840: put poly{
2841: c1 =(1,5); r1 = (1,0); ta=1.1; tb=-1;
2842: left '$+--+$' at p2-1.5;
2843: left '$(-++-)$' at p2-(1.5,0.15);
2844: right '(c)(c1)' at c1-(0.7,1.2);
2845: };
2846: put poly{
2847: c1 =(3.5,5); r1 = (1,0); ta=0.2; tb=-1;
2848: left '$---+$' at p2+(0.5,-0.3);
2849: left '$(--+-)$' at p2+(0.5,-0.45);
2850: right '(d)(d1)' at c1-(0.7,1.2);
2851: };
2852: put poly{
2853: c1 =(1,1); r1 = (1,0); ta=-1; tb=-1.4;
2854: left '$--++$' at p4-(0,0.5);
2855: right '(e)' at c1-(0.7,1.2);
2856: };
2857: put poly{
2858: c1 =(3.5,1); r1 = (1,0); ta=0.2; tb=-0.2;
2859: left '$----$' at p1+0.2;
2860: right '(f)' at c1-(0.7,1.2);
2861: };
2862: }
2863: .P2
2864: .NH 1
2865: Acknowledgements
2866: .PP
2867: My thanks to all who read drafts of this manual and
2868: criticized constructively:
2869: Al Aho,
2870: Lorinda Cherry,
2871: Eric Grosse,
2872: Steve Johnson,
2873: Brian Kernighan,
2874: John Mashey,
2875: Doug McIlroy,
2876: and
2877: Theo Pavlidis;
2878: and to early users of \*(id, especially
2879: Eric Grosse,
2880: Theo Pavlidis,
2881: Norm Schryer,
2882: and
2883: Peter Weinberger.
2884: .NH 1
2885: References
2886: .LP
2887: |reference_placement
2888: .FC
2889: .BP
2890: .2C
2891: .EQ
2892: delim $$
2893: gsize 10
2894: .EN
2895: .........
2896: .NH 1
2897: Ideal Reference Manual
2898: .PP
2899: .I Ideal
2900: programs are usually interpolated into
2901: .I troff
2902: input files.
2903: .Tm .IF S
2904: Each program must be preceded by a
2905: .CW .IS
2906: line, and followed by
2907: either a
2908: .CW .IE
2909: line or a
2910: .CW .IF
2911: line.
2912: The
2913: .CW .IE
2914: line directs that further text will
2915: follow the picture, while the
2916: .CW .IF
2917: line leaves the current
2918: position as it was when the
2919: .CW .IS
2920: line was encountered.
2921: .PP
2922: In this description, italicized names refer to nonterminal grammar symbols.
2923: A parenthesized construct followed by a star means zero or
2924: more repetitions of the construct within.
2925: Comments may appear in \*(id programs between
2926: .CW /*
2927: and
2928: .CW */
2929: brackets
2930: (which nest), and between
2931: .CW #
2932: and newline.
2933: .NH 2
2934: Elements of the \*(id Language
2935: .PP
2936: .I Ideal
2937: expects to be presented with a collection of boxes.
2938: .I Ideal
2939: prepares instructions to draw the picture specified by box
2940: .I main .
2941: If no such box exists, no picture is drawn, but the definitions
2942: that did appear are remembered.
2943: A box looks like this:
2944: .P1
2945: $identifier$ {
2946: $(statement)*$
2947: }
2948: .P2
2949: .LP
2950: The sections below describe allowed statements.
2951: An $identifier$ is a sequence of letters and digits that starts with a letter.
2952: A $string$ is a sequence of characters between double quotes.
2953: .NH 3
2954: Variable Declarations
2955: .P1
2956: var $identifier$ $( font CW "," identifier)*$ ;
2957: .P2
2958: .PP
2959: This declares complex variables for which space will be allocated whenever
2960: the box in which this statement appears is instantiated.
2961: These declarations should appear before any other statements,
2962: though this order is not enforced at the moment.
2963: .NH 3
2964: Equations
2965: .P1
2966: $expr$ = $expr$ $( ~ font CW "=" ~ expr)*$ ;
2967: $expr$ ~ $expr$ $( ~ font CW "~" ~ expr)*$ ;
2968: .P2
2969: .PP
2970: These statements declare relations that should exist among the named variables.
2971: Equations that involve more than two expressions to be equated are processed left to right.
2972: The second form (an equation with a
2973: .CW ~
2974: instead of an equals sign)
2975: requests that no error message be generated if the equation is inconsistent.
2976: Built-in operators include
2977: .CW + ,
2978: .CW -
2979: (both unary and binary),
2980: .CW * ,
2981: and
2982: .CW / ,
2983: with unary minus binding more tightly than multiplication
2984: and division, which in turn bind more tightly than addition or subtraction.
2985: Parentheses may be used to enforce a particular order of evaluation.
2986: The expression
2987: .P1
2988: ( $expr sub 1$ , $expr sub 2$ )
2989: .P2
2990: .LP
2991: has as real part the real part of $expr sub 1$ and as imaginary
2992: part the real part of $expr sub 2$.
2993: (The parentheses in this example are not metacharacters.)
2994: The expression
2995: .P1
2996: $expr sub 1$ [ $expr sub 2$ , $expr sub 3$ ]
2997: .P2
2998: .LP
2999: is evaluated as $expr sub 2 + expr sub 1 * ( expr sub 3 - expr sub 2 )$,
3000: that is
3001: ``$expr sub 1$ of the way from $expr sub 2$ to $expr sub 3$.''
3002: Built-in functions are described below.
3003: .NH 4
3004: Manipulating Complex Numbers
3005: .P1
3006: re ( $expr$ )
3007: im ( $expr$ )
3008: conj ( $expr$ )
3009: .P2
3010: .PP
3011: These functions return, respectively, the real part, the imaginary part,
3012: and the complex conjugate of $expr$.
3013: .NH 4
3014: Absolute Value
3015: .P1
3016: abs ( $expr$ )
3017: .P2
3018: .PP
3019: This returns the absolute value of $expr$.
3020: .NH 4
3021: Unit Vector Functions
3022: .P1
3023: cis ( $expr$ )
3024: E ( $expr$ )
3025: unit ( $expr$ )
3026: .P2
3027: .PP
3028: Function $font CW "cis" ()$ returns a unit vector in the direction
3029: of its argument,
3030: which is interpreted as an angle.
3031: For $theta$ in radians, $font CW "cis" ~ theta$ is defined as
3032: $e sup { i theta } ~ == ~ cos ~ theta ~ + ~ i sin ~ theta$,
3033: and
3034: $font CW "E" (x)$ is defined as $font CW "cis" ~ 2 pi x$.
3035: If $theta$ is in degrees, which it usually is in
3036: .I ideal
3037: programs (see below),
3038: .I ideal
3039: makes the necessary conversion
3040: so that $font CW "cis" ()$ and $font CW "E" ()$ work right.
3041: .PP
3042: Function $font CW "unit" ()$ returns a unit vector in the direction
3043: of its argument,
3044: which is a vector.
3045: For $z$ a complex number,
3046: $font CW "unit" (z) ~ == ~ z / font CW "abs" (z)$.
3047: .NH 4
3048: Floating Truncation
3049: .P1
3050: int ( $expr$ )
3051: .P2
3052: .PP
3053: This function returns the integer part of the real part of $expr$.
3054: .NH 4
3055: Inverse Trigonometric Function
3056: .P1
3057: angle ( $expr$ )
3058: .P2
3059: .PP
3060: This function returns the arctangent of $font CW "im" (expr)/ font CW "re" (expr)$.
3061: .NH 3
3062: Square Root Function
3063: .P1
3064: sqrt ( $expr$ )
3065: .P2
3066: .PP
3067: This function returns the square root of its complex argument.
3068: .NH 3
3069: Line Drawing
3070: .P1
3071: conn $expr$ to $expr$ $($ to $~ expr)*$ ;
3072: .P2
3073: .PP
3074: This statement directs that lines be drawn between each successive
3075: pair of points.
3076: .NH 3
3077: Box Placement
3078: .P1
3079: $[ident sub 1 font CW ":" ]$ put $ident sub 2$ { $(statement)*$ } ;
3080: put $ident sub 1$ : $ident sub 2$ { $(statement)*$ } ;
3081: .P2
3082: .PP
3083: This statement directs that box $ident sub 2$ be instantiated with the
3084: statements in braces prepended to those already present in its definition.
3085: If $ident sub 1$ is present in the statement (the optional first form,
3086: or the second form), the instantiated box's name is $ident sub 1$,
3087: and a local variable $x$ of the box may be referenced as $ident sub 1$.$x$.
3088: .NH 3
3089: Pen Drawing
3090: .P1
3091: conn $expr sub 1$ to $expr sub 2$ using $expr sub 3$
3092: $identifier$ { $(statement)*$ }
3093: < $expr sub 4$ , $expr sub 5$ > ;
3094: .P2
3095: .PP
3096: This statement is shorthand for the following loop:
3097: .P1 0
3098: for i = 1 to $expr sub 3$ by 1
3099: put $identifier$ {
3100: $expr sub 4$ = ((i-1)/$expr sub 3$)
3101: [$expr sub 1$,$expr sub 2$];
3102: $expr sub 5$ = (i/$expr sub 3$)
3103: [$expr sub 1$,$expr sub 2$];
3104: $(statement)*$
3105: };
3106: .P2
3107: .LP
3108: Note that it is different from mere text expansion because the upper limit
3109: ($expr sub 3$) may not be known explicitly when the program is written.
3110: Note too that \*(id does
3111: .I not
3112: include a for-statement!
3113: .NH 3
3114: Drawing Splines
3115: .P1
3116: spline $expr$ to $expr$ $( font CW "to" ~ expr)*$ ;
3117: .P2
3118: .PP
3119: This statement draws a spline guided by the named points in order.
3120: .NH 3
3121: Placing Captions
3122: .P1
3123: left $string$ at $expr$;
3124: $string$ at $expr$;
3125: right $string$ at $expr$;
3126: .P2
3127: .PP
3128: Use these statements to place $string$ at $expr$.
3129: The default is to center the string at $expr$.
3130: The keyword $"left"$ causes the string to start at $expr$,
3131: while the keyword $"right"$ causes the string to end there.
3132: .NH 3
3133: Constructing and Drawing Boxes
3134: .P1
3135: construct $ident sub 1$ :
3136: $ident sub 2$ { $(statement)*$ } ;
3137: $ident sub 1$ : construct
3138: $ident sub 2$ { $(statement)*$ } ;
3139: draw $identifier$ ;
3140: .P2
3141: .PP
3142: The first two of these statements are like the $put$ statements defined above,
3143: but they add to a picture named $ident sub 1$, instead of to the current picture.
3144: The third directs that the named picture (created by a $construct$ command)
3145: be added to the current picture.
3146: .NH 3
3147: Statements Related to Opaquing
3148: .P1
3149: boundary = $expr$ , $expr$ $( font CW "," expr)+$ ;
3150: opaque [ interior ] ;
3151: opaque exterior ;
3152: .P2
3153: .PP
3154: The $boundary$ statement specifies the vertices of a polygon
3155: to be opaqued.
3156: The first $opaque$ statement directs that the interior of the polygon
3157: be opaque.
3158: The second directs that the exterior be made opaque.
3159: If no boundary list is given for a circle, it will opaque a
3160: circular region.
3161: To get an opaque circular region without drawing the circle,
3162: use the box $hole$ instead.
3163: Two other boxes are available for opaquing: $sector$ opaques
3164: a sector of an arc and $segment$ opaques a segment of an arc.
3165: The variables in these boxes are the same as in $arc$.
3166: .NH 2
3167: Command-Line Options
3168: .PP
3169: These options may appear on the command line.
3170: .NH 3
3171: Selecting the Postprocessor
3172: .IP
3173: .CW -p
3174: .br
3175: .CW -4
3176: .br
3177: .CW -n
3178: .PP
3179: .I Ideal
3180: usually prepares output for processing by
3181: .I troff ;
3182: all output dimensions are expressed in inches so that
3183: .I troff
3184: can do the appropriate thing for any typesetter.
3185: The
3186: .CW -p
3187: option directs that the output be generic
3188: .I plot
3189: output.
3190: The
3191: .CW -4
3192: option causes the output to appear on the screen of a 4014.
3193: Both options cause a screen erase at each
3194: .CW .IS ,
3195: but only the
3196: .CW -4
3197: option causes a pause for input at each
3198: .CW .IE .
3199: The screen erase at
3200: .CW .IS
3201: lines may be suppressed by including the line
3202: .P1
3203: \&...noerase
3204: .P2
3205: and may be restored by the line
3206: .P1
3207: \&...yeserase
3208: .P2
3209: Option
3210: .CW -n
3211: directs that the raw
3212: .I ideal
3213: output remain uninterpreted,
3214: so it can be run through
3215: .I nroff
3216: without harm.
3217: .........
3218: .NH 3
3219: Quality Option
3220: .IP
3221: .CW -q
3222: .PP
3223: When
3224: .I ideal
3225: is used to prepare figures for typeset text,
3226: one has a choice of how to draw horizontal and vertical lines.
3227: Without the
3228: .CW -q
3229: option,
3230: .I ideal
3231: uses rule characters,
3232: which draw the lines fast, but may not be accurate.
3233: Giving the
3234: .CW -q
3235: option causes
3236: .I ideal
3237: to draw all lines,
3238: including horizontal and vertical lines, using dots;
3239: this takes longer, but is more accurate.
3240: .NH 3
3241: Angle Processing
3242: .IP
3243: .CW -r
3244: .PP
3245: .I Ideal
3246: expects angles in degrees.
3247: The
3248: .CW -r
3249: option causes
3250: .I ideal
3251: to expect them in radians instead.
3252: (See also the section on Angle Processing as a command to
3253: .I ideal ,
3254: below.)
3255: .NH 3
3256: Including Library Files
3257: .IP
3258: .CW -l\fIlibfile\fP
3259: .PP
3260: This causes
3261: .I ideal
3262: to read the named library file before it begins processing
3263: the input files or the standard input.
3264: (See also the section on Including Library Files as a command to
3265: .I ideal ,
3266: below.)
3267: .NH 2
3268: Commands to Control
3269: .I Ideal
3270: Processing
3271: .PP
3272: These commands affect decisions that must be made during the processing of
3273: an
3274: .I ideal
3275: program.
3276: They should appear after the
3277: .CW .IS
3278: delimiter,
3279: each on a separate line beginning with three dots.
3280: .NH 3
3281: Forgetting a Box
3282: .P1
3283: \&...forget $(boxname)*$
3284: .P2
3285: .PP
3286: All box definitions except the definition of $main$ survive across
3287: .CW .IS\fR/\fP.IE
3288: boundaries.
3289: If you won't need a box again, and memory space is tight, you can
3290: use the $forget$ command to reclaim the space its definition requires.
3291: Because of implementation deficiencies, at most five names of boxes may
3292: appear on one $forget$ line.
3293: There is no way to remember the $main$.
3294: .NH 3
3295: Angle Processing
3296: .P1
3297: \&...degrees
3298: .P2
3299: .P1
3300: \&...radians
3301: .P2
3302: .PP
3303: .I Ideal
3304: expects angles (arguments to $roman "cis"$
3305: and the result of $angle$)
3306: to appear in degrees,
3307: unless it was invoked with the
3308: .CW -r
3309: option on the command line,
3310: in which case it expects angles in radians.
3311: These two commands may be used to switch back and forth between
3312: degrees and radians.
3313: Only one convention may be used within a single
3314: .I ideal
3315: program,
3316: that is between
3317: .CW .IS
3318: and
3319: .CW .IE .
3320: .NH 3
3321: Including Files
3322: .P1
3323: \&...libfile $(file)*$
3324: \&...include $(file)*$
3325: .P2
3326: .PP
3327: The first command directs that the named library files be interpolated so
3328: that their box definitions may be used.
3329: The second is a way to include one's own files.
3330: The following library files are available:
3331: .I arc ,
3332: .I arrow ,
3333: .I circle ,
3334: .I dash ,
3335: .I rect ,
3336: and
3337: .I wavy.
3338: .NH 2
3339: Commands to the Postprocessor
3340: .PP
3341: Each of these commands must appear
3342: between the
3343: .CW .IS
3344: and
3345: .CW .IE
3346: delimiters
3347: on a separate line that begins with
3348: three dots.
3349: .NH 3
3350: Defining the Bounding Box
3351: .P1
3352: \&...minx $number$
3353: \&...miny $number$
3354: \&...maxx $number$
3355: \&...maxy $number$
3356: .P2
3357: .PP
3358: The
3359: .I ideal
3360: processor computes the minimum and maximum extent of the
3361: picture in both $x$- and $y$-directions so that the bounding box
3362: (hence, the picture) can be scaled to the desired width.
3363: These commands allow you to override
3364: .I ideal 's
3365: computed bounding box.
3366: They are useful when the computed bounding box is too large or too small.
3367: .I Ideal
3368: cannot compute the bounding box of a string, so it doesn't try,
3369: and this may be too liberal.
3370: .PP
3371: Normally these dimensions are computed anew for each picture produced
3372: by
3373: .I ideal .
3374: Use the line
3375: .P1
3376: \&...obbox
3377: .P2
3378: between subsequent
3379: .CW .IS
3380: and
3381: .CW .IE\fR/\fP.IF
3382: lines to keep the
3383: bounding box of the previous picture.
3384: .NH 3
3385: Setting the Picture Width
3386: .P1
3387: \&...width $number$
3388: .P2
3389: .PP
3390: This command causes the bounding box to be scaled to a width of $number$
3391: inches.
3392: (If not specified, the default is four inches.)
3393: It persists across
3394: .CW .IS\fR/\fP.IE
3395: boundaries.
3396: .NH 3
3397: Setting the Picture Height
3398: .P1
3399: \&...height $number$
3400: .P2
3401: .PP
3402: This command causes the bounding box to be scaled to a height of $number$
3403: inches.
3404: This allows one to impose a different scale on the horizontal and vertical
3405: dimensions of a picture.
3406: The setting persists across
3407: .CW .IS\fR/\fP.IE
3408: boundaries.
3409: ........
3410: .NH 3
3411: Setting the Column Width
3412: .P1
3413: \&...colwid $number$
3414: .P2
3415: .PP
3416: This command gives the width of the column in which the picture will appear
3417: so that it can be centered in the column.
3418: (If not specified, the default is six inches.)
3419: The setting persists across
3420: .CW .IS\fR/\fP.IE
3421: boundaries.
3422: .NH 3
3423: Using Postprocessor Commands to Scale Pictures
3424: .PP
3425: The bounding box and width information can be adjusted
3426: to scale the picture or move it on the page.
3427: .I Ideal
3428: does not check that the entire picture is in fact
3429: contained in the bounding box, and it cannot check
3430: that the column width is correct:
3431: it uses the bounding box information to scale the
3432: picture to the width requested,
3433: then uses the column width to center the bounding box.
3434: .PP
3435: For example, to produce figures at the right of the
3436: page,
3437: .I ideal
3438: was told that the column was nine inches wide.
3439: Since the pictures are typically no more than two inches
3440: wide, they lie within the actual six inch column.
3441: .PP
3442: Suppose one's
3443: figures are drawn in the unit square,
3444: though some pieces lie a little outside,
3445: and one wants one inch to correspond to one in \*(id's
3446: coordinate system.
3447: One could set the six parameters as follows:
3448: .P1
3449: \&...minx 0
3450: \&...miny 0
3451: \&...maxx 1
3452: \&...maxy 1
3453: \&...width 1
3454: \&...colwid 6
3455: .P2
3456: .LP
3457: This gives a way for
3458: users to get exact scale
3459: representations of their pictures.
3460: .NH 2
3461: Obsolete Features
3462: .PP
3463: These holdovers from earlier implementations are not guaranteed to survive.
3464: .NH 3
3465: Options on the
3466: .CW .IS
3467: Line
3468: .PP
3469: One could specify the bounding box on the
3470: .CW .IS
3471: line by
3472: .P1
3473: \&.IS minx maxy maxx miny
3474: .P2
3475: .LP
3476: The bounding box commands to the postprocessor are now preferred.
3477: .NH 3
3478: Changes to Keywords
3479: .PP
3480: The keyword $box$ used to be required before a box definition.
3481: .PP
3482: The keyword $boundary$ has replaced $bdlist$.
3483: .PP
3484: The function $angle$ used to be called $atan2$.
3485: .NH 3
3486: String Delimiters
3487: .PP
3488: Strings used to be delimited by single quotes.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.