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 void matrix_multiply(GDIPCONST REAL * left, GDIPCONST REAL * right, REAL * out)
  43 {
  44     REAL temp[6];
  45     int i, odd;
  46
  47     for(i = 0; i < 6; i++){
  48         odd = i % 2;
  49         temp[i] = left[i - odd] * right[odd] + left[i - odd + 1] * right[odd + 2] +
  50                   (i >= 4 ? right[odd + 4] : 0.0);
  51     }
  52
  53     memcpy(out, temp, 6 * sizeof(REAL));
  54 }
  55
  56 static REAL matrix_det(GDIPCONST GpMatrix *matrix)
  57 {
  58     return matrix->matrix[0]*matrix->matrix[3] - matrix->matrix[1]*matrix->matrix[2];
  59 }
  60
  61 GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22,
  62     REAL dx, REAL dy, GpMatrix **matrix)
  63 {
  64     TRACE("(%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p)\n", m11, m12, m21, m22, dx, dy, matrix);
  65
  66     if(!matrix)
  67         return InvalidParameter;
  68
  69     *matrix = heap_alloc_zero(sizeof(GpMatrix));
  70     if(!*matrix)    return OutOfMemory;
  71
  72     /* first row */
  73     (*matrix)->matrix[0] = m11;
  74     (*matrix)->matrix[1] = m12;
  75     /* second row */
  76     (*matrix)->matrix[2] = m21;
  77     (*matrix)->matrix[3] = m22;
  78     /* third row */
  79     (*matrix)->matrix[4] = dx;
  80     (*matrix)->matrix[5] = dy;
  81
  82     return Ok;
  83 }
  84
  85 GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF *rect,
  86     GDIPCONST GpPointF *pt, GpMatrix **matrix)
  87 {
  88     REAL m11, m12, m21, m22, dx, dy;
  89
  90     TRACE("(%s, %p, %p)\n", debugstr_rectf(rect), pt, matrix);
  91
  92     if(!matrix || !pt)
  93         return InvalidParameter;
  94
  95     m11 = (pt[1].X - pt[0].X) / rect->Width;
  96     m21 = (pt[2].X - pt[0].X) / rect->Height;
  97     dx = pt[0].X - m11 * rect->X - m21 * rect->Y;
  98     m12 = (pt[1].Y - pt[0].Y) / rect->Width;
  99     m22 = (pt[2].Y - pt[0].Y) / rect->Height;
 100     dy = pt[0].Y - m12 * rect->X - m22 * rect->Y;
 101
 102     return GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, matrix);
 103 }
 104
 105 GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect *rect, GDIPCONST GpPoint *pt,
 106     GpMatrix **matrix)
 107 {
 108     GpRectF rectF;
 109     GpPointF ptF[3];
 110     int i;
 111
 112     TRACE("(%p, %p, %p)\n", rect, pt, matrix);
 113
 114     rectF.X = (REAL)rect->X;
 115     rectF.Y = (REAL)rect->Y;
 116     rectF.Width = (REAL)rect->Width;
 117     rectF.Height = (REAL)rect->Height;
 118
 119     for (i = 0; i < 3; i++) {
 120         ptF[i].X = (REAL)pt[i].X;
 121         ptF[i].Y = (REAL)pt[i].Y;
 122     }
 123     return GdipCreateMatrix3(&rectF, ptF, matrix);
 124 }
 125
 126 GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix *matrix, GpMatrix **clone)
 127 {
 128     TRACE("(%p, %p)\n", matrix, clone);
 129
 130     if(!matrix || !clone)
 131         return InvalidParameter;
 132
 133     *clone = heap_alloc_zero(sizeof(GpMatrix));
 134     if(!*clone)    return OutOfMemory;
 135
 136     **clone = *matrix;
 137
 138     return Ok;
 139 }
 140
 141 GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
 142 {
 143     TRACE("(%p)\n", matrix);
 144
 145     if(!matrix)
 146         return InvalidParameter;
 147
 148     *matrix = heap_alloc_zero(sizeof(GpMatrix));
 149     if(!*matrix)    return OutOfMemory;
 150
 151     (*matrix)->matrix[0] = 1.0;
 152     (*matrix)->matrix[1] = 0.0;
 153     (*matrix)->matrix[2] = 0.0;
 154     (*matrix)->matrix[3] = 1.0;
 155     (*matrix)->matrix[4] = 0.0;
 156     (*matrix)->matrix[5] = 0.0;
 157
 158     return Ok;
 159 }
 160
 161 GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
 162 {
 163     TRACE("(%p)\n", matrix);
 164
 165     if(!matrix)
 166         return InvalidParameter;
 167
 168     heap_free(matrix);
 169
 170     return Ok;
 171 }
 172
 173 GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix,
 174     REAL *out)
 175 {
 176     TRACE("(%p, %p)\n", matrix, out);
 177
 178     if(!matrix || !out)
 179         return InvalidParameter;
 180
 181     memcpy(out, matrix->matrix, sizeof(matrix->matrix));
 182
 183     return Ok;
 184 }
 185
 186 GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix *matrix)
 187 {
 188     GpMatrix copy;
 189     REAL det;
 190     BOOL invertible;
 191
 192     TRACE("(%p)\n", matrix);
 193
 194     if(!matrix)
 195         return InvalidParameter;
 196
 197     GdipIsMatrixInvertible(matrix, &invertible);
 198     if(!invertible)
 199         return InvalidParameter;
 200
 201     /* optimize inverting simple scaling and translation matrices */
 202     if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
 203     {
 204         matrix->matrix[4] = -matrix->matrix[4] / matrix->matrix[0];
 205         matrix->matrix[5] = -matrix->matrix[5] / matrix->matrix[3];
 206         matrix->matrix[0] = 1 / matrix->matrix[0];
 207         matrix->matrix[3] = 1 / matrix->matrix[3];
 208
 209         return Ok;
 210     }
 211
 212     det = matrix_det(matrix);
 213
 214     copy = *matrix;
 215     /* store result */
 216     matrix->matrix[0] =   copy.matrix[3] / det;
 217     matrix->matrix[1] =  -copy.matrix[1] / det;
 218     matrix->matrix[2] =  -copy.matrix[2] / det;
 219     matrix->matrix[3] =   copy.matrix[0] / det;
 220     matrix->matrix[4] =  (copy.matrix[2]*copy.matrix[5]-copy.matrix[3]*copy.matrix[4]) / det;
 221     matrix->matrix[5] = -(copy.matrix[0]*copy.matrix[5]-copy.matrix[1]*copy.matrix[4]) / det;
 222
 223     return Ok;
 224 }
 225
 226 GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix, BOOL *result)
 227 {
 228     TRACE("(%p, %p)\n", matrix, result);
 229
 230     if(!matrix || !result)
 231         return InvalidParameter;
 232
 233     if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
 234         *result = matrix->matrix[0] != 0 && matrix->matrix[3] != 0;
 235     else
 236         *result = (fabs(matrix_det(matrix)) >= 1e-5);
 237
 238     return Ok;
 239 }
 240
 241 GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GDIPCONST GpMatrix* matrix2,
 242     GpMatrixOrder order)
 243 {
 244     TRACE("(%p, %p, %d)\n", matrix, matrix2, order);
 245
 246     if(!matrix || !matrix2)
 247         return InvalidParameter;
 248
 249     if(order == MatrixOrderAppend)
 250         matrix_multiply(matrix->matrix, matrix2->matrix, matrix->matrix);
 251     else if (order == MatrixOrderPrepend)
 252         matrix_multiply(matrix2->matrix, matrix->matrix, matrix->matrix);
 253     else
 254         return InvalidParameter;
 255
 256     return Ok;
 257 }
 258
 259 GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle,
 260     GpMatrixOrder order)
 261 {
 262     REAL cos_theta, sin_theta, rotate[6];
 263
 264     TRACE("(%p, %.2f, %d)\n", matrix, angle, order);
 265
 266     if(!matrix)
 267         return InvalidParameter;
 268
 269     angle = deg2rad(angle);
 270     cos_theta = cos(angle);
 271     sin_theta = sin(angle);
 272
 273     rotate[0] = cos_theta;
 274     rotate[1] = sin_theta;
 275     rotate[2] = -sin_theta;
 276     rotate[3] = cos_theta;
 277     rotate[4] = 0.0;
 278     rotate[5] = 0.0;
 279
 280     if(order == MatrixOrderAppend)
 281         matrix_multiply(matrix->matrix, rotate, matrix->matrix);
 282     else if (order == MatrixOrderPrepend)
 283         matrix_multiply(rotate, matrix->matrix, matrix->matrix);
 284     else
 285         return InvalidParameter;
 286
 287     return Ok;
 288 }
 289
 290 GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY,
 291     GpMatrixOrder order)
 292 {
 293     REAL scale[6];
 294
 295     TRACE("(%p, %.2f, %.2f, %d)\n", matrix, scaleX, scaleY, order);
 296
 297     if(!matrix)
 298         return InvalidParameter;
 299
 300     scale[0] = scaleX;
 301     scale[1] = 0.0;
 302     scale[2] = 0.0;
 303     scale[3] = scaleY;
 304     scale[4] = 0.0;
 305     scale[5] = 0.0;
 306
 307     if(order == MatrixOrderAppend)
 308         matrix_multiply(matrix->matrix, scale, matrix->matrix);
 309     else if (order == MatrixOrderPrepend)
 310         matrix_multiply(scale, matrix->matrix, matrix->matrix);
 311     else
 312         return InvalidParameter;
 313
 314     return Ok;
 315 }
 316
 317 GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12,
 318     REAL m21, REAL m22, REAL dx, REAL dy)
 319 {
 320     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", matrix, m11, m12,
 321             m21, m22, dx, dy);
 322
 323     if(!matrix)
 324         return InvalidParameter;
 325
 326     matrix->matrix[0] = m11;
 327     matrix->matrix[1] = m12;
 328     matrix->matrix[2] = m21;
 329     matrix->matrix[3] = m22;
 330     matrix->matrix[4] = dx;
 331     matrix->matrix[5] = dy;
 332
 333     return Ok;
 334 }
 335
 336 GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY,
 337     GpMatrixOrder order)
 338 {
 339     REAL shear[6];
 340
 341     TRACE("(%p, %.2f, %.2f, %d)\n", matrix, shearX, shearY, order);
 342
 343     if(!matrix)
 344         return InvalidParameter;
 345
 346     /* prepare transformation matrix */
 347     shear[0] = 1.0;
 348     shear[1] = shearY;
 349     shear[2] = shearX;
 350     shear[3] = 1.0;
 351     shear[4] = 0.0;
 352     shear[5] = 0.0;
 353
 354     if(order == MatrixOrderAppend)
 355         matrix_multiply(matrix->matrix, shear, matrix->matrix);
 356     else if (order == MatrixOrderPrepend)
 357         matrix_multiply(shear, matrix->matrix, matrix->matrix);
 358     else
 359         return InvalidParameter;
 360
 361     return Ok;
 362 }
 363
 364 GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts,
 365                                               INT count)
 366 {
 367     REAL x, y;
 368     INT i;
 369
 370     TRACE("(%p, %p, %d)\n", matrix, pts, count);
 371
 372     if(!matrix || !pts || count <= 0)
 373         return InvalidParameter;
 374
 375     for(i = 0; i < count; i++)
 376     {
 377         x = pts[i].X;
 378         y = pts[i].Y;
 379
 380         pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2] + matrix->matrix[4];
 381         pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3] + matrix->matrix[5];
 382     }
 383
 384     return Ok;
 385 }
 386
 387 GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count)
 388 {
 389     GpPointF *ptsF;
 390     GpStatus ret;
 391     INT i;
 392
 393     TRACE("(%p, %p, %d)\n", matrix, pts, count);
 394
 395     if(count <= 0)
 396         return InvalidParameter;
 397
 398     ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
 399     if(!ptsF)
 400         return OutOfMemory;
 401
 402     for(i = 0; i < count; i++){
 403         ptsF[i].X = (REAL)pts[i].X;
 404         ptsF[i].Y = (REAL)pts[i].Y;
 405     }
 406
 407     ret = GdipTransformMatrixPoints(matrix, ptsF, count);
 408
 409     if(ret == Ok)
 410         for(i = 0; i < count; i++){
 411             pts[i].X = gdip_round(ptsF[i].X);
 412             pts[i].Y = gdip_round(ptsF[i].Y);
 413         }
 414     heap_free(ptsF);
 415
 416     return ret;
 417 }
 418
 419 GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX,
 420     REAL offsetY, GpMatrixOrder order)
 421 {
 422     REAL translate[6];
 423
 424     TRACE("(%p, %.2f, %.2f, %d)\n", matrix, offsetX, offsetY, order);
 425
 426     if(!matrix)
 427         return InvalidParameter;
 428
 429     translate[0] = 1.0;
 430     translate[1] = 0.0;
 431     translate[2] = 0.0;
 432     translate[3] = 1.0;
 433     translate[4] = offsetX;
 434     translate[5] = offsetY;
 435
 436     if(order == MatrixOrderAppend)
 437         matrix_multiply(matrix->matrix, translate, matrix->matrix);
 438     else if (order == MatrixOrderPrepend)
 439         matrix_multiply(translate, matrix->matrix, matrix->matrix);
 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("(%p, %p, %d)\n", 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("(%p, %p, %d)\n", 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("(%p, %p, %p)\n", 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("(%p, %p)\n", matrix, result);
 523
 524     if(!matrix || !result)
 525         return InvalidParameter;
 526
 527     return GdipIsMatrixEqual(matrix, &identity, result);
 528 }