LCOV - code coverage report
Current view: top level - basegfx/source/tools - gradienttools.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 54 162 33.3 %
Date: 2014-11-03 Functions: 6 17 35.3 %
Legend: Lines: hit not hit

          Line data    Source code
       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/tools/gradienttools.hxx>
      21             : #include <basegfx/point/b2dpoint.hxx>
      22             : #include <basegfx/range/b2drange.hxx>
      23             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      24             : 
      25             : namespace basegfx
      26             : {
      27           0 :     bool ODFGradientInfo::operator==(const ODFGradientInfo& rODFGradientInfo) const
      28             :     {
      29           0 :         return getTextureTransform() == rODFGradientInfo.getTextureTransform()
      30           0 :             && getAspectRatio() == rODFGradientInfo.getAspectRatio()
      31           0 :             && getSteps() == rODFGradientInfo.getSteps();
      32             :     }
      33             : 
      34       69454 :     const B2DHomMatrix& ODFGradientInfo::getBackTextureTransform() const
      35             :     {
      36       69454 :         if(maBackTextureTransform.isIdentity())
      37             :         {
      38          13 :             const_cast< ODFGradientInfo* >(this)->maBackTextureTransform = getTextureTransform();
      39          13 :             const_cast< ODFGradientInfo* >(this)->maBackTextureTransform.invert();
      40             :         }
      41             : 
      42       69454 :         return maBackTextureTransform;
      43             :     }
      44             : 
      45             :     /** Most of the setup for linear & axial gradient is the same, except
      46             :         for the border treatment. Factored out here.
      47             :     */
      48         473 :     ODFGradientInfo init1DGradientInfo(
      49             :         const B2DRange& rTargetRange,
      50             :         sal_uInt32 nSteps,
      51             :         double fBorder,
      52             :         double fAngle,
      53             :         bool bAxial)
      54             :     {
      55         473 :         B2DHomMatrix aTextureTransform;
      56             : 
      57         473 :         fAngle = -fAngle;
      58             : 
      59         473 :         double fTargetSizeX(rTargetRange.getWidth());
      60         473 :         double fTargetSizeY(rTargetRange.getHeight());
      61         473 :         double fTargetOffsetX(rTargetRange.getMinX());
      62         473 :         double fTargetOffsetY(rTargetRange.getMinY());
      63             : 
      64             :         // add object expansion
      65         473 :         const bool bAngleUsed(!fTools::equalZero(fAngle));
      66             : 
      67         473 :         if(bAngleUsed)
      68             :         {
      69         119 :             const double fAbsCos(fabs(cos(fAngle)));
      70         119 :             const double fAbsSin(fabs(sin(fAngle)));
      71         119 :             const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
      72         119 :             const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
      73             : 
      74         119 :             fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
      75         119 :             fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
      76         119 :             fTargetSizeX = fNewX;
      77         119 :             fTargetSizeY = fNewY;
      78             :         }
      79             : 
      80         473 :         const double fSizeWithoutBorder(1.0 - fBorder);
      81             : 
      82         473 :         if(bAxial)
      83             :         {
      84         113 :             aTextureTransform.scale(1.0, fSizeWithoutBorder * 0.5);
      85         113 :             aTextureTransform.translate(0.0, 0.5);
      86             :         }
      87             :         else
      88             :         {
      89         360 :             if(!fTools::equal(fSizeWithoutBorder, 1.0))
      90             :             {
      91           0 :                 aTextureTransform.scale(1.0, fSizeWithoutBorder);
      92           0 :                 aTextureTransform.translate(0.0, fBorder);
      93             :             }
      94             :         }
      95             : 
      96         473 :         aTextureTransform.scale(fTargetSizeX, fTargetSizeY);
      97             : 
      98             :         // add texture rotate after scale to keep perpendicular angles
      99         473 :         if(bAngleUsed)
     100             :         {
     101         119 :             const B2DPoint aCenter(0.5 * fTargetSizeX, 0.5 * fTargetSizeY);
     102             : 
     103         119 :             aTextureTransform *= basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
     104             :         }
     105             : 
     106             :         // add object translate
     107         473 :         aTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
     108             : 
     109             :         // prepare aspect for texture
     110         473 :         const double fAspectRatio(fTools::equalZero(fTargetSizeY) ?  1.0 : fTargetSizeX / fTargetSizeY);
     111             : 
     112         473 :         return ODFGradientInfo(aTextureTransform, fAspectRatio, nSteps);
     113             :     }
     114             : 
     115             :     /** Most of the setup for radial & ellipsoidal gradient is the same,
     116             :         except for the border treatment. Factored out here.
     117             :     */
     118           0 :     ODFGradientInfo initEllipticalGradientInfo(
     119             :         const B2DRange& rTargetRange,
     120             :         const B2DVector& rOffset,
     121             :         sal_uInt32 nSteps,
     122             :         double fBorder,
     123             :         double fAngle,
     124             :         bool bCircular)
     125             :     {
     126           0 :         B2DHomMatrix aTextureTransform;
     127             : 
     128           0 :         fAngle = -fAngle;
     129             : 
     130           0 :         double fTargetSizeX(rTargetRange.getWidth());
     131           0 :         double fTargetSizeY(rTargetRange.getHeight());
     132           0 :         double fTargetOffsetX(rTargetRange.getMinX());
     133           0 :         double fTargetOffsetY(rTargetRange.getMinY());
     134             : 
     135             :         // add object expansion
     136           0 :         if(bCircular)
     137             :         {
     138           0 :             const double fOriginalDiag(sqrt((fTargetSizeX * fTargetSizeX) + (fTargetSizeY * fTargetSizeY)));
     139             : 
     140           0 :             fTargetOffsetX -= (fOriginalDiag - fTargetSizeX) / 2.0;
     141           0 :             fTargetOffsetY -= (fOriginalDiag - fTargetSizeY) / 2.0;
     142           0 :             fTargetSizeX = fOriginalDiag;
     143           0 :             fTargetSizeY = fOriginalDiag;
     144             :         }
     145             :         else
     146             :         {
     147           0 :             fTargetOffsetX -= (0.4142 / 2.0 ) * fTargetSizeX;
     148           0 :             fTargetOffsetY -= (0.4142 / 2.0 ) * fTargetSizeY;
     149           0 :             fTargetSizeX = 1.4142 * fTargetSizeX;
     150           0 :             fTargetSizeY = 1.4142 * fTargetSizeY;
     151             :         }
     152             : 
     153           0 :         const double fHalfBorder((1.0 - fBorder) * 0.5);
     154             : 
     155           0 :         aTextureTransform.scale(fHalfBorder, fHalfBorder);
     156           0 :         aTextureTransform.translate(0.5, 0.5);
     157           0 :         aTextureTransform.scale(fTargetSizeX, fTargetSizeY);
     158             : 
     159             :         // add texture rotate after scale to keep perpendicular angles
     160           0 :         if(!bCircular && !fTools::equalZero(fAngle))
     161             :         {
     162           0 :             const B2DPoint aCenter(0.5 * fTargetSizeX, 0.5 * fTargetSizeY);
     163             : 
     164           0 :             aTextureTransform *= basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
     165             :         }
     166             : 
     167             :         // add defined offsets after rotation
     168           0 :         if(!fTools::equal(0.5, rOffset.getX()) || !fTools::equal(0.5, rOffset.getY()))
     169             :         {
     170             :             // use original target size
     171           0 :             fTargetOffsetX += (rOffset.getX() - 0.5) * rTargetRange.getWidth();
     172           0 :             fTargetOffsetY += (rOffset.getY() - 0.5) * rTargetRange.getHeight();
     173             :         }
     174             : 
     175             :         // add object translate
     176           0 :         aTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
     177             : 
     178             :         // prepare aspect for texture
     179           0 :         const double fAspectRatio((0.0 != fTargetSizeY) ?  fTargetSizeX / fTargetSizeY : 1.0);
     180             : 
     181           0 :         return ODFGradientInfo(aTextureTransform, fAspectRatio, nSteps);
     182             :     }
     183             : 
     184             :     /** Setup for rect & square gradient is exactly the same. Factored out
     185             :         here.
     186             :     */
     187           0 :     ODFGradientInfo initRectGradientInfo(
     188             :         const B2DRange& rTargetRange,
     189             :         const B2DVector& rOffset,
     190             :         sal_uInt32 nSteps,
     191             :         double fBorder,
     192             :         double fAngle,
     193             :         bool bSquare)
     194             :     {
     195           0 :         B2DHomMatrix aTextureTransform;
     196             : 
     197           0 :         fAngle = -fAngle;
     198             : 
     199           0 :         double fTargetSizeX(rTargetRange.getWidth());
     200           0 :         double fTargetSizeY(rTargetRange.getHeight());
     201           0 :         double fTargetOffsetX(rTargetRange.getMinX());
     202           0 :         double fTargetOffsetY(rTargetRange.getMinY());
     203             : 
     204             :         // add object expansion
     205           0 :         if(bSquare)
     206             :         {
     207           0 :             const double fSquareWidth(std::max(fTargetSizeX, fTargetSizeY));
     208             : 
     209           0 :             fTargetOffsetX -= (fSquareWidth - fTargetSizeX) / 2.0;
     210           0 :             fTargetOffsetY -= (fSquareWidth - fTargetSizeY) / 2.0;
     211           0 :             fTargetSizeX = fTargetSizeY = fSquareWidth;
     212             :         }
     213             : 
     214             :         // add object expansion
     215           0 :         const bool bAngleUsed(!fTools::equalZero(fAngle));
     216             : 
     217           0 :         if(bAngleUsed)
     218             :         {
     219           0 :             const double fAbsCos(fabs(cos(fAngle)));
     220           0 :             const double fAbsSin(fabs(sin(fAngle)));
     221           0 :             const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
     222           0 :             const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
     223             : 
     224           0 :             fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
     225           0 :             fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
     226           0 :             fTargetSizeX = fNewX;
     227           0 :             fTargetSizeY = fNewY;
     228             :         }
     229             : 
     230           0 :         const double fHalfBorder((1.0 - fBorder) * 0.5);
     231             : 
     232           0 :         aTextureTransform.scale(fHalfBorder, fHalfBorder);
     233           0 :         aTextureTransform.translate(0.5, 0.5);
     234           0 :         aTextureTransform.scale(fTargetSizeX, fTargetSizeY);
     235             : 
     236             :         // add texture rotate after scale to keep perpendicular angles
     237           0 :         if(bAngleUsed)
     238             :         {
     239           0 :             const B2DPoint aCenter(0.5 * fTargetSizeX, 0.5 * fTargetSizeY);
     240             : 
     241           0 :             aTextureTransform *= basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
     242             :         }
     243             : 
     244             :         // add defined offsets after rotation
     245           0 :         if(!fTools::equal(0.5, rOffset.getX()) || !fTools::equal(0.5, rOffset.getY()))
     246             :         {
     247             :             // use scaled target size
     248           0 :             fTargetOffsetX += (rOffset.getX() - 0.5) * fTargetSizeX;
     249           0 :             fTargetOffsetY += (rOffset.getY() - 0.5) * fTargetSizeY;
     250             :         }
     251             : 
     252             :         // add object translate
     253           0 :         aTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
     254             : 
     255             :         // prepare aspect for texture
     256           0 :         const double fAspectRatio((0.0 != fTargetSizeY) ? fTargetSizeX / fTargetSizeY : 1.0);
     257             : 
     258           0 :         return ODFGradientInfo(aTextureTransform, fAspectRatio, nSteps);
     259             :     }
     260             : 
     261             :     namespace tools
     262             :     {
     263         360 :         ODFGradientInfo createLinearODFGradientInfo(
     264             :             const B2DRange& rTargetArea,
     265             :             sal_uInt32 nSteps,
     266             :             double fBorder,
     267             :             double fAngle)
     268             :         {
     269             :             return init1DGradientInfo(
     270             :                 rTargetArea,
     271             :                 nSteps,
     272             :                 fBorder,
     273             :                 fAngle,
     274         360 :                 false);
     275             :         }
     276             : 
     277         113 :         ODFGradientInfo createAxialODFGradientInfo(
     278             :             const B2DRange& rTargetArea,
     279             :             sal_uInt32 nSteps,
     280             :             double fBorder,
     281             :             double fAngle)
     282             :         {
     283             :             return init1DGradientInfo(
     284             :                 rTargetArea,
     285             :                 nSteps,
     286             :                 fBorder,
     287             :                 fAngle,
     288         113 :                 true);
     289             :         }
     290             : 
     291           0 :         ODFGradientInfo createRadialODFGradientInfo(
     292             :             const B2DRange& rTargetArea,
     293             :             const B2DVector& rOffset,
     294             :             sal_uInt32 nSteps,
     295             :             double fBorder)
     296             :         {
     297             :             return initEllipticalGradientInfo(
     298             :                 rTargetArea,
     299             :                 rOffset,
     300             :                 nSteps,
     301             :                 fBorder,
     302             :                 0.0,
     303           0 :                 true);
     304             :         }
     305             : 
     306           0 :         ODFGradientInfo createEllipticalODFGradientInfo(
     307             :             const B2DRange& rTargetArea,
     308             :             const B2DVector& rOffset,
     309             :             sal_uInt32 nSteps,
     310             :             double fBorder,
     311             :             double fAngle)
     312             :         {
     313             :             return initEllipticalGradientInfo(
     314             :                 rTargetArea,
     315             :                 rOffset,
     316             :                 nSteps,
     317             :                 fBorder,
     318             :                 fAngle,
     319           0 :                 false);
     320             :         }
     321             : 
     322           0 :         ODFGradientInfo createSquareODFGradientInfo(
     323             :             const B2DRange& rTargetArea,
     324             :             const B2DVector& rOffset,
     325             :             sal_uInt32 nSteps,
     326             :             double fBorder,
     327             :             double fAngle)
     328             :         {
     329             :             return initRectGradientInfo(
     330             :                 rTargetArea,
     331             :                 rOffset,
     332             :                 nSteps,
     333             :                 fBorder,
     334             :                 fAngle,
     335           0 :                 true);
     336             :         }
     337             : 
     338           0 :         ODFGradientInfo createRectangularODFGradientInfo(
     339             :             const B2DRange& rTargetArea,
     340             :             const B2DVector& rOffset,
     341             :             sal_uInt32 nSteps,
     342             :             double fBorder,
     343             :             double fAngle)
     344             :         {
     345             :             return initRectGradientInfo(
     346             :                 rTargetArea,
     347             :                 rOffset,
     348             :                 nSteps,
     349             :                 fBorder,
     350             :                 fAngle,
     351           0 :                 false);
     352             :         }
     353             : 
     354       34713 :         double getLinearGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     355             :         {
     356       34713 :             const B2DPoint aCoor(rGradInfo.getBackTextureTransform() * rUV);
     357             : 
     358             :             // Ignore Y, this is not needed at all for Y-Oriented gradients
     359             :             // if(aCoor.getX() < 0.0 || aCoor.getX() > 1.0)
     360             :             // {
     361             :             //     return 0.0;
     362             :             // }
     363             : 
     364       34713 :             if(aCoor.getY() <= 0.0)
     365             :             {
     366        1354 :                 return 0.0; // start value for inside
     367             :             }
     368             : 
     369       33359 :             if(aCoor.getY() >= 1.0)
     370             :             {
     371           0 :                 return 1.0; // end value for outside
     372             :             }
     373             : 
     374       33359 :             const sal_uInt32 nSteps(rGradInfo.getSteps());
     375             : 
     376       33359 :             if(nSteps)
     377             :             {
     378       33359 :                 return floor(aCoor.getY() * nSteps) / double(nSteps - 1);
     379             :             }
     380             : 
     381           0 :             return aCoor.getY();
     382             :         }
     383             : 
     384       34735 :         double getAxialGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     385             :         {
     386       34735 :             const B2DPoint aCoor(rGradInfo.getBackTextureTransform() * rUV);
     387             : 
     388             :             // Ignore Y, this is not needed at all for Y-Oriented gradients
     389             :             //if(aCoor.getX() < 0.0 || aCoor.getX() > 1.0)
     390             :             //{
     391             :             //    return 0.0;
     392             :             //}
     393             : 
     394       34735 :             const double fAbsY(fabs(aCoor.getY()));
     395             : 
     396       34735 :             if(fAbsY >= 1.0)
     397             :             {
     398           2 :                 return 1.0; // use end value when outside in Y
     399             :             }
     400             : 
     401       34733 :             const sal_uInt32 nSteps(rGradInfo.getSteps());
     402             : 
     403       34733 :             if(nSteps)
     404             :             {
     405       34733 :                 return floor(fAbsY * nSteps) / double(nSteps - 1);
     406             :             }
     407             : 
     408           0 :             return fAbsY;
     409             :         }
     410             : 
     411           0 :         double getRadialGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     412             :         {
     413           0 :             const B2DPoint aCoor(rGradInfo.getBackTextureTransform() * rUV);
     414             : 
     415           0 :             if(aCoor.getX() < -1.0 || aCoor.getX() > 1.0 || aCoor.getY() < -1.0 || aCoor.getY() > 1.0)
     416             :             {
     417           0 :                 return 0.0;
     418             :             }
     419             : 
     420           0 :             const double t(1.0 - sqrt(aCoor.getX() * aCoor.getX() + aCoor.getY() * aCoor.getY()));
     421           0 :             const sal_uInt32 nSteps(rGradInfo.getSteps());
     422             : 
     423           0 :             if(nSteps && t < 1.0)
     424             :             {
     425           0 :                 return floor(t * nSteps) / double(nSteps - 1);
     426             :             }
     427             : 
     428           0 :             return t;
     429             :         }
     430             : 
     431           0 :         double getEllipticalGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     432             :         {
     433           0 :             return getRadialGradientAlpha(rUV, rGradInfo); // only matrix setup differs
     434             :         }
     435             : 
     436           0 :         double getSquareGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     437             :         {
     438           0 :             const B2DPoint aCoor(rGradInfo.getBackTextureTransform() * rUV);
     439           0 :             const double fAbsX(fabs(aCoor.getX()));
     440             : 
     441           0 :             if(fAbsX >= 1.0)
     442             :             {
     443           0 :                 return 0.0;
     444             :             }
     445             : 
     446           0 :             const double fAbsY(fabs(aCoor.getY()));
     447             : 
     448           0 :             if(fAbsY >= 1.0)
     449             :             {
     450           0 :                 return 0.0;
     451             :             }
     452             : 
     453           0 :             const double t(1.0 - std::max(fAbsX, fAbsY));
     454           0 :             const sal_uInt32 nSteps(rGradInfo.getSteps());
     455             : 
     456           0 :             if(nSteps && t < 1.0)
     457             :             {
     458           0 :                 return floor(t * nSteps) / double(nSteps - 1);
     459             :             }
     460             : 
     461           0 :             return t;
     462             :         }
     463             : 
     464           0 :         double getRectangularGradientAlpha(const B2DPoint& rUV, const ODFGradientInfo& rGradInfo)
     465             :         {
     466           0 :             return getSquareGradientAlpha(rUV, rGradInfo); // only matrix setup differs
     467             :         }
     468             :     } // namespace tools
     469             : } // namespace basegfx
     470             : 
     471             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10