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