source: tags/initial/fig2dev/bound.c

Last change on this file was 2, checked in by oldcode, 24 years ago

Initial revision
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.8 KB
Line 
1/*
2 * TransFig: Facility for Translating Fig code
3 * Copyright (c) 1985 Supoj Sutantavibul
4 * Copyright (c) 1991 Micah Beck
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation. The authors make no representations about the suitability
11 * of this software for any purpose.  It is provided "as is" without express
12 * or implied warranty.
13 *
14 * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20 * PERFORMANCE OF THIS SOFTWARE.
21 *
22 */
23
24#include <stdio.h>
25#include <math.h>
26#include "pi.h"
27#include "object.h"
28
29#define         Ninety_deg              M_PI_2
30#define         One_eighty_deg          M_PI
31#define         Two_seventy_deg         (M_PI + M_PI_2)
32#define         Three_sixty_deg         (M_PI + M_PI)
33#define         round(x)                ((int) ((x) + ((x >= 0)? 0.5: -0.5)))
34#define         half(z1 ,z2)            ((z1+z2)/2.0)
35#define         max(a, b)               (((a) > (b)) ? (a) : (b))
36#define         min(a, b)               (((a) < (b)) ? (a) : (b))
37
38arc_bound(arc, xmin, ymin, xmax, ymax)
39F_arc   *arc;
40int     *xmin, *ymin, *xmax, *ymax;
41{
42        double  alpha, beta;
43        double  dx, dy, radius;
44        int     bx, by, sx, sy;
45
46        dx = arc->point[0].x - arc->center.x;
47        dy = arc->center.y - arc->point[0].y;
48        alpha = atan2(dy, dx);
49        if (alpha < 0.0) alpha += Three_sixty_deg;
50        /* compute_angle returns value between 0 to 2PI */
51       
52        radius = hypot(dx, dy);
53
54        dx = arc->point[2].x - arc->center.x;
55        dy = arc->center.y - arc->point[2].y;
56        beta = atan2(dy, dx);
57        if (beta < 0.0) beta += Three_sixty_deg;
58
59        bx = max(arc->point[0].x, arc->point[1].x);
60        bx = max(arc->point[2].x, bx);
61        by = max(arc->point[0].y, arc->point[1].y);
62        by = max(arc->point[2].y, by);
63        sx = min(arc->point[0].x, arc->point[1].x);
64        sx = min(arc->point[2].x, sx);
65        sy = min(arc->point[0].y, arc->point[1].y);
66        sy = min(arc->point[2].y, sy);
67
68        if (arc->direction == 1) { /* counter clockwise */
69            if (alpha > beta) {
70                if (alpha <= 0 || 0 <= beta)
71                    bx = (int)(arc->center.x + radius + 1.0);
72                if (alpha <= Ninety_deg || Ninety_deg <= beta)
73                    sy = (int)(arc->center.y - radius - 1.0);
74                if (alpha <= One_eighty_deg || One_eighty_deg <= beta)
75                    sx = (int)(arc->center.x - radius - 1.0);
76                if (alpha <= Two_seventy_deg || Two_seventy_deg <= beta)
77                    by = (int)(arc->center.y + radius + 1.0);
78                }
79            else {
80                if (0 <= beta && alpha <= 0)
81                    bx = (int)(arc->center.x + radius + 1.0);
82                if (Ninety_deg <= beta && alpha <= Ninety_deg)
83                    sy = (int)(arc->center.y - radius - 1.0);
84                if (One_eighty_deg <= beta && alpha <= One_eighty_deg)
85                    sx = (int)(arc->center.x - radius - 1.0);
86                if (Two_seventy_deg <= beta && alpha <= Two_seventy_deg)
87                    by = (int)(arc->center.y + radius + 1.0);
88                }
89            }
90        else {  /* clockwise    */
91            if (alpha > beta) {
92                if (beta <= 0 && 0 <= alpha)
93                    bx = (int)(arc->center.x + radius + 1.0);
94                if (beta <= Ninety_deg && Ninety_deg <= alpha)
95                    sy = (int)(arc->center.y - radius - 1.0);
96                if (beta <= One_eighty_deg && One_eighty_deg <= alpha)
97                    sx = (int)(arc->center.x - radius - 1.0);
98                if (beta <= Two_seventy_deg && Two_seventy_deg <= alpha)
99                    by = (int)(arc->center.y + radius + 1.0);
100                }
101            else {
102                if (0 <= alpha || beta <= 0)
103                    bx = (int)(arc->center.x + radius + 1.0);
104                if (Ninety_deg <= alpha || beta <= Ninety_deg)
105                    sy = (int)(arc->center.y - radius - 1.0);
106                if (One_eighty_deg <= alpha || beta <= One_eighty_deg)
107                    sx = (int)(arc->center.x - radius - 1.0);
108                if (Two_seventy_deg <= alpha || beta <= Two_seventy_deg)
109                    by = (int)(arc->center.y + radius + 1.0);
110                }
111            }
112        *xmax = bx; *ymax = by;
113        *xmin = sx; *ymin = sy;
114        }
115
116compound_bound(compound, xmin, ymin, xmax, ymax, include)
117F_compound      *compound;
118int             *xmin, *ymin, *xmax, *ymax;
119int             include;
120{
121        F_arc           *a;
122        F_ellipse       *e;
123        F_compound      *c;
124        F_spline        *s;
125        F_line          *l;
126        F_text          *t;
127        int             bx, by, sx, sy, first = 1;
128        int             llx, lly, urx, ury;
129
130   while(compound != NULL)
131   {
132        for (a = compound->arcs; a != NULL; a = a->next) {
133            arc_bound(a, &sx, &sy, &bx, &by);
134            if (first) {
135                first = 0;
136                llx = sx; lly = sy;
137                urx = bx; ury = by;
138                }
139            else {
140                llx = min(llx, sx); lly = min(lly, sy);
141                urx = max(urx, bx); ury = max(ury, by);
142                }
143            }
144
145        for (c = compound->compounds; c != NULL; c = c->next) {
146            compound_bound(c, &sx, &sy, &bx, &by);
147            if (first) {
148                first = 0;
149                llx = sx; lly = sy;
150                urx = bx; ury = by;
151                }
152            else {
153                llx = min(llx, sx); lly = min(lly, sy);
154                urx = max(urx, bx); ury = max(ury, by);
155                }
156            }
157
158        for (e = compound->ellipses; e != NULL; e = e->next) {
159            ellipse_bound(e, &sx, &sy, &bx, &by);
160            if (first) {
161                first = 0;
162                llx = sx; lly = sy;
163                urx = bx; ury = by;
164                }
165            else {
166                llx = min(llx, sx); lly = min(lly, sy);
167                urx = max(urx, bx); ury = max(ury, by);
168                }
169            }
170
171        for (l = compound->lines; l != NULL; l = l->next) {
172            line_bound(l, &sx, &sy, &bx, &by);
173            if (first) {
174                first = 0;
175                llx = sx; lly = sy;
176                urx = bx; ury = by;
177                }
178            else {
179                llx = min(llx, sx); lly = min(lly, sy);
180                urx = max(urx, bx); ury = max(ury, by);
181                }
182            }
183
184        for (s = compound->splines; s != NULL; s = s->next) {
185            spline_bound(s, &sx, &sy, &bx, &by);
186            if (first) {
187                first = 0;
188                llx = sx; lly = sy;
189                urx = bx; ury = by;
190                }
191            else {
192                llx = min(llx, sx); lly = min(lly, sy);
193                urx = max(urx, bx); ury = max(ury, by);
194                }
195            }
196
197        for (t = compound->texts; t != NULL; t = t->next) {
198            text_bound(t, &sx, &sy, &bx, &by, include);
199            if (first) {
200                first = 0;
201                llx = sx; lly = sy;
202                urx = bx; ury = by;
203                }
204            else {
205                llx = min(llx, sx); lly = min(lly, sy);
206                urx = max(urx, bx); ury = max(ury, by);
207                }
208            }
209        compound = compound->next;
210     }
211
212        *xmin = llx; *ymin = lly;
213        *xmax = urx; *ymax = ury;
214        }
215
216ellipse_bound(e, xmin, ymin, xmax, ymax)
217F_ellipse       *e;
218int             *xmin, *ymin, *xmax, *ymax;
219{
220        *xmin = e->center.x - e->radiuses.x;
221        *ymin = e->center.y - e->radiuses.y;
222        *xmax = e->center.x + e->radiuses.x;
223        *ymax = e->center.y + e->radiuses.y;
224        }
225
226line_bound(l, xmin, ymin, xmax, ymax)
227F_line  *l;
228int     *xmin, *ymin, *xmax, *ymax;
229{
230        points_bound(l->points, xmin, ymin, xmax, ymax);
231        }
232
233spline_bound(s, xmin, ymin, xmax, ymax)
234F_spline        *s;
235int             *xmin, *ymin, *xmax, *ymax;
236{
237        if (int_spline(s)) {
238            int_spline_bound(s, xmin, ymin, xmax, ymax);
239            }
240        else {
241            normal_spline_bound(s, xmin, ymin, xmax, ymax);
242            }
243        }
244
245int_spline_bound(s, xmin, ymin, xmax, ymax)
246F_spline        *s;
247int             *xmin, *ymin, *xmax, *ymax;
248{
249        F_point         *p1, *p2;
250        F_control       *cp1, *cp2;
251        double          x0, y0, x1, y1, x2, y2, x3, y3, sx1, sy1, sx2, sy2;
252        double          tx, ty, tx1, ty1, tx2, ty2;
253        double          sx, sy, bx, by;
254
255        p1 = s->points;
256        sx = bx = p1->x;
257        sy = by = p1->y;
258        cp1 = s->controls;
259        for (p2 = p1->next, cp2 = cp1->next; p2 != NULL;
260                p1 = p2, cp1 = cp2, p2 = p2->next, cp2 = cp2->next) {
261            x0 = p1->x; y0 = p1->y;
262            x1 = cp1->rx; y1 = cp1->ry;
263            x2 = cp2->lx; y2 = cp2->ly;
264            x3 = p2->x; y3 = p2->y;
265            tx = half(x1, x2); ty = half(y1, y2);
266            sx1 = half(x0, x1); sy1 = half(y0, y1);
267            sx2 = half(sx1, tx); sy2 = half(sy1, ty);
268            tx2 = half(x2, x3); ty2 = half(y2, y3);
269            tx1 = half(tx2, tx); ty1 = half(ty2, ty);
270
271            sx = min(x0, sx); sy = min(y0, sy);
272            sx = min(sx1, sx); sy = min(sy1, sy);
273            sx = min(sx2, sx); sy = min(sy2, sy);
274            sx = min(tx1, sx); sy = min(ty1, sy);
275            sx = min(tx2, sx); sy = min(ty2, sy);
276            sx = min(x3, sx); sy = min(y3, sy);
277
278            bx = max(x0, bx); by = max(y0, by);
279            bx = max(sx1, bx); by = max(sy1, by);
280            bx = max(sx2, bx); by = max(sy2, by);
281            bx = max(tx1, bx); by = max(ty1, by);
282            bx = max(tx2, bx); by = max(ty2, by);
283            bx = max(x3, bx); by = max(y3, by);
284            }
285        *xmin = round(sx);
286        *ymin = round(sy);
287        *xmax = round(bx);
288        *ymax = round(by);
289        }
290
291normal_spline_bound(s, xmin, ymin, xmax, ymax)
292F_spline        *s;
293int             *xmin, *ymin, *xmax, *ymax;
294{
295        F_point *p;
296        double  cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
297        double  x1, y1, x2, y2, sx, sy, bx, by;
298        double  px, py, qx, qy;
299
300        p = s->points;
301        x1 = p->x;  y1 = p->y;
302        p = p->next;
303        x2 = p->x;  y2 = p->y;
304        cx1 = (x1 + x2) / 2.0;   cy1 = (y1 + y2) / 2.0;
305        cx2 = (cx1 + x2) / 2.0;  cy2 = (cy1 + y2) / 2.0;
306        if (closed_spline(s)) {
307            x1 = (cx1 + x1) / 2.0;
308            y1 = (cy1 + y1) / 2.0;
309            }
310        sx = min(x1, cx2); sy = min(y1, cy2);
311        bx = max(x1, cx2); by = max(y1, cy2);
312
313        for (p = p->next; p != NULL; p = p->next) {
314            x1 = x2;  y1 = y2;
315            x2 = p->x;  y2 = p->y;
316            cx4 = (x1 + x2) / 2.0; cy4 = (y1 + y2) / 2.0;
317            cx3 = (x1 + cx4) / 2.0; cy3 = (y1 + cy4) / 2.0;
318            cx2 = (cx4 + x2) / 2.0;  cy2 = (cy4 + y2) / 2.0;
319
320            px = min(cx2, cx3); py = min(cy2, cy3);
321            qx = max(cx2, cx3); qy = max(cy2, cy3);
322
323            sx = min(sx, px); sy = min(sy, py);
324            bx = max(bx, qx); by = max(by, qy);
325            }
326        if (closed_spline(s)) {
327            *xmin = round(sx); *ymin = round(sy);
328            *xmax = round(bx); *ymax = round(by);
329            }
330        else {
331            *xmin = round(min(sx, x2)); *ymin = round(min(sy, y2));
332            *xmax = round(max(bx, x2)); *ymax = round(max(by, y2));
333            }
334        }
335
336double rot_x(x,y,angle) 
337double x,y,angle;
338{
339    return(x*cos(-angle)-y*sin(-angle));
340}
341
342double rot_y(x,y,angle)
343double x,y,angle;
344{
345 return(x*sin(-angle)+y*cos(-angle));
346}
347
348
349text_bound(t, xmin, ymin, xmax, ymax, include)
350F_text  *t;
351int     *xmin, *ymin, *xmax, *ymax;
352int     include;
353{
354    double dx1, dx2, dx3, dx4, dy1, dy2, dy3, dy4;
355
356        if (t->type == T_CENTER_JUSTIFIED) {
357            dx1 = (t->length/2);     dy1 = 0.0;
358            dx2 = -(t->length/2);    dy2 = 0.0;
359            dx3 = (t->length/2);     dy3 = -t->height;
360            dx4 = -(t->length/2);    dy4 = -t->height;
361        } else if (t->type == T_RIGHT_JUSTIFIED) {
362            dx1 = 0.0;               dy1 = 0.0;
363            dx2 = -t->length;        dy2 = 0.0;
364            dx3 = 0.0;               dy3 = -t->height;
365            dx4 = -t->length;        dy4 = -t->height;
366        } else {
367            dx1 = (include ? t->length : 0); dy1 = 0.0;
368            dx2 = 0.0;                       dy2 = 0.0;
369            dx3 = (include ? t->length : 0); dy3 = -t->height;
370            dx4 = 0.0;                       dy4 = -t->height;
371        }
372    *xmax= t->base_x +
373           max( max( rot_x(dx1,dy1,t->angle), rot_x(dx2,dy2,t->angle) ), 
374                max( rot_x(dx3,dy3,t->angle), rot_x(dx4,dy4,t->angle) ) );
375    *ymax= t->base_y + 
376           max( max( rot_y(dx1,dy1,t->angle), rot_y(dx2,dy2,t->angle) ), 
377                max( rot_y(dx3,dy3,t->angle), rot_y(dx4,dy4,t->angle) ) );
378
379    *xmin= t->base_x + 
380           min( min( rot_x(dx1,dy1,t->angle), rot_x(dx2,dy2,t->angle) ), 
381                min( rot_x(dx3,dy3,t->angle), rot_x(dx4,dy4,t->angle) ) );
382    *ymin= t->base_y + 
383           min( min( rot_y(dx1,dy1,t->angle), rot_y(dx2,dy2,t->angle) ), 
384                min( rot_y(dx3,dy3,t->angle), rot_y(dx4,dy4,t->angle) ) );
385        }
386
387points_bound(points, xmin, ymin, xmax, ymax)
388F_point *points;
389int     *xmin, *ymin, *xmax, *ymax;
390{
391        int     bx, by, sx, sy;
392        F_point *p;
393
394        bx = sx = points->x; by = sy = points->y;
395        for (p = points->next; p != NULL; p = p->next) {
396            sx = min(sx, p->x); sy = min(sy, p->y);
397            bx = max(bx, p->x); by = max(by, p->y);
398            }
399        *xmin = sx; *ymin = sy;
400        *xmax = bx; *ymax = by;
401        }
402
403control_points_bound(cps, xmin, ymin, xmax, ymax)
404F_control       *cps;
405int             *xmin, *ymin, *xmax, *ymax;
406{
407        F_control       *c;
408        double          bx, by, sx, sy;
409
410        bx = sx = cps->lx;
411        by = sy = cps->ly;
412        sx = min(sx, cps->rx); sy = min(sy, cps->ry);
413        bx = max(bx, cps->rx); by = max(by, cps->ry);
414        for (c = cps->next; c != NULL; c = c->next) {
415            sx = min(sx, c->lx); sy = min(sy, c->ly);
416            bx = max(bx, c->lx); by = max(by, c->ly);
417            sx = min(sx, c->rx); sy = min(sy, c->ry);
418            bx = max(bx, c->rx); by = max(by, c->ry);
419            }
420        *xmin = round(sx); *ymin = round(sy);
421        *xmax = round(bx); *ymax = round(by);
422        }
Note: See TracBrowser for help on using the repository browser.