basegfx/source/matrix/b2dhommatrixtools.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  21
  22 #include <osl/diagnose.h>
  23 #include <rtl/ustring.hxx>
  24 #include <rtl/ustrbuf.hxx>
  25
  26 namespace basegfx
  27 {
  28     namespace utils
  29     {
  30         void createSinCosOrthogonal(double& o_rSin, double& o_rCos, double fRadiant)
  31         {
  32             if( fTools::equalZero( fmod( fRadiant, F_PI2 ) ) )
  33             {
  34                 // determine quadrant
  35                 const sal_Int32 nQuad(
  36                     (4 + fround( 4/F_2PI*fmod( fRadiant, F_2PI ) )) % 4 );
  37                 switch( nQuad )
  38                 {
  39                     case 0: // -2pi,0,2pi
  40                         o_rSin = 0.0;
  41                         o_rCos = 1.0;
  42                         break;
  43
  44                     case 1: // -3/2pi,1/2pi
  45                         o_rSin = 1.0;
  46                         o_rCos = 0.0;
  47                         break;
  48
  49                     case 2: // -pi,pi
  50                         o_rSin = 0.0;
  51                         o_rCos = -1.0;
  52                         break;
  53
  54                     case 3: // -1/2pi,3/2pi
  55                         o_rSin = -1.0;
  56                         o_rCos = 0.0;
  57                         break;
  58
  59                     default:
  60                         OSL_FAIL( "createSinCos: Impossible case reached" );
  61                 }
  62             }
  63             else
  64             {
  65                 // TODO(P1): Maybe use glibc's sincos here (though
  66                 // that's kinda non-portable...)
  67                 o_rSin = sin(fRadiant);
  68                 o_rCos = cos(fRadiant);
  69             }
  70         }
  71
  72         B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY)
  73         {
  74             B2DHomMatrix aRetval;
  75             const double fOne(1.0);
  76
  77             if(!fTools::equal(fScaleX, fOne))
  78             {
  79                 aRetval.set(0, 0, fScaleX);
  80             }
  81
  82             if(!fTools::equal(fScaleY, fOne))
  83             {
  84                 aRetval.set(1, 1, fScaleY);
  85             }
  86
  87             return aRetval;
  88         }
  89
  90         B2DHomMatrix createShearXB2DHomMatrix(double fShearX)
  91         {
  92             B2DHomMatrix aRetval;
  93
  94             if(!fTools::equalZero(fShearX))
  95             {
  96                 aRetval.set(0, 1, fShearX);
  97             }
  98
  99             return aRetval;
 100         }
 101
 102         B2DHomMatrix createShearYB2DHomMatrix(double fShearY)
 103         {
 104             B2DHomMatrix aRetval;
 105
 106             if(!fTools::equalZero(fShearY))
 107             {
 108                 aRetval.set(1, 0, fShearY);
 109             }
 110
 111             return aRetval;
 112         }
 113
 114         B2DHomMatrix createRotateB2DHomMatrix(double fRadiant)
 115         {
 116             B2DHomMatrix aRetval;
 117
 118             if(!fTools::equalZero(fRadiant))
 119             {
 120                 double fSin(0.0);
 121                 double fCos(1.0);
 122
 123                 createSinCosOrthogonal(fSin, fCos, fRadiant);
 124                 aRetval.set(0, 0, fCos);
 125                 aRetval.set(1, 1, fCos);
 126                 aRetval.set(1, 0, fSin);
 127                 aRetval.set(0, 1, -fSin);
 128             }
 129
 130             return aRetval;
 131         }
 132
 133         B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY)
 134         {
 135             B2DHomMatrix aRetval;
 136
 137             if(!(fTools::equalZero(fTranslateX) && fTools::equalZero(fTranslateY)))
 138             {
 139                 aRetval.set(0, 2, fTranslateX);
 140                 aRetval.set(1, 2, fTranslateY);
 141             }
 142
 143             return aRetval;
 144         }
 145
 146         B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
 147             double fScaleX, double fScaleY,
 148             double fShearX,
 149             double fRadiant,
 150             double fTranslateX, double fTranslateY)
 151         {
 152             const double fOne(1.0);
 153
 154             if(fTools::equal(fScaleX, fOne) && fTools::equal(fScaleY, fOne))
 155             {
 156                 /// no scale, take shortcut
 157                 return createShearXRotateTranslateB2DHomMatrix(fShearX, fRadiant, fTranslateX, fTranslateY);
 158             }
 159             else
 160             {
 161                 /// scale used
 162                 if(fTools::equalZero(fShearX))
 163                 {
 164                     /// no shear
 165                     if(fTools::equalZero(fRadiant))
 166                     {
 167                         /// no rotate, take shortcut
 168                         return createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, fTranslateX, fTranslateY);
 169                     }
 170                     else
 171                     {
 172                         /// rotate and scale used, no shear
 173                         double fSin(0.0);
 174                         double fCos(1.0);
 175
 176                         createSinCosOrthogonal(fSin, fCos, fRadiant);
 177
 178                         B2DHomMatrix aRetval(
 179                             /* Row 0, Column 0 */ fCos * fScaleX,
 180                             /* Row 0, Column 1 */ fScaleY * -fSin,
 181                             /* Row 0, Column 2 */ fTranslateX,
 182                             /* Row 1, Column 0 */ fSin * fScaleX,
 183                             /* Row 1, Column 1 */ fScaleY * fCos,
 184                             /* Row 1, Column 2 */ fTranslateY);
 185
 186                         return aRetval;
 187                     }
 188                 }
 189                 else
 190                 {
 191                     /// scale and shear used
 192                     if(fTools::equalZero(fRadiant))
 193                     {
 194                         /// scale and shear, but no rotate
 195                         B2DHomMatrix aRetval(
 196                             /* Row 0, Column 0 */ fScaleX,
 197                             /* Row 0, Column 1 */ fScaleY * fShearX,
 198                             /* Row 0, Column 2 */ fTranslateX,
 199                             /* Row 1, Column 0 */ 0.0,
 200                             /* Row 1, Column 1 */ fScaleY,
 201                             /* Row 1, Column 2 */ fTranslateY);
 202
 203                         return aRetval;
 204                     }
 205                     else
 206                     {
 207                         /// scale, shear and rotate used
 208                         double fSin(0.0);
 209                         double fCos(1.0);
 210
 211                         createSinCosOrthogonal(fSin, fCos, fRadiant);
 212
 213                         B2DHomMatrix aRetval(
 214                             /* Row 0, Column 0 */ fCos * fScaleX,
 215                             /* Row 0, Column 1 */ fScaleY * ((fCos * fShearX) - fSin),
 216                             /* Row 0, Column 2 */ fTranslateX,
 217                             /* Row 1, Column 0 */ fSin * fScaleX,
 218                             /* Row 1, Column 1 */ fScaleY * ((fSin * fShearX) + fCos),
 219                             /* Row 1, Column 2 */ fTranslateY);
 220
 221                         return aRetval;
 222                     }
 223                 }
 224             }
 225         }
 226
 227         B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
 228             double fShearX,
 229             double fRadiant,
 230             double fTranslateX, double fTranslateY)
 231         {
 232             if(fTools::equalZero(fShearX))
 233             {
 234                 /// no shear
 235                 if(fTools::equalZero(fRadiant))
 236                 {
 237                     /// no shear, no rotate, take shortcut
 238                     return createTranslateB2DHomMatrix(fTranslateX, fTranslateY);
 239                 }
 240                 else
 241                 {
 242                     /// no shear, but rotate used
 243                     double fSin(0.0);
 244                     double fCos(1.0);
 245
 246                     createSinCosOrthogonal(fSin, fCos, fRadiant);
 247
 248                     B2DHomMatrix aRetval(
 249                         /* Row 0, Column 0 */ fCos,
 250                         /* Row 0, Column 1 */ -fSin,
 251                         /* Row 0, Column 2 */ fTranslateX,
 252                         /* Row 1, Column 0 */ fSin,
 253                         /* Row 1, Column 1 */ fCos,
 254                         /* Row 1, Column 2 */ fTranslateY);
 255
 256                     return aRetval;
 257                 }
 258             }
 259             else
 260             {
 261                 /// shear used
 262                 if(fTools::equalZero(fRadiant))
 263                 {
 264                     /// no rotate, but shear used
 265                     B2DHomMatrix aRetval(
 266                         /* Row 0, Column 0 */ 1.0,
 267                         /* Row 0, Column 1 */ fShearX,
 268                         /* Row 0, Column 2 */ fTranslateX,
 269                         /* Row 1, Column 0 */ 0.0,
 270                         /* Row 1, Column 1 */ 1.0,
 271                         /* Row 1, Column 2 */ fTranslateY);
 272
 273                     return aRetval;
 274                 }
 275                 else
 276                 {
 277                     /// shear and rotate used
 278                     double fSin(0.0);
 279                     double fCos(1.0);
 280
 281                     createSinCosOrthogonal(fSin, fCos, fRadiant);
 282
 283                     B2DHomMatrix aRetval(
 284                         /* Row 0, Column 0 */ fCos,
 285                         /* Row 0, Column 1 */ (fCos * fShearX) - fSin,
 286                         /* Row 0, Column 2 */ fTranslateX,
 287                         /* Row 1, Column 0 */ fSin,
 288                         /* Row 1, Column 1 */ (fSin * fShearX) + fCos,
 289                         /* Row 1, Column 2 */ fTranslateY);
 290
 291                     return aRetval;
 292                 }
 293             }
 294         }
 295
 296         B2DHomMatrix createScaleTranslateB2DHomMatrix(
 297             double fScaleX, double fScaleY,
 298             double fTranslateX, double fTranslateY)
 299         {
 300             const double fOne(1.0);
 301
 302             if(fTools::equal(fScaleX, fOne) && fTools::equal(fScaleY, fOne))
 303             {
 304                 /// no scale, take shortcut
 305                 return createTranslateB2DHomMatrix(fTranslateX, fTranslateY);
 306             }
 307             else
 308             {
 309                 /// scale used
 310                 if(fTools::equalZero(fTranslateX) && fTools::equalZero(fTranslateY))
 311                 {
 312                     /// no translate, but scale.
 313                     B2DHomMatrix aRetval;
 314
 315                     aRetval.set(0, 0, fScaleX);
 316                     aRetval.set(1, 1, fScaleY);
 317
 318                     return aRetval;
 319                 }
 320                 else
 321                 {
 322                     /// translate and scale
 323                     B2DHomMatrix aRetval(
 324                         /* Row 0, Column 0 */ fScaleX,
 325                         /* Row 0, Column 1 */ 0.0,
 326                         /* Row 0, Column 2 */ fTranslateX,
 327                         /* Row 1, Column 0 */ 0.0,
 328                         /* Row 1, Column 1 */ fScaleY,
 329                         /* Row 1, Column 2 */ fTranslateY);
 330
 331                     return aRetval;
 332                 }
 333             }
 334         }
 335
 336         B2DHomMatrix createRotateAroundPoint(
 337             double fPointX, double fPointY,
 338             double fRadiant)
 339         {
 340             B2DHomMatrix aRetval;
 341
 342             if(!fTools::equalZero(fRadiant))
 343             {
 344                 double fSin(0.0);
 345                 double fCos(1.0);
 346
 347                 createSinCosOrthogonal(fSin, fCos, fRadiant);
 348
 349                 aRetval.set3x2(
 350                     /* Row 0, Column 0 */ fCos,
 351                     /* Row 0, Column 1 */ -fSin,
 352                     /* Row 0, Column 2 */ (fPointX * (1.0 - fCos)) + (fSin * fPointY),
 353                     /* Row 1, Column 0 */ fSin,
 354                     /* Row 1, Column 1 */ fCos,
 355                     /* Row 1, Column 2 */ (fPointY * (1.0 - fCos)) - (fSin * fPointX));
 356             }
 357
 358             return aRetval;
 359         }
 360
 361         BASEGFX_DLLPUBLIC B2DHomMatrix createRotateAroundCenterKeepAspectRatioStayInsideRange(
 362             const basegfx::B2DRange& rTargetRange,
 363             double fRotate)
 364         {
 365             basegfx::B2DHomMatrix aRetval;
 366
 367             // RotGrfFlyFrame: Create a transformation that maps the range inside of itself
 368             // so that it fits, takes as much space as possible and keeps the aspect ratio
 369             if(0.0 != fRotate)
 370             {
 371                 // Fit rotated graphic to center of available space, keeping page ratio:
 372                 // Adapt scaling ratio of unit object and rotate it
 373                 aRetval.scale(1.0, rTargetRange.getHeight() / rTargetRange.getWidth());
 374                 aRetval.rotate(fRotate);
 375
 376                 // get the range to see where we are in unit coordinates
 377                 basegfx::B2DRange aFullRange(0.0, 0.0, 1.0, 1.0);
 378                 aFullRange.transform(aRetval);
 379
 380                 // detect needed scales in X/Y and choose the smallest for staying inside the
 381                 // available space while keeping aspect ratio of the source
 382                 const double fScaleX(rTargetRange.getWidth() / aFullRange.getWidth());
 383                 const double fScaleY(rTargetRange.getHeight() / aFullRange.getHeight());
 384                 const double fScaleMin(std::min(fScaleX, fScaleY));
 385
 386                 // TopLeft to zero, then scale, then move to center of available space
 387                 aRetval.translate(-aFullRange.getMinX(), -aFullRange.getMinY());
 388                 aRetval.scale(fScaleMin, fScaleMin);
 389                 aRetval.translate(
 390                     rTargetRange.getCenterX() - (0.5 * fScaleMin * aFullRange.getWidth()),
 391                     rTargetRange.getCenterY() - (0.5 * fScaleMin * aFullRange.getHeight()));
 392             }
 393             else
 394             {
 395                 // just scale/translate needed
 396                 aRetval *= createScaleTranslateB2DHomMatrix(
 397                     rTargetRange.getRange(),
 398                     rTargetRange.getMinimum());
 399             }
 400
 401             return aRetval;
 402         }
 403
 404         /// special for the case to map from source range to target range
 405         B2DHomMatrix createSourceRangeTargetRangeTransform(
 406             const B2DRange& rSourceRange,
 407             const B2DRange& rTargetRange)
 408         {
 409             B2DHomMatrix aRetval;
 410
 411             if(&rSourceRange == &rTargetRange)
 412             {
 413                 return aRetval;
 414             }
 415
 416             if(!fTools::equalZero(rSourceRange.getMinX()) || !fTools::equalZero(rSourceRange.getMinY()))
 417             {
 418                 aRetval.set(0, 2, -rSourceRange.getMinX());
 419                 aRetval.set(1, 2, -rSourceRange.getMinY());
 420             }
 421
 422             const double fSourceW(rSourceRange.getWidth());
 423             const double fSourceH(rSourceRange.getHeight());
 424             const bool bDivX(!fTools::equalZero(fSourceW) && !fTools::equal(fSourceW, 1.0));
 425             const bool bDivY(!fTools::equalZero(fSourceH) && !fTools::equal(fSourceH, 1.0));
 426             const double fScaleX(bDivX ? rTargetRange.getWidth() / fSourceW : rTargetRange.getWidth());
 427             const double fScaleY(bDivY ? rTargetRange.getHeight() / fSourceH : rTargetRange.getHeight());
 428
 429             if(!fTools::equalZero(fScaleX) || !fTools::equalZero(fScaleY))
 430             {
 431                 aRetval.scale(fScaleX, fScaleY);
 432             }
 433
 434             if(!fTools::equalZero(rTargetRange.getMinX()) || !fTools::equalZero(rTargetRange.getMinY()))
 435             {
 436                 aRetval.translate(
 437                     rTargetRange.getMinX(),
 438                     rTargetRange.getMinY());
 439             }
 440
 441             return aRetval;
 442         }
 443
 444         B2DHomMatrix createCoordinateSystemTransform(
 445             const B2DPoint& rOrigin,
 446             const B2DVector& rX,
 447             const B2DVector& rY)
 448         {
 449             return basegfx::B2DHomMatrix(
 450                 rX.getX(), rY.getX(), rOrigin.getX(),
 451                 rX.getY(), rY.getY(), rOrigin.getY());
 452         }
 453
 454         B2DTuple getColumn(const B2DHomMatrix& rMatrix, sal_uInt16 nCol)
 455         {
 456             return B2DTuple(rMatrix.get(0, nCol), rMatrix.get(1, nCol));
 457         }
 458     } // end of namespace utils
 459 } // end of namespace basegfx
 460
 461 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */