dlls/gdiplus/matrix.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <math.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25
  26 #include "objbase.h"
  27
  28 #include "gdiplus.h"
  29 #include "gdiplus_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  33
  34 /* Multiplies two matrices of the form
  35  *
  36  * idx:0 idx:1     0
  37  * idx:2 idx:3     0
  38  * idx:4 idx:5     1
  39  *
  40  * and puts the output in out.
  41  * */
  42 static inline void matrix_multiply(GDIPCONST REAL * left, GDIPCONST REAL * right, REAL * out)
  43 {
  44     REAL temp[6];
  45     temp[0] = left[0] * right[0] + left[1] * right[2];
  46     temp[1] = left[0] * right[1] + left[1] * right[3];
  47     temp[2] = left[2] * right[0] + left[3] * right[2];
  48     temp[3] = left[2] * right[1] + left[3] * right[3];
  49     temp[4] = left[4] * right[0] + left[5] * right[2] + right[4];
  50     temp[5] = left[4] * right[1] + left[5] * right[3] + right[5];
  51     memcpy(out, temp, 6 * sizeof(REAL));
  52 }
  53
  54 static REAL matrix_det(GDIPCONST GpMatrix *matrix)
  55 {
  56     return matrix->matrix[0]*matrix->matrix[3] - matrix->matrix[1]*matrix->matrix[2];
  57 }
  58
  59 GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22,
  60     REAL dx, REAL dy, GpMatrix **matrix)
  61 {
  62     TRACE("(%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p)\n", m11, m12, m21, m22, dx, dy, matrix);
  63
  64     if(!matrix)
  65         return InvalidParameter;
  66
  67     *matrix = heap_alloc_zero(sizeof(GpMatrix));
  68     if(!*matrix)    return OutOfMemory;
  69
  70     /* first row */
  71     (*matrix)->matrix[0] = m11;
  72     (*matrix)->matrix[1] = m12;
  73     /* second row */
  74     (*matrix)->matrix[2] = m21;
  75     (*matrix)->matrix[3] = m22;
  76     /* third row */
  77     (*matrix)->matrix[4] = dx;
  78     (*matrix)->matrix[5] = dy;
  79
  80     return Ok;
  81 }
  82
  83 GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF *rect,
  84     GDIPCONST GpPointF *pt, GpMatrix **matrix)
  85 {
  86     REAL m11, m12, m21, m22, dx, dy;
  87
  88     TRACE("(%s, %p, %p)\n", debugstr_rectf(rect), pt, matrix);
  89
  90     if(!matrix || !pt)
  91         return InvalidParameter;
  92
  93     m11 = (pt[1].X - pt[0].X) / rect->Width;
  94     m21 = (pt[2].X - pt[0].X) / rect->Height;
  95     dx = pt[0].X - m11 * rect->X - m21 * rect->Y;
  96     m12 = (pt[1].Y - pt[0].Y) / rect->Width;
  97     m22 = (pt[2].Y - pt[0].Y) / rect->Height;
  98     dy = pt[0].Y - m12 * rect->X - m22 * rect->Y;
  99
 100     return GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, matrix);
 101 }
 102
 103 GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect *rect, GDIPCONST GpPoint *pt,
 104     GpMatrix **matrix)
 105 {
 106     GpRectF rectF;
 107     GpPointF ptF[3];
 108     int i;
 109
 110     TRACE("(%p, %p, %p)\n", rect, pt, matrix);
 111
 112     set_rect(&rectF, rect->X, rect->Y, rect->Width, rect->Height);
 113
 114     for (i = 0; i < 3; i++) {
 115         ptF[i].X = (REAL)pt[i].X;
 116         ptF[i].Y = (REAL)pt[i].Y;
 117     }
 118     return GdipCreateMatrix3(&rectF, ptF, matrix);
 119 }
 120
 121 GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix *matrix, GpMatrix **clone)
 122 {
 123     TRACE("(%s, %p)\n", debugstr_matrix(matrix), clone);
 124
 125     if(!matrix || !clone)
 126         return InvalidParameter;
 127
 128     *clone = heap_alloc_zero(sizeof(GpMatrix));
 129     if(!*clone)    return OutOfMemory;
 130
 131     **clone = *matrix;
 132
 133     return Ok;
 134 }
 135
 136 GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
 137 {
 138     TRACE("(%p)\n", matrix);
 139
 140     if(!matrix)
 141         return InvalidParameter;
 142
 143     *matrix = heap_alloc_zero(sizeof(GpMatrix));
 144     if(!*matrix)    return OutOfMemory;
 145
 146     (*matrix)->matrix[0] = 1.0;
 147     (*matrix)->matrix[1] = 0.0;
 148     (*matrix)->matrix[2] = 0.0;
 149     (*matrix)->matrix[3] = 1.0;
 150     (*matrix)->matrix[4] = 0.0;
 151     (*matrix)->matrix[5] = 0.0;
 152
 153     return Ok;
 154 }
 155
 156 GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
 157 {
 158     TRACE("(%p)\n", matrix);
 159
 160     if(!matrix)
 161         return InvalidParameter;
 162
 163     heap_free(matrix);
 164
 165     return Ok;
 166 }
 167
 168 GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix,
 169     REAL *out)
 170 {
 171     TRACE("(%s, %p)\n", debugstr_matrix(matrix), out);
 172
 173     if(!matrix || !out)
 174         return InvalidParameter;
 175
 176     memcpy(out, matrix->matrix, sizeof(matrix->matrix));
 177
 178     return Ok;
 179 }
 180
 181 GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix *matrix)
 182 {
 183     GpMatrix copy;
 184     REAL det;
 185
 186     TRACE("(%s)\n", debugstr_matrix(matrix));
 187
 188     if(!matrix)
 189         return InvalidParameter;
 190
 191     /* optimize inverting simple scaling and translation matrices */
 192     if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
 193     {
 194         if (matrix->matrix[0] != 0 && matrix->matrix[3] != 0)
 195         {
 196             matrix->matrix[4] = -matrix->matrix[4] / matrix->matrix[0];
 197             matrix->matrix[5] = -matrix->matrix[5] / matrix->matrix[3];
 198             matrix->matrix[0] = 1 / matrix->matrix[0];
 199             matrix->matrix[3] = 1 / matrix->matrix[3];
 200
 201             return Ok;
 202         }
 203         else
 204             return InvalidParameter;
 205     }
 206     det = matrix_det(matrix);
 207     if (!(fabs(det) >= 1e-5))
 208         return InvalidParameter;
 209
 210     det = 1 / det;
 211
 212     copy = *matrix;
 213     /* store result */
 214     matrix->matrix[0] =   copy.matrix[3] * det;
 215     matrix->matrix[1] =  -copy.matrix[1] * det;
 216     matrix->matrix[2] =  -copy.matrix[2] * det;
 217     matrix->matrix[3] =   copy.matrix[0] * det;
 218     matrix->matrix[4] =  (copy.matrix[2]*copy.matrix[5]-copy.matrix[3]*copy.matrix[4]) * det;
 219     matrix->matrix[5] = -(copy.matrix[0]*copy.matrix[5]-copy.matrix[1]*copy.matrix[4]) * det;
 220
 221     return Ok;
 222 }
 223
 224 GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix, BOOL *result)
 225 {
 226     TRACE("(%s, %p)\n", debugstr_matrix(matrix), result);
 227
 228     if(!matrix || !result)
 229         return InvalidParameter;
 230
 231     if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
 232         *result = matrix->matrix[0] != 0 && matrix->matrix[3] != 0;
 233     else
 234         *result = (fabs(matrix_det(matrix)) >= 1e-5);
 235
 236     return Ok;
 237 }
 238
 239 GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GDIPCONST GpMatrix* matrix2,
 240     GpMatrixOrder order)
 241 {
 242     TRACE("(%s, %s, %d)\n", debugstr_matrix(matrix), debugstr_matrix(matrix2), order);
 243
 244     if(!matrix || !matrix2)
 245         return InvalidParameter;
 246
 247     if(order == MatrixOrderAppend)
 248         matrix_multiply(matrix->matrix, matrix2->matrix, matrix->matrix);
 249     else if (order == MatrixOrderPrepend)
 250         matrix_multiply(matrix2->matrix, matrix->matrix, matrix->matrix);
 251     else
 252         return InvalidParameter;
 253
 254     return Ok;
 255 }
 256
 257 GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle,
 258     GpMatrixOrder order)
 259 {
 260     REAL cos_theta, sin_theta, rotate[6];
 261
 262     TRACE("(%p, %.2f, %d)\n", debugstr_matrix(matrix), angle, order);
 263
 264     if(!matrix)
 265         return InvalidParameter;
 266
 267     angle = deg2rad(angle);
 268     cos_theta = cos(angle);
 269     sin_theta = sin(angle);
 270
 271     rotate[0] = cos_theta;
 272     rotate[1] = sin_theta;
 273     rotate[2] = -sin_theta;
 274     rotate[3] = cos_theta;
 275     rotate[4] = 0.0;
 276     rotate[5] = 0.0;
 277
 278     if(order == MatrixOrderAppend)
 279         matrix_multiply(matrix->matrix, rotate, matrix->matrix);
 280     else if (order == MatrixOrderPrepend)
 281         matrix_multiply(rotate, matrix->matrix, matrix->matrix);
 282     else
 283         return InvalidParameter;
 284
 285     return Ok;
 286 }
 287
 288 GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY,
 289     GpMatrixOrder order)
 290 {
 291     TRACE("(%s, %.2f, %.2f, %d)\n", debugstr_matrix(matrix), scaleX, scaleY, order);
 292
 293     if(!matrix)
 294         return InvalidParameter;
 295
 296     if(order == MatrixOrderAppend)
 297     {
 298         matrix->matrix[0] *= scaleX;
 299         matrix->matrix[1] *= scaleY;
 300         matrix->matrix[2] *= scaleX;
 301         matrix->matrix[3] *= scaleY;
 302         matrix->matrix[4] *= scaleX;
 303         matrix->matrix[5] *= scaleY;
 304     }
 305     else if (order == MatrixOrderPrepend)
 306     {
 307         matrix->matrix[0] *= scaleX;
 308         matrix->matrix[1] *= scaleX;
 309         matrix->matrix[2] *= scaleY;
 310         matrix->matrix[3] *= scaleY;
 311     }
 312     else
 313         return InvalidParameter;
 314
 315     return Ok;
 316 }
 317
 318 GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12,
 319     REAL m21, REAL m22, REAL dx, REAL dy)
 320 {
 321     TRACE("(%s, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", debugstr_matrix(matrix), m11, m12,
 322             m21, m22, dx, dy);
 323
 324     if(!matrix)
 325         return InvalidParameter;
 326
 327     matrix->matrix[0] = m11;
 328     matrix->matrix[1] = m12;
 329     matrix->matrix[2] = m21;
 330     matrix->matrix[3] = m22;
 331     matrix->matrix[4] = dx;
 332     matrix->matrix[5] = dy;
 333
 334     return Ok;
 335 }
 336
 337 GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY,
 338     GpMatrixOrder order)
 339 {
 340     REAL shear[6];
 341
 342     TRACE("(%s, %.2f, %.2f, %d)\n", debugstr_matrix(matrix), shearX, shearY, order);
 343
 344     if(!matrix)
 345         return InvalidParameter;
 346
 347     /* prepare transformation matrix */
 348     shear[0] = 1.0;
 349     shear[1] = shearY;
 350     shear[2] = shearX;
 351     shear[3] = 1.0;
 352     shear[4] = 0.0;
 353     shear[5] = 0.0;
 354
 355     if(order == MatrixOrderAppend)
 356         matrix_multiply(matrix->matrix, shear, matrix->matrix);
 357     else if (order == MatrixOrderPrepend)
 358         matrix_multiply(shear, matrix->matrix, matrix->matrix);
 359     else
 360         return InvalidParameter;
 361
 362     return Ok;
 363 }
 364
 365 GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts,
 366                                               INT count)
 367 {
 368     REAL x, y;
 369     INT i;
 370
 371     TRACE("(%s, %p, %d)\n", debugstr_matrix(matrix), pts, count);
 372
 373     if(!matrix || !pts || count <= 0)
 374         return InvalidParameter;
 375
 376     for(i = 0; i < count; i++)
 377     {
 378         x = pts[i].X;
 379         y = pts[i].Y;
 380
 381         pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2] + matrix->matrix[4];
 382         pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3] + matrix->matrix[5];
 383     }
 384
 385     return Ok;
 386 }
 387
 388 GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count)
 389 {
 390     GpPointF *ptsF;
 391     GpStatus ret;
 392     INT i;
 393
 394     TRACE("(%s, %p, %d)\n", debugstr_matrix(matrix), pts, count);
 395
 396     if(count <= 0)
 397         return InvalidParameter;
 398
 399     ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
 400     if(!ptsF)
 401         return OutOfMemory;
 402
 403     for(i = 0; i < count; i++){
 404         ptsF[i].X = (REAL)pts[i].X;
 405         ptsF[i].Y = (REAL)pts[i].Y;
 406     }
 407
 408     ret = GdipTransformMatrixPoints(matrix, ptsF, count);
 409
 410     if(ret == Ok)
 411         for(i = 0; i < count; i++){
 412             pts[i].X = gdip_round(ptsF[i].X);
 413             pts[i].Y = gdip_round(ptsF[i].Y);
 414         }
 415     heap_free(ptsF);
 416
 417     return ret;
 418 }
 419
 420 GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX,
 421     REAL offsetY, GpMatrixOrder order)
 422 {
 423     TRACE("(%s, %.2f, %.2f, %d)\n", debugstr_matrix(matrix), offsetX, offsetY, order);
 424
 425     if(!matrix)
 426         return InvalidParameter;
 427
 428     if(order == MatrixOrderAppend)
 429     {
 430         matrix->matrix[4] += offsetX;
 431         matrix->matrix[5] += offsetY;
 432     }
 433     else if (order == MatrixOrderPrepend)
 434     {
 435         matrix->matrix[4] = offsetX * matrix->matrix[0] + offsetY * matrix->matrix[2]
 436             + matrix->matrix[4];
 437         matrix->matrix[5] = offsetX * matrix->matrix[1] + offsetY * matrix->matrix[3]
 438             + matrix->matrix[5];
 439     }
 440     else
 441         return InvalidParameter;
 442
 443     return Ok;
 444 }
 445
 446 GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts, INT count)
 447 {
 448     REAL x, y;
 449     INT i;
 450
 451     TRACE("(%s, %p, %d)\n", debugstr_matrix(matrix), pts, count);
 452
 453     if(!matrix || !pts || count <= 0)
 454         return InvalidParameter;
 455
 456     for(i = 0; i < count; i++)
 457     {
 458         x = pts[i].X;
 459         y = pts[i].Y;
 460
 461         pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2];
 462         pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3];
 463     }
 464
 465     return Ok;
 466 }
 467
 468 GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count)
 469 {
 470     GpPointF *ptsF;
 471     GpStatus ret;
 472     INT i;
 473
 474     TRACE("(%s, %p, %d)\n", debugstr_matrix(matrix), pts, count);
 475
 476     if(count <= 0)
 477         return InvalidParameter;
 478
 479     ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
 480     if(!ptsF)
 481         return OutOfMemory;
 482
 483     for(i = 0; i < count; i++){
 484         ptsF[i].X = (REAL)pts[i].X;
 485         ptsF[i].Y = (REAL)pts[i].Y;
 486     }
 487
 488     ret = GdipVectorTransformMatrixPoints(matrix, ptsF, count);
 489     /* store back */
 490     if(ret == Ok)
 491         for(i = 0; i < count; i++){
 492             pts[i].X = gdip_round(ptsF[i].X);
 493             pts[i].Y = gdip_round(ptsF[i].Y);
 494         }
 495     heap_free(ptsF);
 496
 497     return ret;
 498 }
 499
 500 GpStatus WINGDIPAPI GdipIsMatrixEqual(GDIPCONST GpMatrix *matrix, GDIPCONST GpMatrix *matrix2,
 501     BOOL *result)
 502 {
 503     TRACE("(%s, %s, %p)\n", debugstr_matrix(matrix), debugstr_matrix(matrix2), result);
 504
 505     if(!matrix || !matrix2 || !result)
 506         return InvalidParameter;
 507     /* based on single array member of GpMatrix */
 508     *result = (memcmp(matrix->matrix, matrix2->matrix, sizeof(GpMatrix)) == 0);
 509
 510     return Ok;
 511 }
 512
 513 GpStatus WINGDIPAPI GdipIsMatrixIdentity(GDIPCONST GpMatrix *matrix, BOOL *result)
 514 {
 515     static const GpMatrix identity =
 516     {
 517       { 1.0, 0.0,
 518         0.0, 1.0,
 519         0.0, 0.0 }
 520     };
 521
 522     TRACE("(%s, %p)\n", debugstr_matrix(matrix), result);
 523
 524     if(!matrix || !result)
 525         return InvalidParameter;
 526
 527     return GdipIsMatrixEqual(matrix, &identity, result);
 528 }