1 /* Last non-groff version: hgraph.c 1.14 (Berkeley) 84/11/27
3 * This file contains the graphics routines for converting gremlin pictures
11 #ifdef NEED_DECLARATION_HYPOT
13 double hypot(double, double);
15 #endif /* NEED_DECLARATION_HYPOT */
20 #define PointsPerInterval 64
21 #define pi 3.14159265358979324
22 #define twopi (2.0 * pi)
23 #define len(a, b) hypot((double)(b.x-a.x), (double)(b.y-a.y))
26 extern int dotshifter
; /* for the length of dotted curves */
28 extern int style
[]; /* line and character styles */
29 extern double thick
[];
32 extern int stipple_index
[]; /* stipple font index for stipples 0 - 16 */
33 extern char *stipple
; /* stipple type (cf or ug) */
36 extern double troffscale
; /* imports from main.c */
37 extern double linethickness
;
56 void HGSetFont(int font
, int size
);
57 void HGPutText(int justify
, POINT pnt
, register char *string
);
58 void HGSetBrush(int mode
);
59 void tmove2(int px
, int py
);
60 void doarc(POINT cp
, POINT sp
, int angle
);
61 void tmove(POINT
* ptr
);
63 void drawwig(POINT
* ptr
, int type
);
64 void HGtline(int x1
, int y1
);
67 void HGArc(register int cx
, register int cy
, int px
, int py
, int angle
);
68 void picurve(register int *x
, register int *y
, int npts
);
69 void HGCurve(int *x
, int *y
, int numpoints
);
70 void Paramaterize(int x
[], int y
[], float h
[], int n
);
71 void PeriodicSpline(float h
[], int z
[],
72 float dz
[], float d2z
[], float d3z
[],
74 void NaturalEndSpline(float h
[], int z
[],
75 float dz
[], float d2z
[], float d3z
[],
80 /*----------------------------------------------------------------------------*
81 | Routine: HGPrintElt (element_pointer, baseline)
83 | Results: Examines a picture element and calls the appropriate
84 | routine(s) to print them according to their type. After the
85 | picture is drawn, current position is (lastx, lasty).
86 *----------------------------------------------------------------------------*/
89 HGPrintElt(ELT
*element
,
95 register int graylevel
;
97 if (!DBNullelt(element
) && !Nullpoint((p1
= element
->ptlist
))) {
98 /* p1 always has first point */
99 if (TEXT(element
->type
)) {
100 HGSetFont(element
->brushf
, element
->size
);
101 switch (element
->size
) {
117 HGPutText(element
->type
, *p1
, element
->textpt
);
119 if (element
->brushf
) /* if there is a brush, the */
120 HGSetBrush(element
->brushf
); /* graphics need it set */
122 switch (element
->type
) {
125 p2
= PTNextPoint(p1
);
127 doarc(*p1
, *p2
, element
->size
);
132 length
= 0; /* keep track of line length */
138 length
= 0; /* keep track of line length */
139 drawwig(p1
, BSPLINE
);
144 length
= 0; /* keep track of line length so */
145 tmove(p1
); /* single lines don't get long */
146 while (!Nullpoint((p1
= PTNextPoint(p1
)))) {
147 HGtline((int) (p1
->x
* troffscale
),
148 (int) (p1
->y
* troffscale
));
149 if (length
++ > LINELENGTH
) {
159 /* brushf = style of outline; size = color of fill:
160 * on first pass (polyfill=FILL), do the interior using 'P'
162 * on second pass (polyfill=OUTLINE), do the outline using a series
163 * of vectors. It might make more sense to use \D'p ...',
164 * but there is no uniform way to specify a 'fill character'
165 * that prints as 'no fill' on all output devices (and
167 * If polyfill=BOTH, just use the \D'p ...' command.
169 float firstx
= p1
->x
;
170 float firsty
= p1
->y
;
172 length
= 0; /* keep track of line length so */
173 /* single lines don't get long */
175 if (polyfill
== FILL
|| polyfill
== BOTH
) {
176 /* do the interior */
177 char command
= (polyfill
== BOTH
&& element
->brushf
) ? 'p' : 'P';
179 /* include outline, if there is one and */
180 /* the -p flag was set */
182 /* switch based on what gremlin gives */
183 switch (element
->size
) {
208 default: /* who's giving something else? */
209 graylevel
= NSTIPPLES
;
212 /* int graylevel = element->size; */
216 if (graylevel
> NSTIPPLES
)
217 graylevel
= NSTIPPLES
;
218 printf("\\D'f %du'", stipple_index
[graylevel
])
221 printf("\\D'%c", command
);
223 while (!Nullpoint((PTNextPoint(p1
)))) {
224 p1
= PTNextPoint(p1
);
227 if (length
++ > LINELENGTH
) {
233 /* close polygon if not done so by user */
234 if ((firstx
!= p1
->x
) || (firsty
!= p1
->y
)) {
242 /* else polyfill == OUTLINE; only draw the outline */
243 if (!(element
->brushf
))
245 length
= 0; /* keep track of line length */
248 while (!Nullpoint((PTNextPoint(p1
)))) {
249 p1
= PTNextPoint(p1
);
250 HGtline((int) (p1
->x
* troffscale
),
251 (int) (p1
->y
* troffscale
));
252 if (length
++ > LINELENGTH
) {
258 /* close polygon if not done so by user */
259 if ((firstx
!= p1
->x
) || (firsty
!= p1
->y
)) {
260 HGtline((int) (firstx
* troffscale
),
261 (int) (firsty
* troffscale
));
265 } /* end case POLYGON */
267 } /* end else Text */
272 /*----------------------------------------------------------------------------*
273 | Routine: HGPutText (justification, position_point, string)
275 | Results: Given the justification, a point to position with, and a
276 | string to put, HGPutText first sends the string into a
277 | diversion, moves to the positioning point, then outputs
278 | local vertical and horizontal motions as needed to justify
279 | the text. After all motions are done, the diversion is
281 *----------------------------------------------------------------------------*/
284 HGPutText(int justify
,
286 register char *string
)
288 int savelasty
= lasty
; /* vertical motion for text is to be */
289 /* ignored. Save current y here */
291 printf(".nr g8 \\n(.d\n"); /* save current vertical position. */
292 printf(".ds g9 \""); /* define string containing the text. */
293 while (*string
) { /* put out the string */
294 if (*string
== '\\' &&
295 *(string
+ 1) == '\\') { /* one character at a */
296 printf("\\\\\\"); /* time replacing // */
297 string
++; /* by //// to prevent */
298 } /* interpretation at */
299 printf("%c", *(string
++)); /* printout time */
303 tmove(&pnt
); /* move to positioning point */
306 /* local vertical motions */
307 /* (the numbers here are used to be somewhat compatible with gprint) */
311 printf("\\v'0.85n'"); /* down half */
317 printf("\\v'1.7n'"); /* down whole */
321 /* local horizontal motions */
325 printf("\\h'-\\w'\\*(g9'u/2u'"); /* back half */
331 printf("\\h'-\\w'\\*(g9'u'"); /* back whole */
334 printf("\\&\\*(g9\n"); /* now print the text. */
335 printf(".sp |\\n(g8u\n"); /* restore vertical position */
336 lasty
= savelasty
; /* vertical position restored to where it */
337 lastx
= xleft
; /* was before text, also horizontal is at */
339 } /* end HGPutText */
342 /*----------------------------------------------------------------------------*
343 | Routine: doarc (center_point, start_point, angle)
345 | Results: Produces either drawarc command or a drawcircle command
346 | depending on the angle needed to draw through.
347 *----------------------------------------------------------------------------*/
354 if (angle
) /* arc with angle */
355 HGArc((int) (cp
.x
* troffscale
), (int) (cp
.y
* troffscale
),
356 (int) (sp
.x
* troffscale
), (int) (sp
.y
* troffscale
), angle
);
357 else /* a full circle (angle == 0) */
358 HGArc((int) (cp
.x
* troffscale
), (int) (cp
.y
* troffscale
),
359 (int) (sp
.x
* troffscale
), (int) (sp
.y
* troffscale
), 0);
363 /*----------------------------------------------------------------------------*
364 | Routine: HGSetFont (font_number, Point_size)
366 | Results: ALWAYS outputs a .ft and .ps directive to troff. This is
367 | done because someone may change stuff inside a text string.
368 | Changes thickness back to default thickness. Default
369 | thickness depends on font and pointsize.
370 *----------------------------------------------------------------------------*/
377 ".ps %d\n", tfont
[font
- 1], tsize
[size
- 1]);
378 linethickness
= DEFTHICK
;
382 /*----------------------------------------------------------------------------*
383 | Routine: HGSetBrush (line_mode)
385 | Results: Generates the troff commands to set up the line width and
386 | style of subsequent lines. Does nothing if no change is
389 | Side Efct: Sets `linmode' and `linethicknes'.
390 *----------------------------------------------------------------------------*/
395 register int printed
= 0;
397 if (linmod
!= style
[--mode
]) {
398 /* Groff doesn't understand \Ds, so we take it out */
399 /* printf ("\\D's %du'", linmod = style[mode]); */
400 linmod
= style
[mode
];
403 if (linethickness
!= thick
[mode
]) {
404 linethickness
= thick
[mode
];
405 printf("\\h'-%.2fp'\\D't %.2fp'", linethickness
, linethickness
);
413 /*----------------------------------------------------------------------------*
414 | Routine: dx (x_destination)
416 | Results: Scales and outputs a number for delta x (with a leading
417 | space) given `lastx' and x_destination.
419 | Side Efct: Resets `lastx' to x_destination.
420 *----------------------------------------------------------------------------*/
425 register int ix
= (int) (x
* troffscale
);
427 printf(" %du", ix
- lastx
);
432 /*----------------------------------------------------------------------------*
433 | Routine: dy (y_destination)
435 | Results: Scales and outputs a number for delta y (with a leading
436 | space) given `lastyline' and y_destination.
438 | Side Efct: Resets `lastyline' to y_destination. Since `line' vertical
439 | motions don't affect `page' ones, `lasty' isn't updated.
440 *----------------------------------------------------------------------------*/
445 register int iy
= (int) (y
* troffscale
);
447 printf(" %du", iy
- lastyline
);
452 /*----------------------------------------------------------------------------*
453 | Routine: tmove2 (px, py)
455 | Results: Produces horizontal and vertical moves for troff given the
456 | pair of points to move to and knowing the current position.
457 | Also puts out a horizontal move to start the line. This is
458 | a variation without the .sp command.
459 *----------------------------------------------------------------------------*/
468 if ((dy
= py
- lasty
)) {
469 printf("\\v'%du'", dy
);
471 lastyline
= lasty
= py
; /* lasty is always set to current */
472 if ((dx
= px
- lastx
)) {
473 printf("\\h'%du'", dx
);
479 /*----------------------------------------------------------------------------*
480 | Routine: tmove (point_pointer)
482 | Results: Produces horizontal and vertical moves for troff given the
483 | pointer of a point to move to and knowing the current
484 | position. Also puts out a horizontal move to start the
486 *----------------------------------------------------------------------------*/
491 register int ix
= (int) (ptr
->x
* troffscale
);
492 register int iy
= (int) (ptr
->y
* troffscale
);
496 if ((dy
= iy
- lasty
)) {
497 printf(".sp %du\n", dy
);
499 lastyline
= lasty
= iy
; /* lasty is always set to current */
500 if ((dx
= ix
- lastx
)) {
501 printf("\\h'%du'", dx
);
507 /*----------------------------------------------------------------------------*
510 | Results: Ends off an input line. `.sp -1' is also added to counteract
511 | the vertical move done at the end of text lines.
513 | Side Efct: Sets `lastx' to `xleft' for troff's return to left margin.
514 *----------------------------------------------------------------------------*/
519 printf("\n.sp -1\n");
524 /*----------------------------------------------------------------------------*
527 | Results: Draws a single solid line to (x,y).
528 *----------------------------------------------------------------------------*/
535 printf(" %du", px
- lastx
);
536 printf(" %du'", py
- lastyline
);
538 lastyline
= lasty
= py
;
542 /*----------------------------------------------------------------------------
543 | Routine: drawwig (ptr, type)
545 | Results: The point sequence found in the structure pointed by ptr is
546 | placed in integer arrays for further manipulation by the
547 | existing routing. With the corresponding type parameter,
548 | either picurve or HGCurve are called.
549 *----------------------------------------------------------------------------*/
555 register int npts
; /* point list index */
556 int x
[MAXPOINTS
], y
[MAXPOINTS
]; /* point list */
558 for (npts
= 1; !Nullpoint(ptr
); ptr
= PTNextPoint(ptr
), npts
++) {
559 x
[npts
] = (int) (ptr
->x
* troffscale
);
560 y
[npts
] = (int) (ptr
->y
* troffscale
);
563 if (type
== CURVE
) /* Use the 2 different types of curves */
564 HGCurve(&x
[0], &y
[0], npts
);
566 picurve(&x
[0], &y
[0], npts
);
571 /*----------------------------------------------------------------------------
572 | Routine: HGArc (xcenter, ycenter, xstart, ystart, angle)
574 | Results: This routine plots an arc centered about (cx, cy) counter
575 | clockwise starting from the point (px, py) through `angle'
576 | degrees. If angle is 0, a full circle is drawn. It does so
577 | by creating a draw-path around the arc whose density of
578 | points depends on the size of the arc.
579 *----------------------------------------------------------------------------*/
582 HGArc(register int cx
,
588 double xs
, ys
, resolution
, fullcircle
;
595 register double epsilon
;
602 resolution
= (1.0 + hypot(xs
, ys
) / res
) * PointsPerInterval
;
603 /* mask = (1 << (int) log10(resolution + 1.0)) - 1; */
604 (void) frexp(resolution
, &m
); /* A bit more elegant than log10 */
605 for (mask
= 1; mask
< m
; mask
= mask
<< 1);
608 epsilon
= 1.0 / resolution
;
609 fullcircle
= (2.0 * pi
) * resolution
;
611 extent
= (int) fullcircle
;
613 extent
= (int) (angle
* fullcircle
/ 360.0);
616 while (--extent
>= 0) {
618 nx
= cx
+ (int) (xs
+ 0.5);
620 ny
= cy
+ (int) (ys
+ 0.5);
621 if (!(extent
& mask
)) {
622 HGtline(nx
, ny
); /* put out a point on circle */
623 if (length
++ > LINELENGTH
) {
632 /*----------------------------------------------------------------------------
633 | Routine: picurve (xpoints, ypoints, num_of_points)
635 | Results: Draws a curve delimited by (not through) the line segments
636 | traced by (xpoints, ypoints) point list. This is the `Pic'
638 *----------------------------------------------------------------------------*/
641 picurve(register int *x
,
645 register int nseg
; /* effective resolution for each curve */
646 register int xp
; /* current point (and temporary) */
648 int pxp
, pyp
; /* previous point (to make lines from) */
649 int i
; /* inner curve segment traverser */
651 double w
; /* position factor */
652 double t1
, t2
, t3
; /* calculation temps */
654 if (x
[1] == x
[npts
] && y
[1] == y
[npts
]) {
655 x
[0] = x
[npts
- 1]; /* if the lines' ends meet, make */
656 y
[0] = y
[npts
- 1]; /* sure the curve meets */
659 } else { /* otherwise, make the ends of the */
660 x
[0] = x
[1]; /* curve touch the ending points of */
661 y
[0] = y
[1]; /* the line segments */
662 x
[npts
+ 1] = x
[npts
];
663 y
[npts
+ 1] = y
[npts
];
666 pxp
= (x
[0] + x
[1]) / 2; /* make the last point pointers */
667 pyp
= (y
[0] + y
[1]) / 2; /* point to the start of the 1st line */
670 for (; npts
--; x
++, y
++) { /* traverse the line segments */
673 nseg
= (int) hypot((double) xp
, (double) yp
);
676 /* `nseg' is the number of line */
677 /* segments that will be drawn for */
678 /* each curve segment. */
679 nseg
= (int) ((double) (nseg
+ (int) hypot((double) xp
, (double) yp
)) /
680 res
* PointsPerInterval
);
682 for (i
= 1; i
< nseg
; i
++) {
683 w
= (double) i
/ (double) nseg
;
685 t3
= t1
+ 1.0 - (w
+ w
);
686 t2
= 2.0 - (t3
+ t1
);
687 xp
= (((int) (t1
* x
[2] + t2
* x
[1] + t3
* x
[0])) + 1) / 2;
688 yp
= (((int) (t1
* y
[2] + t2
* y
[1] + t3
* y
[0])) + 1) / 2;
691 if (length
++ > LINELENGTH
) {
700 /*----------------------------------------------------------------------------
701 | Routine: HGCurve(xpoints, ypoints, num_points)
703 | Results: This routine generates a smooth curve through a set of
704 | points. The method used is the parametric spline curve on
705 | unit knot mesh described in `Spline Curve Techniques' by
706 | Patrick Baudelaire, Robert Flegal, and Robert Sproull --
708 *----------------------------------------------------------------------------*/
715 float h
[MAXPOINTS
], dx
[MAXPOINTS
], dy
[MAXPOINTS
];
716 float d2x
[MAXPOINTS
], d2y
[MAXPOINTS
], d3x
[MAXPOINTS
], d3y
[MAXPOINTS
];
730 * Solve for derivatives of the curve at each point separately for x and y
733 Paramaterize(x
, y
, h
, numpoints
);
736 if ((x
[1] == x
[numpoints
]) && (y
[1] == y
[numpoints
])) {
737 PeriodicSpline(h
, x
, dx
, d2x
, d3x
, numpoints
);
738 PeriodicSpline(h
, y
, dy
, d2y
, d3y
, numpoints
);
740 NaturalEndSpline(h
, x
, dx
, d2x
, d3x
, numpoints
);
741 NaturalEndSpline(h
, y
, dy
, d2y
, d3y
, numpoints
);
745 * generate the curve using the above information and PointsPerInterval
746 * vectors between each specified knot.
749 for (j
= 1; j
< numpoints
; ++j
) {
750 if ((x
[j
] == x
[j
+ 1]) && (y
[j
] == y
[j
+ 1]))
752 for (k
= 0; k
<= PointsPerInterval
; ++k
) {
753 t
= (float) k
*h
[j
] / (float) PointsPerInterval
;
756 nx
= x
[j
] + (int) (t
* dx
[j
] + t2
* d2x
[j
] / 2 + t3
* d3x
[j
] / 6);
757 ny
= y
[j
] + (int) (t
* dy
[j
] + t2
* d2y
[j
] / 2 + t3
* d3y
[j
] / 6);
759 if (length
++ > LINELENGTH
) {
768 /*----------------------------------------------------------------------------
769 | Routine: Paramaterize (xpoints, ypoints, hparams, num_points)
771 | Results: This routine calculates parameteric values for use in
772 | calculating curves. The parametric values are returned
773 | in the array h. The values are an approximation of
774 | cumulative arc lengths of the curve (uses cord length).
775 | For additional information, see paper cited below.
776 *----------------------------------------------------------------------------*/
779 Paramaterize(int x
[],
790 for (i
= 1; i
<= n
; ++i
) {
792 for (j
= 1; j
< i
; j
++) {
793 dx
= x
[j
+ 1] - x
[j
];
794 dy
= y
[j
+ 1] - y
[j
];
795 /* Here was overflowing, so I changed it. */
796 /* u[i] += sqrt ((double) (dx * dx + dy * dy)); */
797 u
[i
] += hypot((double) dx
, (double) dy
);
800 for (i
= 1; i
< n
; ++i
)
801 h
[i
] = u
[i
+ 1] - u
[i
];
802 } /* end Paramaterize */
805 /*----------------------------------------------------------------------------
806 | Routine: PeriodicSpline (h, z, dz, d2z, d3z, npoints)
808 | Results: This routine solves for the cubic polynomial to fit a spline
809 | curve to the the points specified by the list of values.
810 | The Curve generated is periodic. The algorithms for this
811 | curve are from the `Spline Curve Techniques' paper cited
813 *----------------------------------------------------------------------------*/
816 PeriodicSpline(float h
[], /* paramaterization */
817 int z
[], /* point list */
818 float dz
[], /* to return the 1st derivative */
819 float d2z
[], /* 2nd derivative */
820 float d3z
[], /* 3rd derivative */
821 int npoints
) /* number of valid points */
824 float deltaz
[MAXPOINTS
], a
[MAXPOINTS
], b
[MAXPOINTS
];
825 float c
[MAXPOINTS
], r
[MAXPOINTS
], s
[MAXPOINTS
];
829 for (i
= 1; i
< npoints
; ++i
) {
830 deltaz
[i
] = h
[i
] ? ((double) (z
[i
+ 1] - z
[i
])) / h
[i
] : 0;
832 h
[0] = h
[npoints
- 1];
833 deltaz
[0] = deltaz
[npoints
- 1];
836 for (i
= 1; i
< npoints
- 1; ++i
) {
837 d
[i
] = deltaz
[i
+ 1] - deltaz
[i
];
839 d
[0] = deltaz
[1] - deltaz
[0];
842 a
[1] = 2 * (h
[0] + h
[1]);
845 for (i
= 2; i
< npoints
- 1; ++i
) {
846 a
[i
] = 2 * (h
[i
- 1] + h
[i
]) -
847 pow((double) h
[i
- 1], (double) 2.0) / a
[i
- 1];
848 b
[i
] = d
[i
- 1] - h
[i
- 1] * b
[i
- 1] / a
[i
- 1];
849 c
[i
] = -h
[i
- 1] * c
[i
- 1] / a
[i
- 1];
855 for (i
= npoints
- 2; i
> 0; --i
) {
856 r
[i
] = -(h
[i
] * r
[i
+ 1] + c
[i
]) / a
[i
];
857 s
[i
] = (6 * b
[i
] - h
[i
] * s
[i
+ 1]) / a
[i
];
861 d2z
[npoints
- 1] = (6 * d
[npoints
- 2] - h
[0] * s
[1]
862 - h
[npoints
- 1] * s
[npoints
- 2])
863 / (h
[0] * r
[1] + h
[npoints
- 1] * r
[npoints
- 2]
864 + 2 * (h
[npoints
- 2] + h
[0]));
865 for (i
= 1; i
< npoints
- 1; ++i
) {
866 d2z
[i
] = r
[i
] * d2z
[npoints
- 1] + s
[i
];
868 d2z
[npoints
] = d2z
[1];
871 for (i
= 1; i
< npoints
; ++i
) {
872 dz
[i
] = deltaz
[i
] - h
[i
] * (2 * d2z
[i
] + d2z
[i
+ 1]) / 6;
873 d3z
[i
] = h
[i
] ? (d2z
[i
+ 1] - d2z
[i
]) / h
[i
] : 0;
875 } /* end PeriodicSpline */
878 /*----------------------------------------------------------------------------
879 | Routine: NaturalEndSpline (h, z, dz, d2z, d3z, npoints)
881 | Results: This routine solves for the cubic polynomial to fit a spline
882 | curve the the points specified by the list of values. The
883 | alogrithms for this curve are from the `Spline Curve
884 | Techniques' paper cited above.
885 *----------------------------------------------------------------------------*/
888 NaturalEndSpline(float h
[], /* parameterization */
889 int z
[], /* Point list */
890 float dz
[], /* to return the 1st derivative */
891 float d2z
[], /* 2nd derivative */
892 float d3z
[], /* 3rd derivative */
893 int npoints
) /* number of valid points */
896 float deltaz
[MAXPOINTS
], a
[MAXPOINTS
], b
[MAXPOINTS
];
900 for (i
= 1; i
< npoints
; ++i
) {
901 deltaz
[i
] = h
[i
] ? ((double) (z
[i
+ 1] - z
[i
])) / h
[i
] : 0;
903 deltaz
[0] = deltaz
[npoints
- 1];
906 for (i
= 1; i
< npoints
- 1; ++i
) {
907 d
[i
] = deltaz
[i
+ 1] - deltaz
[i
];
909 d
[0] = deltaz
[1] - deltaz
[0];
912 a
[0] = 2 * (h
[2] + h
[1]);
914 for (i
= 1; i
< npoints
- 2; ++i
) {
915 a
[i
] = 2 * (h
[i
+ 1] + h
[i
+ 2]) -
916 pow((double) h
[i
+ 1], (double) 2.0) / a
[i
- 1];
917 b
[i
] = d
[i
+ 1] - h
[i
+ 1] * b
[i
- 1] / a
[i
- 1];
921 d2z
[npoints
] = d2z
[1] = 0;
922 for (i
= npoints
- 1; i
> 1; --i
) {
923 d2z
[i
] = (6 * b
[i
- 2] - h
[i
] * d2z
[i
+ 1]) / a
[i
- 2];
927 for (i
= 1; i
< npoints
; ++i
) {
928 dz
[i
] = deltaz
[i
] - h
[i
] * (2 * d2z
[i
] + d2z
[i
+ 1]) / 6;
929 d3z
[i
] = h
[i
] ? (d2z
[i
+ 1] - d2z
[i
]) / h
[i
] : 0;
931 } /* end NaturalEndSpline */
934 /*----------------------------------------------------------------------------*
935 | Routine: change (x_position, y_position, visible_flag)
937 | Results: As HGtline passes from the invisible to visible (or vice
938 | versa) portion of a line, change is called to either draw
939 | the line, or initialize the beginning of the next one.
940 | Change calls line to draw segments if visible_flag is set
941 | (which means we're leaving a visible area).
942 *----------------------------------------------------------------------------*/
945 change(register int x
,
949 static int length
= 0;
951 if (vis
) { /* leaving a visible area, draw it. */
953 if (length
++ > LINELENGTH
) {
957 } else { /* otherwise, we're entering one, remember */
964 /*----------------------------------------------------------------------------
965 | Routine: HGtline (xstart, ystart, xend, yend)
967 | Results: Draws a line from current position to (x1,y1) using line(x1,
968 | y1) to place individual segments of dotted or dashed lines.
969 *----------------------------------------------------------------------------*/
975 register int x0
= lastx
;
976 register int y0
= lasty
;
979 register int oldcoord
;
981 register int visible
;
985 register int dotcounter
;
987 if (linmod
== SOLID
) {
992 /* for handling different resolutions */
993 dotcounter
= linmod
<< dotshifter
;
997 if ((dx
= x1
- x0
) < 0) {
1001 if ((dy
= y1
- y0
) < 0) {
1011 if ((x0
& dotcounter
) && !visible
) {
1014 } else if (visible
&& !(x0
& dotcounter
)) {
1015 change(x0
- xinc
, oldcoord
, 1);
1030 if ((y0
& dotcounter
) && !visible
) {
1033 } else if (visible
&& !(y0
& dotcounter
)) {
1034 change(oldcoord
, y0
- yinc
, 1);