home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / sharewar / dos / program / gs300sr1 / gs300sr1.exe / GSMATRIX.C < prev    next >
C/C++ Source or Header  |  1994-07-31  |  10KB  |  333 lines
  1. /* Copyright (C) 1989, 1990, 1991, 1993 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsmatrix.c */
  20. /* Matrix operators for Ghostscript library */
  21. #include "math_.h"
  22. #include "gx.h"
  23. #include "gserrors.h"
  24. #include "gxfarith.h"
  25. #include "gxfixed.h"
  26. #include "gxmatrix.h"
  27.  
  28. /* The identity matrix */
  29. private gs_matrix gs_identity_matrix =
  30.     { identity_matrix_body };
  31.  
  32. /* Forward references */
  33. typedef struct sincos_s { double sin, cos; } sincos_t;
  34. private void rotation_coefficients(P2(floatp, sincos_t *));
  35.  
  36. /* ------ Matrix creation ------ */
  37.  
  38. /* Create an identity matrix */
  39. void
  40. gs_make_identity(gs_matrix *pmat)
  41. {    *pmat = gs_identity_matrix;
  42. }
  43.  
  44. /* Create a translation matrix */
  45. int
  46. gs_make_translation(floatp dx, floatp dy, register gs_matrix *pmat)
  47. {    *pmat = gs_identity_matrix;
  48.     pmat->tx = dx;
  49.     pmat->ty = dy;
  50.     return 0;
  51. }
  52.  
  53. /* Create a scaling matrix */
  54. int
  55. gs_make_scaling(floatp sx, floatp sy, register gs_matrix *pmat)
  56. {    *pmat = gs_identity_matrix;
  57.     pmat->xx = sx;
  58.     pmat->yy = sy;
  59.     return 0;
  60. }
  61.  
  62. /* Create a rotation matrix. */
  63. /* The angle is in degrees. */
  64. int
  65. gs_make_rotation(floatp ang, register gs_matrix *pmat)
  66. {    sincos_t sincos;
  67.     rotation_coefficients(ang, &sincos);
  68.     pmat->yy = pmat->xx = sincos.cos;
  69.     pmat->xy = sincos.sin;
  70.     pmat->yx = -sincos.sin;
  71.     pmat->tx = pmat->ty = 0.0;
  72.     return 0;
  73. }
  74.  
  75. /* ------ Matrix arithmetic ------ */
  76.  
  77. /* Multiply two matrices.  We should check for floating exceptions, */
  78. /* but for the moment it's just too awkward. */
  79. /* Since this is used heavily, we check for shortcuts. */
  80. int
  81. gs_matrix_multiply(const gs_matrix *pm1, const gs_matrix *pm2, register gs_matrix *pmr)
  82. {    double xx1 = pm1->xx, yy1 = pm1->yy;
  83.     double tx1 = pm1->tx, ty1 = pm1->ty;
  84.     double xx2 = pm2->xx, yy2 = pm2->yy;
  85.     double xy2 = pm2->xy, yx2 = pm2->yx;
  86.     if ( !is_skewed(pm1) )
  87.     {    pmr->tx = tx1 * xx2 + pm2->tx;
  88.         pmr->ty = ty1 * yy2 + pm2->ty;
  89.         if ( is_fzero(xy2) )
  90.             pmr->xy = 0;
  91.         else
  92.             pmr->xy = xx1 * xy2,
  93.             pmr->ty += tx1 * xy2;
  94.         pmr->xx = xx1 * xx2;
  95.         if ( is_fzero(yx2) )
  96.             pmr->yx = 0;
  97.         else
  98.             pmr->yx = yy1 * yx2,
  99.             pmr->tx += ty1 * yx2;
  100.         pmr->yy = yy1 * yy2;
  101.     }
  102.     else
  103.     {    double xy1 = pm1->xy, yx1 = pm1->yx;
  104.         pmr->xx = xx1 * xx2 + xy1 * yx2;
  105.         pmr->xy = xx1 * xy2 + xy1 * yy2;
  106.         pmr->yy = yx1 * xy2 + yy1 * yy2;
  107.         pmr->yx = yx1 * xx2 + yy1 * yx2;
  108.         pmr->tx = tx1 * xx2 + ty1 * yx2 + pm2->tx;
  109.         pmr->ty = tx1 * xy2 + ty1 * yy2 + pm2->ty;
  110.     }
  111.     return 0;
  112. }
  113.  
  114. /* Invert a matrix.  Return gs_error_undefinedresult if not invertible. */
  115. int
  116. gs_matrix_invert(register const gs_matrix *pm, register gs_matrix *pmr)
  117. {    /* We have to be careful about fetch/store order, */
  118.     /* because pm might be the same as pmr. */
  119.     if ( !is_skewed(pm) )
  120.     {    if ( is_fzero(pm->xx) || is_fzero(pm->yy) )
  121.             return_error(gs_error_undefinedresult);
  122.         pmr->tx = - (pmr->xx = 1.0 / pm->xx) * pm->tx;
  123.         pmr->xy = 0.0;
  124.         pmr->yx = 0.0;
  125.         pmr->ty = - (pmr->yy = 1.0 / pm->yy) * pm->ty;
  126.     }
  127.     else
  128.     {    double det = pm->xx * pm->yy - pm->xy * pm->yx;
  129.         double mxx = pm->xx, mtx = pm->tx;
  130.         if ( det == 0 ) return_error(gs_error_undefinedresult);
  131.         pmr->xx = pm->yy / det;
  132.         pmr->xy = - pm->xy / det;
  133.         pmr->yx = - pm->yx / det;
  134.         pmr->yy = mxx / det;    /* xx is already changed */
  135.         pmr->tx = - (mtx * pmr->xx + pm->ty * pmr->yx);
  136.         pmr->ty = - (mtx * pmr->xy + pm->ty * pmr->yy);    /* tx ditto */
  137.     }
  138.     return 0;
  139. }
  140.  
  141. /* Rotate a matrix, possibly in place.  The angle is in degrees. */
  142. int
  143. gs_matrix_rotate(register const gs_matrix *pm, floatp ang, register gs_matrix *pmr)
  144. {    double mxx, mxy;
  145.     sincos_t sincos;
  146.     rotation_coefficients(ang, &sincos);
  147.     mxx = pm->xx, mxy = pm->xy;
  148.     pmr->xx = sincos.cos * mxx + sincos.sin * pm->yx;
  149.     pmr->xy = sincos.cos * mxy + sincos.sin * pm->yy;
  150.     pmr->yx = sincos.cos * pm->yx - sincos.sin * mxx;
  151.     pmr->yy = sincos.cos * pm->yy - sincos.sin * mxy;
  152.     pmr->tx = pm->tx;
  153.     pmr->ty = pm->ty;
  154.     return 0;
  155. }
  156.  
  157. /* ------ Coordinate transformations (floating point) ------ */
  158.  
  159. /* Note that all the transformation routines take separate */
  160. /* x and y arguments, but return their result in a point. */
  161.  
  162. /* Transform a point. */
  163. int
  164. gs_point_transform(floatp x, floatp y, register const gs_matrix *pmat,
  165.   register gs_point *ppt)
  166. {    ppt->x = x * pmat->xx + pmat->tx;
  167.     ppt->y = y * pmat->yy + pmat->ty;
  168.     if ( !is_fzero(pmat->yx) )
  169.         ppt->x += y * pmat->yx;
  170.     if ( !is_fzero(pmat->xy) )
  171.         ppt->y += x * pmat->xy;
  172.     return 0;
  173. }
  174.  
  175. /* Inverse-transform a point. */
  176. /* Return gs_error_undefinedresult if the matrix is not invertible. */
  177. int
  178. gs_point_transform_inverse(floatp x, floatp y, register const gs_matrix *pmat,
  179.   register gs_point *ppt)
  180. {    if ( !is_skewed(pmat) )
  181.        {    if ( is_fzero(pmat->xx) || is_fzero(pmat->yy) )
  182.             return_error(gs_error_undefinedresult);
  183.         ppt->x = (x - pmat->tx) / pmat->xx;
  184.         ppt->y = (y - pmat->ty) / pmat->yy;
  185.         return 0;
  186.        }
  187.     else
  188.        {    /* There are faster ways to do this, */
  189.         /* but we won't implement one unless we have to. */
  190.         gs_matrix imat;
  191.         int code = gs_matrix_invert(pmat, &imat);
  192.         if ( code < 0 ) return code;
  193.         return gs_point_transform(x, y, &imat, ppt);
  194.        }
  195. }
  196.  
  197. /* Transform a distance. */
  198. int
  199. gs_distance_transform(floatp dx, floatp dy, register const gs_matrix *pmat,
  200.   register gs_point *pdpt)
  201. {    pdpt->x = dx * pmat->xx;
  202.     pdpt->y = dy * pmat->yy;
  203.     if ( !is_fzero(pmat->yx) )
  204.         pdpt->x += dy * pmat->yx;
  205.     if ( !is_fzero(pmat->xy) )
  206.         pdpt->y += dx * pmat->xy;
  207.     return 0;
  208. }
  209.  
  210. /* Inverse-transform a distance. */
  211. /* Return gs_error_undefinedresult if the matrix is not invertible. */
  212. int
  213. gs_distance_transform_inverse(floatp dx, floatp dy,
  214.   register const gs_matrix *pmat, register gs_point *pdpt)
  215. {    if ( !is_skewed(pmat) )
  216.        {    if ( is_fzero(pmat->xx) || is_fzero(pmat->yy) )
  217.             return_error(gs_error_undefinedresult);
  218.         pdpt->x = dx / pmat->xx;
  219.         pdpt->y = dy / pmat->yy;
  220.        }
  221.     else
  222.        {    double det = pmat->xx * pmat->yy - pmat->xy * pmat->yx;
  223.         if ( det == 0 ) return_error(gs_error_undefinedresult);
  224.         pdpt->x = (dx * pmat->yy - dy * pmat->yx) / det;
  225.         pdpt->y = (dy * pmat->xx - dx * pmat->xy) / det;
  226.        }
  227.     return 0;
  228. }
  229.  
  230. /* Transform or inverse-transform a bounding box. */
  231. /* Return gs_error_undefinedresult if the matrix is not invertible. */
  232. private int
  233. bbox_transform_either(const gs_rect *pbox_in, const gs_matrix *pmat,
  234.   gs_rect *pbox_out,
  235.   int (*point_xform)(P4(floatp, floatp, const gs_matrix *, gs_point *)),
  236.   int (*distance_xform)(P4(floatp, floatp, const gs_matrix *, gs_point *)))
  237. {    int code;
  238.     gs_point p, w, h;
  239.     double xmin, ymin, xmax, ymax;    /* gs_point uses double */
  240.     /* We must recompute the max and min after transforming, */
  241.     /* since a rotation may be involved. */
  242.     if (    (code = (*point_xform)(pbox_in->p.x, pbox_in->p.y, pmat, &p)) < 0 ||
  243.         (code = (*distance_xform)(pbox_in->q.x - pbox_in->p.x, 0.0, pmat, &w)) < 0 ||
  244.         (code = (*distance_xform)(0.0, pbox_in->q.y - pbox_in->p.y, pmat, &h)) < 0
  245.        )
  246.         return code;
  247.     xmin = xmax = p.x;
  248.     if ( w.x < 0 )    xmin += w.x;
  249.     else        xmax += w.x;
  250.     if ( h.x < 0 )    xmin += h.x;
  251.     else        xmax += h.x;
  252.     ymin = ymax = p.y;
  253.     if ( w.y < 0 )    ymin += w.y;
  254.     else        ymax += w.y;
  255.     if ( h.y < 0 )    ymin += h.y;
  256.     else        ymax += h.y;
  257.     pbox_out->p.x = xmin, pbox_out->p.y = ymin;
  258.     pbox_out->q.x = xmax, pbox_out->q.y = ymax;
  259.     return 0;
  260. }
  261. int
  262. gs_bbox_transform(const gs_rect *pbox_in, const gs_matrix *pmat,
  263.   gs_rect *pbox_out)
  264. {    return bbox_transform_either(pbox_in, pmat, pbox_out,
  265.         gs_point_transform, gs_distance_transform);
  266. }
  267. int
  268. gs_bbox_transform_inverse(const gs_rect *pbox_in, const gs_matrix *pmat,
  269.   gs_rect *pbox_out)
  270. {    return bbox_transform_either(pbox_in, pmat, pbox_out,
  271.         gs_point_transform_inverse, gs_distance_transform_inverse);
  272. }
  273.  
  274. /* ------ Coordinate transformations (to fixed point) ------ */
  275.  
  276. /* Transform a point with a fixed-point result. */
  277. int
  278. gs_point_transform2fixed(register const gs_matrix_fixed *pmat,
  279.   floatp x, floatp y, gs_fixed_point *ppt)
  280. {    if ( !is_fzero(pmat->xy) )
  281.     {    /* Hope for 90 degree rotation */
  282.         ppt->x = dfmul2fixed_vars(y, pmat->yx) + pmat->tx_fixed;
  283.         ppt->y = dfmul2fixed_vars(x, pmat->xy) + pmat->ty_fixed;
  284.         if ( !is_fzero(pmat->xx) )
  285.             ppt->x += dfmul2fixed_vars(x, pmat->xx);
  286.         if ( !is_fzero(pmat->yy) )
  287.             ppt->y += dfmul2fixed_vars(y, pmat->yy);
  288.     }
  289.     else
  290.     {    ppt->x = dfmul2fixed_vars(x, pmat->xx) + pmat->tx_fixed;
  291.         ppt->y = dfmul2fixed_vars(y, pmat->yy) + pmat->ty_fixed;
  292.         if ( !is_fzero(pmat->yx) )
  293.             ppt->x += dfmul2fixed_vars(y, pmat->yx);
  294.     }
  295.     return 0;
  296. }
  297.  
  298. /* Transform a distance with a fixed-point result. */
  299. int
  300. gs_distance_transform2fixed(register const gs_matrix_fixed *pmat,
  301.   floatp dx, floatp dy, gs_fixed_point *ppt)
  302. {    ppt->x = dfmul2fixed_vars(dx, pmat->xx);
  303.     ppt->y = dfmul2fixed_vars(dy, pmat->yy);
  304.     if ( !is_fzero(pmat->yx) )
  305.         ppt->x += dfmul2fixed_vars(dy, pmat->yx);
  306.     if ( !is_fzero(pmat->xy) )
  307.         ppt->y += dfmul2fixed_vars(dx, pmat->xy);
  308.     return 0;
  309. }
  310.  
  311. /* ------ Private routines ------ */
  312.  
  313. /* Get the sine and cosine coefficients for rotation by an angle */
  314. /* specified in degrees, with special checking so multiples of 90 */
  315. /* produce exact results. */
  316. private void
  317. rotation_coefficients(floatp ang, sincos_t *psincos)
  318. {    int quads;
  319.     if ( ang >= -360 && ang <= 360 &&
  320.          ang == (quads = (int)ang / 90) * 90
  321.        )
  322.     {    static const int isincos[5] = { 0, 1, 0, -1, 0 };
  323.         quads &= 3;
  324.         psincos->sin = isincos[quads];
  325.         psincos->cos = isincos[quads + 1];
  326.     }
  327.     else
  328.     {    double theta = ang * (M_PI / 180.0);
  329.         psincos->sin = sin(theta);
  330.         psincos->cos = cos(theta);
  331.     }
  332. }
  333.