basegfx/source/curve/b2dbeziertools.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b2dbeziertools.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <basegfx/curve/b2dbeziertools.hxx>
  34 #include <basegfx/curve/b2dcubicbezier.hxx>
  35 #include <algorithm>
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38
  39 namespace basegfx
  40 {
  41     B2DCubicBezierHelper::B2DCubicBezierHelper(const B2DCubicBezier& rBase, sal_uInt32 nDivisions)
  42     :   maLengthArray(),
  43         mnEdgeCount(0)
  44     {
  45         const bool bIsBezier(rBase.isBezier());
  46
  47         if(bIsBezier)
  48         {
  49             // check nDivisions; at least one is needed, but also prevent too big values
  50             if(nDivisions < 1)
  51             {
  52                 nDivisions = 1;
  53             }
  54             else if(nDivisions > 1000)
  55             {
  56                 nDivisions = 1000;
  57             }
  58
  59             // set nEdgeCount
  60             mnEdgeCount = nDivisions + 1;
  61
  62             // fill in maLengthArray
  63             maLengthArray.clear();
  64             maLengthArray.reserve(mnEdgeCount);
  65             B2DPoint aCurrent(rBase.getStartPoint());
  66             double fLength(0.0);
  67
  68             for(sal_uInt32 a(1);;)
  69             {
  70                 const B2DPoint aNext(rBase.interpolatePoint((double)a / (double)mnEdgeCount));
  71                 const B2DVector aEdge(aNext - aCurrent);
  72
  73                 fLength += aEdge.getLength();
  74                 maLengthArray.push_back(fLength);
  75
  76                 if(++a < mnEdgeCount)
  77                 {
  78                     aCurrent = aNext;
  79                 }
  80                 else
  81                 {
  82                     const B2DPoint aLastNext(rBase.getEndPoint());
  83                     const B2DVector aLastEdge(aLastNext - aNext);
  84
  85                     fLength += aLastEdge.getLength();
  86                     maLengthArray.push_back(fLength);
  87                     break;
  88                 }
  89             }
  90         }
  91         else
  92         {
  93             maLengthArray.clear();
  94             maLengthArray.push_back(rBase.getEdgeLength());
  95             mnEdgeCount = 1;
  96         }
  97     }
  98
  99     double B2DCubicBezierHelper::distanceToRelative(double fDistance) const
 100     {
 101         if(fDistance <= 0.0)
 102         {
 103             return 0.0;
 104         }
 105
 106         const double fLength(getLength());
 107
 108         if(fTools::moreOrEqual(fDistance, fLength))
 109         {
 110             return 1.0;
 111         }
 112
 113         // fDistance is in ]0.0 .. fLength[
 114
 115         if(1 == mnEdgeCount)
 116         {
 117             // not a bezier, linear edge
 118             return fDistance / fLength;
 119         }
 120
 121         // it is a bezier
 122         ::std::vector< double >::const_iterator aIter = ::std::lower_bound(maLengthArray.begin(), maLengthArray.end(), fDistance);
 123         const sal_uInt32 nIndex(aIter - maLengthArray.begin());
 124         const double fHighBound(maLengthArray[nIndex]);
 125         const double fLowBound(nIndex ?  maLengthArray[nIndex - 1] : 0.0);
 126         const double fLinearInterpolatedLength((fDistance - fLowBound) / (fHighBound - fLowBound));
 127
 128         return (static_cast< double >(nIndex) + fLinearInterpolatedLength) / static_cast< double >(mnEdgeCount);
 129     }
 130
 131     double B2DCubicBezierHelper::relativeToDistance(double fRelative) const
 132     {
 133         if(fRelative <= 0.0)
 134         {
 135             return 0.0;
 136         }
 137
 138         const double fLength(getLength());
 139
 140         if(fTools::moreOrEqual(fRelative, 1.0))
 141         {
 142             return fLength;
 143         }
 144
 145         // fRelative is in ]0.0 .. 1.0[
 146
 147         if(1 == mnEdgeCount)
 148         {
 149             // not a bezier, linear edge
 150             return fRelative * fLength;
 151         }
 152
 153         // fRelative is in ]0.0 .. 1.0[
 154         const double fIndex(fRelative * static_cast< double >(mnEdgeCount));
 155         double fIntIndex;
 156         const double fFractIndex(modf(fIndex, &fIntIndex));
 157         const sal_uInt32 nIntIndex(static_cast< sal_uInt32 >(fIntIndex));
 158         const double fStartDistance(nIntIndex ? maLengthArray[nIntIndex - 1] : 0.0);
 159
 160         return fStartDistance + ((maLengthArray[nIntIndex] - fStartDistance) * fFractIndex);
 161     }
 162 } // end of namespace basegfx
 163
 164 //////////////////////////////////////////////////////////////////////////////
 165
 166 // eof