WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-matrix.c

  *	Carl D. Worth
  */
 #include "cairoint.h"
+#include "cairo-error-private.h"
+#include
-#include "cairo-error-private.h"
+#define PIXMAN_MAX_INT ((pixman_fixed_1 >> 1) - pixman_fixed_e) /* need to ensure deltas also fit */
 #if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE)
 #define ISFINITE(x) isfinite (x)
+ *
  * The current transformation matrix of a #cairo_t, represented as a
  * #cairo_matrix_t, defines the transformation from user-space
  * coordinates to device-space coordinates. See cairo_get_matrix() and
  * cairo_set_matrix().
- */
+ **/
 static void
 _cairo_matrix_scalar_multiply (cairo_matrix_t *matrix, double scalar);
 /**
  * cairo_matrix_init_identity:
  * @matrix: a #cairo_matrix_t
+ *
  * Modifies @matrix to be an identity transformation.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_init_identity (cairo_matrix_t *matrix)
+{
     cairo_matrix_init (matrix,
  * by:
+ *
  *  x_new = xx * x + xy * y + x0;
  *  y_new = yx * x + yy * y + y0;
+ *
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_init (cairo_matrix_t *matrix,
 		   double xx, double yx,
  * @tx: amount to translate in the X direction
  * @ty: amount to translate in the Y direction
+ *
  * Initializes @matrix to a transformation that translates by @tx and
  * @ty in the X and Y dimensions, respectively.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_init_translate (cairo_matrix_t *matrix,
 			     double tx, double ty)
+{
+ *
  * Applies a translation by @tx, @ty to the transformation in
  * @matrix. The effect of the new transformation is to first translate
  * the coordinates by @tx and @ty, then apply the original transformation
  * to the coordinates.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_translate (cairo_matrix_t *matrix, double tx, double ty)
+{
     cairo_matrix_t tmp;
  * @sx: scale factor in the X direction
  * @sy: scale factor in the Y direction
+ *
  * Initializes @matrix to a transformation that scales by @sx and @sy
  * in the X and Y dimensions, respectively.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_init_scale (cairo_matrix_t *matrix,
 			 double sx, double sy)
+{
  * @sy: scale factor in the Y direction
+ *
  * Applies scaling by @sx, @sy to the transformation in @matrix. The
  * effect of the new transformation is to first scale the coordinates
  * by @sx and @sy, then apply the original transformation to the coordinates.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_scale (cairo_matrix_t *matrix, double sx, double sy)
+{
     cairo_matrix_t tmp;
  * the positive X axis toward the positive Y axis. With the default
  * axis orientation of cairo, positive angles rotate in a clockwise
  * direction.
+ *
  * Initialized @matrix to a transformation that rotates by @radians.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_init_rotate (cairo_matrix_t *matrix,
 			  double radians)
+{
+ *
  * Applies rotation by @radians to the transformation in
  * @matrix. The effect of the new transformation is to first rotate the
  * coordinates by @radians, then apply the original transformation
  * to the coordinates.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_rotate (cairo_matrix_t *matrix, double radians)
+{
     cairo_matrix_t tmp;
  * transformation is to first apply the transformation in @a to the
  * coordinates and then apply the transformation in @b to the
  * coordinates.
+ *
  * It is allowable for @result to be identical to either @a or @b.
+ *
+ * Since: 1.0
  **/
 /*
  * XXX: The ordering of the arguments to this function corresponds
  *      to [row_vector]*A*B. If we want to use column vectors instead,
  *      then we need to switch the two arguments and fix up all
     *result = r;
+}
+slim_hidden_def(cairo_matrix_multiply);
+void
+_cairo_matrix_multiply (cairo_matrix_t *r,
+			const cairo_matrix_t *a,
+			const cairo_matrix_t *b)
+{
+    r->xx = a->xx * b->xx + a->yx * b->xy;
+    r->yx = a->xx * b->yx + a->yx * b->yy;
+    r->xy = a->xy * b->xx + a->yy * b->xy;
+    r->yy = a->xy * b->yx + a->yy * b->yy;
+    r->x0 = a->x0 * b->xx + a->y0 * b->xy + b->x0;
+    r->y0 = a->x0 * b->yx + a->y0 * b->yy + b->y0;
 slim_hidden_def(cairo_matrix_multiply);
 /**
  * cairo_matrix_transform_distance:
  * @matrix: a #cairo_matrix_t
+ *
  * Affine transformations are position invariant, so the same vector
  * always transforms to the same vector. If (@x1,@y1) transforms
  * to (@x2,@y2) then (@x1+@dx1,@y1+@dy1) will transform to
  * (@x1+@dx2,@y1+@dy2) for all values of @x1 and @x2.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_transform_distance (const cairo_matrix_t *matrix, double *dx, double *dy)
+{
     double new_x, new_y;
  * @matrix: a #cairo_matrix_t
  * @x: X position. An in/out parameter
  * @y: Y position. An in/out parameter
+ *
  * Transforms the point (@x, @y) by @matrix.
+ *
+ * Since: 1.0
  **/
 void
 cairo_matrix_transform_point (const cairo_matrix_t *matrix, double *x, double *y)
+{
     cairo_matrix_transform_distance (matrix, x, y);
  * then it has no inverse and this function will fail.
+ *
  * Returns: If @matrix has an inverse, modifies @matrix to
  *  be the inverse matrix and returns %CAIRO_STATUS_SUCCESS. Otherwise,
  *  returns %CAIRO_STATUS_INVALID_MATRIX.
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_matrix_invert (cairo_matrix_t *matrix)
+{
     double det;
     return CAIRO_STATUS_SUCCESS;
+}
-cairo_bool_t
-_cairo_matrix_is_identity (const cairo_matrix_t *matrix)
-{
-    return (matrix->xx == 1.0 && matrix->yx == 0.0 &&
-	    matrix->xy == 0.0 && matrix->yy == 1.0 &&
-	    matrix->x0 == 0.0 && matrix->y0 == 0.0);
-}
-cairo_bool_t
-_cairo_matrix_is_translation (const cairo_matrix_t *matrix)
-{
-    return (matrix->xx == 1.0 && matrix->yx == 0.0 &&
-	    matrix->xy == 0.0 && matrix->yy == 1.0);
-}
 cairo_bool_t
 _cairo_matrix_is_integer_translation (const cairo_matrix_t *matrix,
 				      int *itx, int *ity)
+{
 _cairo_matrix_transformed_circle_major_axis (const cairo_matrix_t *matrix,
 					     double radius)
+{
     double  a, b, c, d, f, g, h, i, j;
+    if (_cairo_matrix_has_unity_scale (matrix))
+	return radius;
     _cairo_matrix_get_affine (matrix,
                               &a, &b,
                               &c, &d,
      * we don't need the minor axis length, which is
      * double min = radius * sqrt (f - sqrt (g*g+h*h));
      */
+}
-void
-_cairo_matrix_to_pixman_matrix (const cairo_matrix_t	*matrix,
-				pixman_transform_t	*pixman_transform,
-				double xc,
-				double yc)
-    static const pixman_transform_t pixman_identity_transform = {{
+static const pixman_transform_t pixman_identity_transform = {{
         {1 << 16,        0,       0},
         {       0, 1 << 16,       0},
         {       0,       0, 1 << 16}
+    }};
-    }};
+static cairo_status_t
+_cairo_matrix_to_pixman_matrix (const cairo_matrix_t	*matrix,
-    if (_cairo_matrix_is_identity (matrix)) {
+				pixman_transform_t	*pixman_transform,
+				double xc,
-        *pixman_transform = pixman_identity_transform;
+				double yc)
     } else {
-        cairo_matrix_t inv;
+    cairo_matrix_t inv;
-	unsigned max_iterations;
+    unsigned max_iterations;
-         * space and adjust pixman's transform to agree with cairo's at
+     * space and adjust pixman's transform to agree with cairo's at
-         * that point.
+     * that point.
-	 */
+     */
+    if (_cairo_matrix_has_unity_scale (matrix))
+	return CAIRO_STATUS_SUCCESS;
+    if (unlikely (fabs (matrix->xx) > PIXMAN_MAX_INT ||
+		  fabs (matrix->xy) > PIXMAN_MAX_INT ||
+		  fabs (matrix->x0) > PIXMAN_MAX_INT ||
+		  fabs (matrix->yx) > PIXMAN_MAX_INT ||
+		  fabs (matrix->yy) > PIXMAN_MAX_INT ||
-	if (_cairo_matrix_has_unity_scale (matrix))
+		  fabs (matrix->y0) > PIXMAN_MAX_INT))
+    {
+	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
 	    return;
-        /* Note: If we can't invert the transformation, skip the adjustment. */
+    /* Note: If we can't invert the transformation, skip the adjustment. */
-        inv = *matrix;
+    inv = *matrix;
-        if (cairo_matrix_invert (&inv) != CAIRO_STATUS_SUCCESS)
+    if (cairo_matrix_invert (&inv) != CAIRO_STATUS_SUCCESS)
-            return;
 	return CAIRO_STATUS_SUCCESS;
         /* find the pattern space coordinate that maps to (xc, yc) */
-	xc += .5; yc += .5; /* offset for the pixel centre */
+    /* find the pattern space coordinate that maps to (xc, yc) */
-	max_iterations = 5;
+    max_iterations = 5;
-	do {
+    do {
-	    double x,y;
+	double x,y;
-	    pixman_vector_t vector;
+	pixman_vector_t vector;
-	    cairo_fixed_16_16_t dx, dy;
+	cairo_fixed_16_16_t dx, dy;
 	vector.vector[0] = _cairo_fixed_16_16_from_double (xc);
-	    vector.vector[0] = _cairo_fixed_16_16_from_double (xc);
+	vector.vector[1] = _cairo_fixed_16_16_from_double (yc);
-	    vector.vector[1] = _cairo_fixed_16_16_from_double (yc);
+	vector.vector[2] = 1 << 16;
 	    vector.vector[2] = 1 << 16;
 	/* If we can't transform the reference point, skip the adjustment. */
-	    dy = _cairo_fixed_16_16_from_double (y);
+	dy = _cairo_fixed_16_16_from_double (y);
-	    pixman_transform->matrix[0][2] -= dx;
+	pixman_transform->matrix[0][2] -= dx;
-	    pixman_transform->matrix[1][2] -= dy;
+	pixman_transform->matrix[1][2] -= dy;
-	    if (dx == 0 && dy == 0)
+	if (dx == 0 && dy == 0)
-		break;
+	    return CAIRO_STATUS_SUCCESS;
+    } while (--max_iterations);
+    /* We didn't find an exact match between cairo and pixman, but
+     * the matrix should be mostly correct */
+    return CAIRO_STATUS_SUCCESS;
+}
+static inline double
+_pixman_nearest_sample (double d)
+{
+    return ceil (d - .5);
+}
+/**
+ * _cairo_matrix_is_pixman_translation:
+ * @matrix: a matrix
+ * @filter: the filter to be used on the pattern transformed by @matrix
+ * @x_offset: the translation in the X direction
+ * @y_offset: the translation in the Y direction
+ *
+ * Checks if @matrix translated by (x_offset, y_offset) can be
+ * represented using just an offset (within the range pixman can
+ * accept) and an identity matrix.
+ *
+ * Passing a non-zero value in x_offset/y_offset has the same effect
+ * as applying cairo_matrix_translate(matrix, x_offset, y_offset) and
+ * setting x_offset and y_offset to 0.
+ *
+ * Upon return x_offset and y_offset contain the translation vector if
+ * the return value is %TRUE. If the return value is %FALSE, they will
+ * not be modified.
+ *
+ * Return value: %TRUE if @matrix can be represented as a pixman
+ * translation, %FALSE otherwise.
+ **/
+cairo_bool_t
+_cairo_matrix_is_pixman_translation (const cairo_matrix_t     *matrix,
+				     cairo_filter_t            filter,
+				     int                      *x_offset,
+				     int                      *y_offset)
+{
+    double tx, ty;
+    if (!_cairo_matrix_is_translation (matrix))
+	return FALSE;
+    if (matrix->x0 == 0. && matrix->y0 == 0.)
+	return TRUE;
+    tx = matrix->x0 + *x_offset;
+    ty = matrix->y0 + *y_offset;
+    if (filter == CAIRO_FILTER_FAST || filter == CAIRO_FILTER_NEAREST) {
+	tx = _pixman_nearest_sample (tx);
+	ty = _pixman_nearest_sample (ty);
+    } else if (tx != floor (tx) || ty != floor (ty)) {
+	return FALSE;
+    }
+    if (fabs (tx) > PIXMAN_MAX_INT || fabs (ty) > PIXMAN_MAX_INT)
+	return FALSE;
+    *x_offset = _cairo_lround (tx);
+    *y_offset = _cairo_lround (ty);
+    return TRUE;
+}
+/**
+ * _cairo_matrix_to_pixman_matrix_offset:
+ * @matrix: a matrix
+ * @filter: the filter to be used on the pattern transformed by @matrix
+ * @xc: the X coordinate of the point to fix in pattern space
+ * @yc: the Y coordinate of the point to fix in pattern space
+ * @out_transform: the transformation which best approximates @matrix
+ * @x_offset: the translation in the X direction
+ * @y_offset: the translation in the Y direction
+ *
+ * This function tries to represent @matrix translated by (x_offset,
+ * y_offset) as a %pixman_transform_t and an translation.
+ *
+ * Passing a non-zero value in x_offset/y_offset has the same effect
+ * as applying cairo_matrix_translate(matrix, x_offset, y_offset) and
+ * setting x_offset and y_offset to 0.
+ *
+ * If it is possible to represent the matrix with an identity
+ * %pixman_transform_t and a translation within the valid range for
+ * pixman, this function will set @out_transform to be the identity,
+ * @x_offset and @y_offset to be the translation vector and will
+ * return %CAIRO_INT_STATUS_NOTHING_TO_DO. Otherwise it will try to
+ * evenly divide the translational component of @matrix between
+ * @out_transform and (@x_offset, @y_offset).
+ *
+ * Upon return x_offset and y_offset contain the translation vector.
+ *
+ * Return value: %CAIRO_INT_STATUS_NOTHING_TO_DO if the out_transform
+ * is the identity, %CAIRO_STATUS_INVALID_MATRIX if it was not
+ * possible to represent @matrix as a pixman_transform_t without
+ * overflows, %CAIRO_STATUS_SUCCESS otherwise.
+ **/
+cairo_status_t
+_cairo_matrix_to_pixman_matrix_offset (const cairo_matrix_t	*matrix,
+				       cairo_filter_t            filter,
+				       double                    xc,
+				       double                    yc,
+				       pixman_transform_t	*out_transform,
+				       int                      *x_offset,
+				       int                      *y_offset)
+{
+    cairo_bool_t is_pixman_translation;
+    is_pixman_translation = _cairo_matrix_is_pixman_translation (matrix,
+								 filter,
+								 x_offset,
+								 y_offset);
+    if (is_pixman_translation) {
+	*out_transform = pixman_identity_transform;
+	return CAIRO_INT_STATUS_NOTHING_TO_DO;
+    } else {
+	cairo_matrix_t m;
+	m = *matrix;
+	cairo_matrix_translate (&m, *x_offset, *y_offset);
+	if (m.x0 != 0.0 || m.y0 != 0.0) {
+	    double tx, ty, norm;
+	    int i, j;
+	    /* pixman also limits the [xy]_offset to 16 bits so evenly
+	     * spread the bits between the two.
+	     *
+	     * To do this, find the solutions of:
+	     *   |x| = |x*m.xx + y*m.xy + m.x0|
+	     *   |y| = |x*m.yx + y*m.yy + m.y0|
+	     *
+	     * and select the one whose maximum norm is smallest.
+	     */
+	    tx = m.x0;
+	    ty = m.y0;
+	    norm = MAX (fabs (tx), fabs (ty));
+	    for (i = -1; i < 2; i+=2) {
+		for (j = -1; j < 2; j+=2) {
+		    double x, y, den, new_norm;
+		    den = (m.xx + i) * (m.yy + j) - m.xy * m.yx;
+		    if (fabs (den) < DBL_EPSILON)
+			continue;
+		    x = m.y0 * m.xy - m.x0 * (m.yy + j);
+		    y = m.x0 * m.yx - m.y0 * (m.xx + i);
+		    den = 1 / den;
+		    x *= den;
+		    y *= den;
+		    new_norm = MAX (fabs (x), fabs (y));
+		    if (norm > new_norm) {
+			norm = new_norm;
+			tx = x;
+			ty = y;
+		    }
+		}
+	    }
+	    tx = floor (tx);
+	    ty = floor (ty);
+	    *x_offset = -tx;
+	    *y_offset = -ty;
+	    cairo_matrix_translate (&m, tx, ty);
+	} else {
+	    *x_offset = 0;
+	    *y_offset = 0;
+	}
-	} while (--max_iterations);
+	return _cairo_matrix_to_pixman_matrix (&m, out_transform, xc, yc);
+    }

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-matrix.c – Rev 1892 → 3959