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