home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / XAP / XFIG / TRANSFIG.2 / TRANSFIG / transfig / fig2dev / bound.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-14  |  11.8 KB  |  423 lines
  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.  
  38. arc_bound(arc, xmin, ymin, xmax, ymax)
  39. F_arc    *arc;
  40. int    *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.  
  116. compound_bound(compound, xmin, ymin, xmax, ymax, include)
  117. F_compound    *compound;
  118. int        *xmin, *ymin, *xmax, *ymax;
  119. int        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.  
  216. ellipse_bound(e, xmin, ymin, xmax, ymax)
  217. F_ellipse    *e;
  218. int        *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.  
  226. line_bound(l, xmin, ymin, xmax, ymax)
  227. F_line    *l;
  228. int    *xmin, *ymin, *xmax, *ymax;
  229. {
  230.     points_bound(l->points, xmin, ymin, xmax, ymax);
  231.     }
  232.  
  233. spline_bound(s, xmin, ymin, xmax, ymax)
  234. F_spline    *s;
  235. int        *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.  
  245. int_spline_bound(s, xmin, ymin, xmax, ymax)
  246. F_spline    *s;
  247. int        *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.  
  291. normal_spline_bound(s, xmin, ymin, xmax, ymax)
  292. F_spline    *s;
  293. int        *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.  
  336. double rot_x(x,y,angle) 
  337. double x,y,angle;
  338. {
  339.     return(x*cos(-angle)-y*sin(-angle));
  340. }
  341.  
  342. double rot_y(x,y,angle)
  343. double x,y,angle;
  344. {
  345.  return(x*sin(-angle)+y*cos(-angle));
  346. }
  347.  
  348.  
  349. text_bound(t, xmin, ymin, xmax, ymax, include)
  350. F_text    *t;
  351. int    *xmin, *ymin, *xmax, *ymax;
  352. int    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.  
  387. points_bound(points, xmin, ymin, xmax, ymax)
  388. F_point    *points;
  389. int    *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.  
  403. control_points_bound(cps, xmin, ymin, xmax, ymax)
  404. F_control    *cps;
  405. int        *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.     }
  423.