thbfixes10: merge with DEV300 m69

12 files changed, 812 insertions, 390 deletions

diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index e7247a95333b..83c620df7870 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -7,7 +7,6 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: b2dcubicbezier.cxx,v $
- * $Revision: 1.16 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -1045,6 +1044,65 @@ namespace basegfx
             impCheckExtremumResult(fCY / (2 * fBY), rResults);
         }
     }
+
+    int B2DCubicBezier::getMaxDistancePositions( double pResult[2]) const
+    {
+        // the distance from the bezier to a line through start and end
+        // is proportional to (ENDx-STARTx,ENDy-STARTy)*(+BEZIERy(t),-BEZIERx(t))
+        // this distance becomes zero for at least t==0 and t==1
+        // its extrema that are between 0..1 are interesting as split candidates
+        // its derived function has the form dD/dt = fA*t^2 + 2*fB*t + fC
+        const B2DPoint aRelativeEndPoint(maEndPoint-maStartPoint);
+        const double fA = 3 * (maEndPoint.getX() - maControlPointB.getX()) * aRelativeEndPoint.getY()
+                - 3 * (maEndPoint.getY() - maControlPointB.getY()) * aRelativeEndPoint.getX();
+        const double fB = (maControlPointB.getX() - maControlPointA.getX()) * aRelativeEndPoint.getY()
+                - (maControlPointB.getY() - maControlPointA.getY()) * aRelativeEndPoint.getX();
+        const double fC = (maControlPointA.getX() - maStartPoint.getX()) * aRelativeEndPoint.getY()
+                - (maControlPointA.getY() - maStartPoint.getY()) * aRelativeEndPoint.getX();
+
+        // test for degenerated case: non-cubic curve
+        if( fTools::equalZero(fA) )
+        {
+            // test for degenerated case: straight line
+            if( fTools::equalZero(fB) )
+                return 0;
+
+            // degenerated case: quadratic bezier
+            pResult[0] = -fC / (2*fB);
+
+            // test root: ignore it when it is outside the curve
+            int nCount = ((pResult[0] > 0) && (pResult[0] < 1));
+            return nCount;
+        }
+
+        // derivative is polynomial of order 2
+        // check if the polynomial has non-imaginary roots
+        const double fD = fB*fB - fA*fC;
+        if( fD >= 0.0 ) // TODO: is this test needed? geometrically not IMHO
+        {
+            // calculate the first root
+            const double fS = sqrt(fD);
+            const double fQ = fB + ((fB >= 0) ? +fS : -fS);
+            pResult[0] = fQ / fA;
+            // test root: ignore it when it is outside the curve
+            int nCount = ((pResult[0] > 0) && (pResult[0] < 1));
+
+            // ignore multiplicit roots
+            if( !fTools::equalZero(fD) )
+            {
+                 // calculate the second root
+                const double fRoot = fC / fQ;
+                pResult[ nCount ] = fC / fQ;
+                // test root: ignore it when it is outside the curve
+                nCount += ((fRoot > 0) && (fRoot < 1));
+            }
+
+            return nCount;
+        }
+
+        return 0;
+    }
+
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/matrix/b2dhommatrix.cxx b/basegfx/source/matrix/b2dhommatrix.cxx
index 352113fa8ed3..a7777352effb 100644
--- a/basegfx/source/matrix/b2dhommatrix.cxx
+++ b/basegfx/source/matrix/b2dhommatrix.cxx
@@ -36,6 +36,9 @@
 #include <hommatrixtemplate.hxx>
 #include <basegfx/tuple/b2dtuple.hxx>
 #include <basegfx/vector/b2dvector.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+
+///////////////////////////////////////////////////////////////////////////////
 
 namespace basegfx
 {
@@ -60,6 +63,17 @@ namespace basegfx
     {
     }
 
+    B2DHomMatrix::B2DHomMatrix(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2)
+    :   mpImpl( IdentityMatrix::get() ) // use common identity matrix, will be made unique with 1st set-call
+    {
+        mpImpl->set(0, 0, f_0x0);
+        mpImpl->set(0, 1, f_0x1);
+        mpImpl->set(0, 2, f_0x2);
+        mpImpl->set(1, 0, f_1x0);
+        mpImpl->set(1, 1, f_1x1);
+        mpImpl->set(1, 2, f_1x2);
+    }
+
     B2DHomMatrix& B2DHomMatrix::operator=(const B2DHomMatrix& rMat)
     {
         mpImpl = rMat.mpImpl;
@@ -81,6 +95,16 @@ namespace basegfx
         mpImpl->set(nRow, nColumn, fValue);
     }
 
+    void B2DHomMatrix::set3x2(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2)
+    {
+        mpImpl->set(0, 0, f_0x0);
+        mpImpl->set(0, 1, f_0x1);
+        mpImpl->set(0, 2, f_0x2);
+        mpImpl->set(1, 0, f_1x0);
+        mpImpl->set(1, 1, f_1x1);
+        mpImpl->set(1, 2, f_1x2);
+    }
+
     bool B2DHomMatrix::isLastLineDefault() const
     {
         return mpImpl->isLastLineDefault();
@@ -206,56 +230,9 @@ namespace basegfx
         if(!fTools::equalZero(fRadiant))
         {
             double fSin(0.0);
-            double fCos(0.0);
-
-            // is the rotation angle an approximate multiple of pi/2?
-            // If yes, force fSin/fCos to -1/0/1, to maintain
-            // orthogonality (which might also be advantageous for the
-            // other cases, but: for multiples of pi/2, the exact
-            // values _can_ be attained. It would be largely
-            // unintuitive, if a 180 degrees rotation would introduce
-            // slight roundoff errors, instead of exactly mirroring
-            // the coordinate system).
-            if( fTools::equalZero( fmod( fRadiant, F_PI2 ) ) )
-            {
-                // determine quadrant
-                const sal_Int32 nQuad(
-                    (4 + fround( 4/F_2PI*fmod( fRadiant, F_2PI ) )) % 4 );
-                switch( nQuad )
-                {
-                    case 0: // -2pi,0,2pi
-                        fSin = 0.0;
-                        fCos = 1.0;
-                        break;
-
-                    case 1: // -3/2pi,1/2pi
-                        fSin = 1.0;
-                        fCos = 0.0;
-                        break;
-
-                    case 2: // -pi,pi
-                        fSin = 0.0;
-                        fCos = -1.0;
-                        break;
-
-                    case 3: // -1/2pi,3/2pi
-                        fSin = -1.0;
-                        fCos = 0.0;
-                        break;
-
-                    default:
-                        OSL_ENSURE( false,
-                                    "B2DHomMatrix::rotate(): Impossible case reached" );
-                }
-            }
-            else
-            {
-                // TODO(P1): Maybe use glibc's sincos here (though
-                // that's kinda non-portable...)
-                fSin = sin(fRadiant);
-                fCos = cos(fRadiant);
-            }
+            double fCos(1.0);
 
+            tools::createSinCosOrthogonal(fSin, fCos, fRadiant);
             Impl2DHomMatrix aRotMat;
 
             aRotMat.set(0, 0, fCos);
@@ -474,104 +451,7 @@ namespace basegfx
 
         return true;
     }
-
-/* Old version: Used 3D decompose when shaer was involved and also a determinant test
-   (but only in that case). Keeping as comment since it also worked and to allow a
-   fallback in case the new version makes trouble somehow. Definitely missing in the 2nd
-   case is the sign correction for Y-Scale, this would need to be added following the above
-   pattern
-
-    bool B2DHomMatrix::decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const
-    {
-        // when perspective is used, decompose is not made here
-        if(!mpImpl->isLastLineDefault())
-            return false;
-
-        // test for rotation and shear
-        if(fTools::equalZero(get(0, 1))
-           && fTools::equalZero(get(1, 0)))
-        {
-            // no rotation and shear, direct value extraction
-            rRotate = rShearX = 0.0;
-
-            // copy scale values
-            rScale.setX(get(0, 0));
-            rScale.setY(get(1, 1));
-
-            // copy translation values
-            rTranslate.setX(get(0, 2));
-            rTranslate.setY(get(1, 2));
-
-            return true;
-        }
-        else
-        {
-            // test if shear is zero. That's the case, if the unit vectors in the matrix
-            // are perpendicular -> scalar is zero
-            const ::basegfx::B2DVector aUnitVecX(get(0, 0), get(1, 0));
-            const ::basegfx::B2DVector aUnitVecY(get(0, 1), get(1, 1));
-
-            if(fTools::equalZero(aUnitVecX.scalar(aUnitVecY)))
-            {
-                // no shear, direct value extraction
-                rShearX = 0.0;
-
-                // calculate rotation
-                rShearX = 0.0;
-                rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
-
-                // calculate scale values
-                rScale.setX(aUnitVecX.getLength());
-                rScale.setY(aUnitVecY.getLength());
-
-                // copy translation values
-                rTranslate.setX(get(0, 2));
-                rTranslate.setY(get(1, 2));
-
-                return true;
-            }
-            else
-            {
-                // If determinant is zero, decomposition is not possible
-                if(0.0 == determinant())
-                    return false;
-
-                // copy 2x2 matrix and translate vector to 3x3 matrix
-                ::basegfx::B3DHomMatrix a3DHomMat;
-
-                a3DHomMat.set(0, 0, get(0, 0));
-                a3DHomMat.set(0, 1, get(0, 1));
-                a3DHomMat.set(1, 0, get(1, 0));
-                a3DHomMat.set(1, 1, get(1, 1));
-                a3DHomMat.set(0, 3, get(0, 2));
-                a3DHomMat.set(1, 3, get(1, 2));
-
-                ::basegfx::B3DTuple r3DScale, r3DTranslate, r3DRotate, r3DShear;
-
-                if(a3DHomMat.decompose(r3DScale, r3DTranslate, r3DRotate, r3DShear))
-                {
-                    // copy scale values
-                    rScale.setX(r3DScale.getX());
-                    rScale.setY(r3DScale.getY());
-
-                    // copy shear
-                    rShearX = r3DShear.getX();
-
-                    // copy rotate
-                    rRotate = r3DRotate.getZ();
-
-                    // copy translate
-                    rTranslate.setX(r3DTranslate.getX());
-                    rTranslate.setY(r3DTranslate.getY());
-
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    } */
-
 } // end of namespace basegfx
 
+///////////////////////////////////////////////////////////////////////////////
 // eof
diff --git a/basegfx/source/matrix/b2dhommatrixtools.cxx b/basegfx/source/matrix/b2dhommatrixtools.cxx
index 366a08a1d202..f3d483c976e5 100644
--- a/basegfx/source/matrix/b2dhommatrixtools.cxx
+++ b/basegfx/source/matrix/b2dhommatrixtools.cxx
@@ -66,6 +66,339 @@ namespace basegfx
         return aStrBuf.makeStringAndClear();
     }
 
+    namespace tools
+    {
+        void createSinCosOrthogonal(double& o_rSin, double& o_rCos, double fRadiant)
+        {
+            if( fTools::equalZero( fmod( fRadiant, F_PI2 ) ) )
+            {
+                // determine quadrant
+                const sal_Int32 nQuad(
+                    (4 + fround( 4/F_2PI*fmod( fRadiant, F_2PI ) )) % 4 );
+                switch( nQuad )
+                {
+                    case 0: // -2pi,0,2pi
+                        o_rSin = 0.0;
+                        o_rCos = 1.0;
+                        break;
+
+                    case 1: // -3/2pi,1/2pi
+                        o_rSin = 1.0;
+                        o_rCos = 0.0;
+                        break;
+
+                    case 2: // -pi,pi
+                        o_rSin = 0.0;
+                        o_rCos = -1.0;
+                        break;
+
+                    case 3: // -1/2pi,3/2pi
+                        o_rSin = -1.0;
+                        o_rCos = 0.0;
+                        break;
+
+                    default:
+                        OSL_ENSURE( false, "createSinCos: Impossible case reached" );
+                }
+            }
+            else
+            {
+                // TODO(P1): Maybe use glibc's sincos here (though
+                // that's kinda non-portable...)
+                o_rSin = sin(fRadiant);
+                o_rCos = cos(fRadiant);
+            }
+        }
+
+        B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY)
+        {
+            B2DHomMatrix aRetval;
+            const double fOne(1.0);
+
+            if(!fTools::equal(fScaleX, fOne))
+            {
+                aRetval.set(0, 0, fScaleX);
+            }
+
+            if(!fTools::equal(fScaleY, fOne))
+            {
+                aRetval.set(1, 1, fScaleY);
+            }
+
+            return aRetval;
+        }
+
+        B2DHomMatrix createShearXB2DHomMatrix(double fShearX)
+        {
+            B2DHomMatrix aRetval;
+
+            if(!fTools::equalZero(fShearX))
+            {
+                aRetval.set(0, 1, fShearX);
+            }
+
+            return aRetval;
+        }
+
+        B2DHomMatrix createShearYB2DHomMatrix(double fShearY)
+        {
+            B2DHomMatrix aRetval;
+
+            if(!fTools::equalZero(fShearY))
+            {
+                aRetval.set(1, 0, fShearY);
+            }
+
+            return aRetval;
+        }
+
+        B2DHomMatrix createRotateB2DHomMatrix(double fRadiant)
+        {
+            B2DHomMatrix aRetval;
+
+            if(!fTools::equalZero(fRadiant))
+            {
+                double fSin(0.0);
+                double fCos(1.0);
+
+                createSinCosOrthogonal(fSin, fCos, fRadiant);
+                aRetval.set(0, 0, fCos);
+                aRetval.set(1, 1, fCos);
+                aRetval.set(1, 0, fSin);
+                aRetval.set(0, 1, -fSin);
+            }
+
+            return aRetval;
+        }
+
+        B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY)
+        {
+            B2DHomMatrix aRetval;
+
+            if(!(fTools::equalZero(fTranslateX) && fTools::equalZero(fTranslateY)))
+            {
+                aRetval.set(0, 2, fTranslateX);
+                aRetval.set(1, 2, fTranslateY);
+            }
+
+            return aRetval;
+        }
+
+        B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
+            double fScaleX, double fScaleY,
+            double fShearX,
+            double fRadiant,
+            double fTranslateX, double fTranslateY)
+        {
+            const double fOne(1.0);
+
+            if(fTools::equal(fScaleX, fOne) && fTools::equal(fScaleY, fOne))
+            {
+                /// no scale, take shortcut
+                return createShearXRotateTranslateB2DHomMatrix(fShearX, fRadiant, fTranslateX, fTranslateY);
+            }
+            else
+            {
+                /// scale used
+                if(fTools::equalZero(fShearX))
+                {
+                    /// no shear
+                    if(fTools::equalZero(fRadiant))
+                    {
+                        /// no rotate, take shortcut
+                        return createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, fTranslateX, fTranslateY);
+                    }
+                    else
+                    {
+                        /// rotate and scale used, no shear
+                        double fSin(0.0);
+                        double fCos(1.0);
+
+                        createSinCosOrthogonal(fSin, fCos, fRadiant);
+
+                        B2DHomMatrix aRetval(
+                            /* Row 0, Column 0 */ fCos * fScaleX,
+                            /* Row 0, Column 1 */ fScaleY * -fSin,
+                            /* Row 0, Column 2 */ fTranslateX,
+                            /* Row 1, Column 0 */ fSin * fScaleX,
+                            /* Row 1, Column 1 */ fScaleY * fCos,
+                            /* Row 1, Column 2 */ fTranslateY);
+
+                        return aRetval;
+                    }
+                }
+                else
+                {
+                    /// scale and shear used
+                    if(fTools::equalZero(fRadiant))
+                    {
+                        /// scale and shear, but no rotate
+                        B2DHomMatrix aRetval(
+                            /* Row 0, Column 0 */ fScaleX,
+                            /* Row 0, Column 1 */ fScaleY * fShearX,
+                            /* Row 0, Column 2 */ fTranslateX,
+                            /* Row 1, Column 0 */ 0.0,
+                            /* Row 1, Column 1 */ fScaleY,
+                            /* Row 1, Column 2 */ fTranslateY);
+
+                        return aRetval;
+                    }
+                    else
+                    {
+                        /// scale, shear and rotate used
+                        double fSin(0.0);
+                        double fCos(1.0);
+
+                        createSinCosOrthogonal(fSin, fCos, fRadiant);
+
+                        B2DHomMatrix aRetval(
+                            /* Row 0, Column 0 */ fCos * fScaleX,
+                            /* Row 0, Column 1 */ fScaleY * ((fCos * fShearX) - fSin),
+                            /* Row 0, Column 2 */ fTranslateX,
+                            /* Row 1, Column 0 */ fSin * fScaleX,
+                            /* Row 1, Column 1 */ fScaleY * ((fSin * fShearX) + fCos),
+                            /* Row 1, Column 2 */ fTranslateY);
+
+                        return aRetval;
+                    }
+                }
+            }
+        }
+
+        B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
+            double fShearX,
+            double fRadiant,
+            double fTranslateX, double fTranslateY)
+        {
+            if(fTools::equalZero(fShearX))
+            {
+                /// no shear
+                if(fTools::equalZero(fRadiant))
+                {
+                    /// no shear, no rotate, take shortcut
+                    return createTranslateB2DHomMatrix(fTranslateX, fTranslateY);
+                }
+                else
+                {
+                    /// no shear, but rotate used
+                    double fSin(0.0);
+                    double fCos(1.0);
+
+                    createSinCosOrthogonal(fSin, fCos, fRadiant);
+
+                    B2DHomMatrix aRetval(
+                        /* Row 0, Column 0 */ fCos,
+                        /* Row 0, Column 1 */ -fSin,
+                        /* Row 0, Column 2 */ fTranslateX,
+                        /* Row 1, Column 0 */ fSin,
+                        /* Row 1, Column 1 */ fCos,
+                        /* Row 1, Column 2 */ fTranslateY);
+
+                    return aRetval;
+                }
+            }
+            else
+            {
+                /// shear used
+                if(fTools::equalZero(fRadiant))
+                {
+                    /// no rotate, but shear used
+                    B2DHomMatrix aRetval(
+                        /* Row 0, Column 0 */ 1.0,
+                        /* Row 0, Column 1 */ fShearX,
+                        /* Row 0, Column 2 */ fTranslateX,
+                        /* Row 1, Column 0 */ 0.0,
+                        /* Row 1, Column 1 */ 1.0,
+                        /* Row 1, Column 2 */ fTranslateY);
+
+                    return aRetval;
+                }
+                else
+                {
+                    /// shear and rotate used
+                    double fSin(0.0);
+                    double fCos(1.0);
+
+                    createSinCosOrthogonal(fSin, fCos, fRadiant);
+
+                    B2DHomMatrix aRetval(
+                        /* Row 0, Column 0 */ fCos,
+                        /* Row 0, Column 1 */ (fCos * fShearX) - fSin,
+                        /* Row 0, Column 2 */ fTranslateX,
+                        /* Row 1, Column 0 */ fSin,
+                        /* Row 1, Column 1 */ (fSin * fShearX) + fCos,
+                        /* Row 1, Column 2 */ fTranslateY);
+
+                    return aRetval;
+                }
+            }
+        }
+
+        B2DHomMatrix createScaleTranslateB2DHomMatrix(
+            double fScaleX, double fScaleY,
+            double fTranslateX, double fTranslateY)
+        {
+            const double fOne(1.0);
+
+            if(fTools::equal(fScaleX, fOne) && fTools::equal(fScaleY, fOne))
+            {
+                /// no scale, take shortcut
+                return createTranslateB2DHomMatrix(fTranslateX, fTranslateY);
+            }
+            else
+            {
+                /// scale used
+                if(fTools::equalZero(fTranslateX) && fTools::equalZero(fTranslateY))
+                {
+                    /// no translate, but scale.
+                    B2DHomMatrix aRetval;
+
+                    aRetval.set(0, 0, fScaleX);
+                    aRetval.set(1, 1, fScaleY);
+
+                    return aRetval;
+                }
+                else
+                {
+                    /// translate and scale
+                    B2DHomMatrix aRetval(
+                        /* Row 0, Column 0 */ fScaleX,
+                        /* Row 0, Column 1 */ 0.0,
+                        /* Row 0, Column 2 */ fTranslateX,
+                        /* Row 1, Column 0 */ 0.0,
+                        /* Row 1, Column 1 */ fScaleY,
+                        /* Row 1, Column 2 */ fTranslateY);
+
+                    return aRetval;
+                }
+            }
+        }
+
+        B2DHomMatrix createRotateAroundPoint(
+            double fPointX, double fPointY,
+            double fRadiant)
+        {
+            B2DHomMatrix aRetval;
+
+            if(!fTools::equalZero(fRadiant))
+            {
+                double fSin(0.0);
+                double fCos(1.0);
+
+                createSinCosOrthogonal(fSin, fCos, fRadiant);
+
+                aRetval.set3x2(
+                    /* Row 0, Column 0 */ fCos,
+                    /* Row 0, Column 1 */ -fSin,
+                    /* Row 0, Column 2 */ (fPointX * (1.0 - fCos)) + (fSin * fPointY),
+                    /* Row 1, Column 0 */ fSin,
+                    /* Row 1, Column 1 */ fCos,
+                    /* Row 1, Column 2 */ (fPointY * (1.0 - fCos)) - (fSin * fPointX));
+            }
+
+            return aRetval;
+        }
+    } // end of namespace tools
 } // end of namespace basegfx
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dlinegeometry.cxx b/basegfx/source/polygon/b2dlinegeometry.cxx
index 1a9264ab769e..c22b5ea94011 100644
--- a/basegfx/source/polygon/b2dlinegeometry.cxx
+++ b/basegfx/source/polygon/b2dlinegeometry.cxx
@@ -40,6 +40,7 @@
 #include <basegfx/range/b2drange.hxx>
 #include <basegfx/matrix/b2dhommatrix.hxx>
 #include <basegfx/curve/b2dcubicbezier.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -85,11 +86,9 @@ namespace basegfx
                 // get size of the arrow
                 const B2DRange aArrowSize(getRange(rArrow));
 
-                // build ArrowTransform
-                B2DHomMatrix aArrowTransform;
-
-                // center in X, align with axis in Y
-                aArrowTransform.translate(-aArrowSize.getCenter().getX(), -aArrowSize.getMinimum().getY());
+                // build ArrowTransform; center in X, align with axis in Y
+                B2DHomMatrix aArrowTransform(basegfx::tools::createTranslateB2DHomMatrix(
+                    -aArrowSize.getCenter().getX(), -aArrowSize.getMinimum().getY()));
 
                 // scale to target size
                 const double fArrowScale(fWidth / (aArrowSize.getRange().getX()));
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index 0f70c7efafda..0aeaec5c1b95 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -7,7 +7,6 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: b2dpolygon.cxx,v $
- * $Revision: 1.22 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -109,6 +108,16 @@ public:
         maVector[nIndex] = rValue;
     }
 
+    void reserve(sal_uInt32 nCount)
+    {
+        maVector.reserve(nCount);
+    }
+
+    void append(const CoordinateData2D& rValue)
+    {
+        maVector.push_back(rValue);
+    }
+
     void insert(sal_uInt32 nIndex, const CoordinateData2D& rValue, sal_uInt32 nCount)
     {
         if(nCount)
@@ -398,6 +407,17 @@ public:
         }
     }
 
+    void append(const ControlVectorPair2D& rValue)
+    {
+        maVector.push_back(rValue);
+
+        if(!rValue.getPrevVector().equalZero())
+            mnUsedVectors += 1;
+
+        if(!rValue.getNextVector().equalZero())
+            mnUsedVectors += 1;
+    }
+
     void insert(sal_uInt32 nIndex, const ControlVectorPair2D& rValue, sal_uInt32 nCount)
     {
         if(nCount)
@@ -759,6 +779,24 @@ public:
         maPoints.setCoordinate(nIndex, rValue);
     }
 
+    void reserve(sal_uInt32 nCount)
+    {
+        maPoints.reserve(nCount);
+    }
+
+    void append(const basegfx::B2DPoint& rPoint)
+    {
+        mpBufferedData.reset(); // TODO: is this needed?
+        const CoordinateData2D aCoordinate(rPoint);
+        maPoints.append(aCoordinate);
+
+        if(mpControlVector)
+        {
+            const ControlVectorPair2D aVectorPair;
+            mpControlVector->append(aVectorPair);
+        }
+    }
+
     void insert(sal_uInt32 nIndex, const basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
     {
         if(nCount)
@@ -1230,6 +1268,11 @@ namespace basegfx
         }
     }
 
+    void B2DPolygon::reserve(sal_uInt32 nCount)
+    {
+        mpPolygon->reserve(nCount);
+    }
+
     void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPoint& rPoint, sal_uInt32 nCount)
     {
         OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
@@ -1248,6 +1291,11 @@ namespace basegfx
         }
     }
 
+    void B2DPolygon::append(const B2DPoint& rPoint)
+    {
+        mpPolygon->append(rPoint);
+    }
+
     B2DPoint B2DPolygon::getPrevControlPoint(sal_uInt32 nIndex) const
     {
         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
diff --git a/basegfx/source/polygon/b2dpolygonclipper.cxx b/basegfx/source/polygon/b2dpolygonclipper.cxx
index f0d325942c07..87e44ed3d063 100644
--- a/basegfx/source/polygon/b2dpolygonclipper.cxx
+++ b/basegfx/source/polygon/b2dpolygonclipper.cxx
@@ -40,6 +40,7 @@
 #include <basegfx/polygon/b2dpolypolygontools.hxx>
 #include <basegfx/curve/b2dcubicbezier.hxx>
 #include <basegfx/tools/rectcliptools.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -361,11 +362,10 @@ namespace basegfx
             else if(rCandidate.count())
             {
                 const B2DVector aEdge(rPointB - rPointA);
-                B2DHomMatrix aMatrixTransform;
                 B2DPolygon aCandidate(rCandidate);
 
                 // translate and rotate polygon so that given edge is on x axis
-                aMatrixTransform.translate(-rPointA.getX(), -rPointA.getY());
+                B2DHomMatrix aMatrixTransform(basegfx::tools::createTranslateB2DHomMatrix(-rPointA.getX(), -rPointA.getY()));
                 aMatrixTransform.rotate(-atan2(aEdge.getY(), aEdge.getX()));
                 aCandidate.transform(aMatrixTransform);
 
@@ -395,11 +395,10 @@ namespace basegfx
             else if(rCandidate.count())
             {
                 const B2DVector aEdge(rPointB - rPointA);
-                B2DHomMatrix aMatrixTransform;
                 B2DPolyPolygon aCandidate(rCandidate);
 
                 // translate and rotate polygon so that given edge is on x axis
-                aMatrixTransform.translate(-rPointA.getX(), -rPointA.getY());
+                B2DHomMatrix aMatrixTransform(basegfx::tools::createTranslateB2DHomMatrix(-rPointA.getX(), -rPointA.getY()));
                 aMatrixTransform.rotate(-atan2(aEdge.getY(), aEdge.getX()));
                 aCandidate.transform(aMatrixTransform);
 
diff --git a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
index 26016942717d..da6ff8904725 100644
--- a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
+++ b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
@@ -7,7 +7,6 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: b2dpolygoncutandtouch.cxx,v $
- * $Revision: 1.8 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -430,6 +429,7 @@ namespace basegfx
 
             // create subdivided polygons and find cuts between them
             // Keep adaptiveSubdivideByCount due to needed quality
+            aTempPolygonA.reserve(SUBDIVIDE_FOR_CUT_TEST_COUNT + 8);
             aTempPolygonA.append(rCubicA.getStartPoint());
             rCubicA.adaptiveSubdivideByCount(aTempPolygonA, SUBDIVIDE_FOR_CUT_TEST_COUNT);
             aTempPolygonEdge.append(rCurrB);
@@ -470,8 +470,10 @@ namespace basegfx
 
             // create subdivided polygons and find cuts between them
             // Keep adaptiveSubdivideByCount due to needed quality
+            aTempPolygonA.reserve(SUBDIVIDE_FOR_CUT_TEST_COUNT + 8);
             aTempPolygonA.append(rCubicA.getStartPoint());
             rCubicA.adaptiveSubdivideByCount(aTempPolygonA, SUBDIVIDE_FOR_CUT_TEST_COUNT);
+            aTempPolygonB.reserve(SUBDIVIDE_FOR_CUT_TEST_COUNT + 8);
             aTempPolygonB.append(rCubicB.getStartPoint());
             rCubicB.adaptiveSubdivideByCount(aTempPolygonB, SUBDIVIDE_FOR_CUT_TEST_COUNT);
 
@@ -497,6 +499,13 @@ namespace basegfx
             const B2DCubicBezier& rCubicA,
             sal_uInt32 nInd, temporaryPointVector& rTempPoints)
         {
+            // avoid expensive part of this method if possible
+            // TODO: use hasAnyExtremum() method instead when it becomes available
+            double fDummy;
+            const bool bHasAnyExtremum = rCubicA.getMinimumExtremumPosition( fDummy );
+            if( !bHasAnyExtremum )
+                return;
+
             // find all self-intersections on the given bezier segment. Add an entry to the tempPoints
             // for each self intersection point with the cut value describing the relative position on given
             // bezier segment.
@@ -505,6 +514,7 @@ namespace basegfx
 
             // create subdivided polygon and find cuts on it
             // Keep adaptiveSubdivideByCount due to needed quality
+            aTempPolygon.reserve(SUBDIVIDE_FOR_CUT_TEST_COUNT + 8);
             aTempPolygon.append(rCubicA.getStartPoint());
             rCubicA.adaptiveSubdivideByCount(aTempPolygon, SUBDIVIDE_FOR_CUT_TEST_COUNT);
             findCuts(aTempPolygon, aTempPointVector);
@@ -557,7 +567,14 @@ namespace basegfx
                                 const bool bEdgeBIsCurve(aCubicB.isBezier());
                                 const B2DRange aRangeB(aCubicB.getRange());
 
-                                if(aRangeA.overlaps(aRangeB))
+                                // only overlapping segments need to be tested
+                                // consecutive segments touch of course
+                                bool bOverlap = false;
+                                if( b > a+1)
+                                    bOverlap = aRangeA.overlaps(aRangeB);
+                                else
+                                    bOverlap = aRangeA.overlapsMore(aRangeB);
+                                if( bOverlap)
                                 {
                                     if(bEdgeAIsCurve && bEdgeBIsCurve)
                                     {
@@ -599,7 +616,13 @@ namespace basegfx
                                 const B2DPoint aNextB(rCandidate.getB2DPoint(b + 1L == nPointCount ? 0L : b + 1L));
                                 const B2DRange aRangeB(aCurrB, aNextB);
 
-                                if(aRangeA.overlaps(aRangeB))
+                                // consecutive segments touch of course
+                                bool bOverlap = false;
+                                if( b > a+1)
+                                    bOverlap = aRangeA.overlaps(aRangeB);
+                                else
+                                    bOverlap = aRangeA.overlapsMore(aRangeB);
+                                if( bOverlap)
                                 {
                                     findEdgeCutsTwoEdges(aCurrA, aNextA, aCurrB, aNextB, a, b, rTempPoints, rTempPoints);
                                 }
@@ -688,6 +711,7 @@ namespace basegfx
 
             // create subdivided polygon and find cuts on it
             // Keep adaptiveSubdivideByCount due to needed quality
+            aTempPolygon.reserve(SUBDIVIDE_FOR_CUT_TEST_COUNT + 8);
             aTempPolygon.append(rCubicA.getStartPoint());
             rCubicA.adaptiveSubdivideByCount(aTempPolygon, SUBDIVIDE_FOR_CUT_TEST_COUNT);
             findTouches(aTempPolygon, rPointPolygon, aTempPointVector);
@@ -796,7 +820,13 @@ namespace basegfx
                                 const bool bEdgeBIsCurve(aCubicB.isBezier());
                                 const B2DRange aRangeB(aCubicB.getRange());
 
-                                if(aRangeA.overlaps(aRangeB))
+                                // consecutive segments touch of course
+                                bool bOverlap = false;
+                                if( b > a+1)
+                                    bOverlap = aRangeA.overlaps(aRangeB);
+                                else
+                                    bOverlap = aRangeA.overlapsMore(aRangeB);
+                                if( bOverlap)
                                 {
                                     if(bEdgeAIsCurve && bEdgeBIsCurve)
                                     {
@@ -838,7 +868,13 @@ namespace basegfx
                                 const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1L == nPointCountB ? 0L : b + 1L));
                                 const B2DRange aRangeB(aCurrB, aNextB);
 
-                                if(aRangeA.overlaps(aRangeB))
+                                // consecutive segments touch of course
+                                bool bOverlap = false;
+                                if( b > a+1)
+                                    bOverlap = aRangeA.overlaps(aRangeB);
+                                else
+                                    bOverlap = aRangeA.overlapsMore(aRangeB);
+                                if( bOverlap)
                                 {
                                     // test for simple edge-edge cuts
                                     findEdgeCutsTwoEdges(aCurrA, aNextA, aCurrB, aNextB, a, b, rTempPointsA, rTempPointsB);
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index a866eb5ef545..2999b20a2a6c 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -7,7 +7,6 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: b2dpolygontools.cxx,v $
- * $Revision: 1.29.4.1 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -34,7 +33,6 @@
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <osl/diagnose.h>
 #include <rtl/math.hxx>
-
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/range/b2drange.hxx>
@@ -44,6 +42,8 @@
 #include <basegfx/matrix/b3dhommatrix.hxx>
 #include <basegfx/matrix/b2dhommatrix.hxx>
 #include <basegfx/curve/b2dbeziertools.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <osl/mutex.hxx>
 
 #include <numeric>
 #include <limits>
@@ -55,6 +55,7 @@
 #ifdef DBG_UTIL
 static double fAngleBoundStartValue = ANGLE_BOUND_START_VALUE;
 #endif
+#define STEPSPERQUARTER     (3)
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -192,6 +193,9 @@ namespace basegfx
                     B2DCubicBezier aBezier;
                     aBezier.setStartPoint(rCandidate.getB2DPoint(0));
 
+                    // perf: try to avoid too many realloctions by guessing the result's pointcount
+                    aRetval.reserve(nPointCount*4);
+
                     // add start point (always)
                     aRetval.append(aBezier.getStartPoint());
 
@@ -272,6 +276,9 @@ namespace basegfx
                     B2DCubicBezier aBezier;
                     aBezier.setStartPoint(rCandidate.getB2DPoint(0));
 
+                    // perf: try to avoid too many realloctions by guessing the result's pointcount
+                    aRetval.reserve(nPointCount*4);
+
                     // add start point (always)
                     aRetval.append(aBezier.getStartPoint());
 
@@ -342,6 +349,9 @@ namespace basegfx
                     B2DCubicBezier aBezier;
                     aBezier.setStartPoint(rCandidate.getB2DPoint(0));
 
+                    // perf: try to avoid too many realloctions by guessing the result's pointcount
+                    aRetval.reserve(nPointCount*4);
+
                     // add start point (always)
                     aRetval.append(aBezier.getStartPoint());
 
@@ -1832,145 +1842,106 @@ namespace basegfx
             return createPolygonFromEllipse( rCenter, fRadius, fRadius );
         }
 
-        void appendUnitCircleQuadrant(B2DPolygon& rPolygon, sal_uInt32 nQuadrant)
+        B2DPolygon impCreateUnitCircle(sal_uInt32 nStartQuadrant)
         {
-            const double fZero(0.0);
-            const double fOne(1.0);
+            B2DPolygon aUnitCircle;
             const double fKappa((M_SQRT2 - 1.0) * 4.0 / 3.0);
+            const double fScaledKappa(fKappa * (1.0 / STEPSPERQUARTER));
+            const B2DHomMatrix aRotateMatrix(createRotateB2DHomMatrix(F_PI2 / STEPSPERQUARTER));
+
+            B2DPoint aPoint(1.0, 0.0);
+            B2DPoint aForward(1.0, fScaledKappa);
+            B2DPoint aBackward(1.0, -fScaledKappa);
 
-            // create closed unit-circle with 4 segments
-            switch(nQuadrant)
+            if(0 != nStartQuadrant)
             {
-                case 0 : // first quadrant
-                {
-                    rPolygon.append(B2DPoint(fOne, fZero));
-                    rPolygon.appendBezierSegment(B2DPoint(fOne, fKappa), B2DPoint(fKappa, fOne), B2DPoint(fZero, fOne));
-                    break;
-                }
-                case 1 : // second quadrant
-                {
-                    rPolygon.append(B2DPoint(fZero, fOne));
-                    rPolygon.appendBezierSegment(B2DPoint(-fKappa, fOne), B2DPoint(-fOne, fKappa), B2DPoint(-fOne, fZero));
-                    break;
-                }
-                case 2 : // third quadrant
-                {
-                    rPolygon.append(B2DPoint(-fOne, fZero));
-                    rPolygon.appendBezierSegment(B2DPoint(-fOne, -fKappa), B2DPoint(-fKappa, -fOne), B2DPoint(fZero, -fOne));
-                    break;
-                }
-                default : // last quadrant
-                {
-                    rPolygon.append(B2DPoint(fZero, -fOne));
-                    rPolygon.appendBezierSegment(B2DPoint(fKappa, -fOne), B2DPoint(fOne, -fKappa), B2DPoint(fOne, fZero));
-                    break;
-                }
+                const B2DHomMatrix aQuadrantMatrix(createRotateB2DHomMatrix(F_PI2 * (nStartQuadrant % 4)));
+                aPoint *= aQuadrantMatrix;
+                aBackward *= aQuadrantMatrix;
+                aForward *= aQuadrantMatrix;
             }
-        }
 
-        B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant)
-        {
-            B2DPolygon aRetval;
+            aUnitCircle.append(aPoint);
 
-            // create unit-circle with all 4 segments, close it
-            appendUnitCircleQuadrant(aRetval, nStartQuadrant % 4); nStartQuadrant++;
-            appendUnitCircleQuadrant(aRetval, nStartQuadrant % 4); nStartQuadrant++;
-            appendUnitCircleQuadrant(aRetval, nStartQuadrant % 4); nStartQuadrant++;
-            appendUnitCircleQuadrant(aRetval, nStartQuadrant % 4); nStartQuadrant++;
-            aRetval.setClosed(true);
+            for(sal_uInt32 a(0); a < STEPSPERQUARTER * 4; a++)
+            {
+                aPoint *= aRotateMatrix;
+                aBackward *= aRotateMatrix;
+                aUnitCircle.appendBezierSegment(aForward, aBackward, aPoint);
+                aForward *= aRotateMatrix;
+            }
 
-            // remove double points between segments created by segmented creation
-            aRetval.removeDoublePoints();
+            aUnitCircle.setClosed(true);
+            aUnitCircle.removeDoublePoints();
 
-            return aRetval;
+            return aUnitCircle;
         }
 
-        B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY )
+        B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant)
         {
-            const double fOne(1.0);
-            B2DPolygon aRetval(createPolygonFromUnitCircle());
-
-            // transformation necessary?
-            const sal_Bool bScale(!fTools::equal(fRadiusX, fOne) || !fTools::equal(fRadiusY, fOne));
-            const sal_Bool bTranslate(!rCenter.equalZero());
-
-            if(bScale || bTranslate)
+            switch(nStartQuadrant % 4)
             {
-                B2DHomMatrix aMatrix;
-
-                if(bScale)
+                case 1 :
                 {
-                    aMatrix.scale(fRadiusX, fRadiusY);
-                }
-
-                if(bTranslate)
-                {
-                    aMatrix.translate(rCenter.getX(), rCenter.getY());
-                }
+                    static B2DPolygon aUnitCircleStartQuadrantOne;
 
-                aRetval.transform(aMatrix);
-            }
-
-            return aRetval;
-        }
-
-        void appendUnitCircleQuadrantSegment(B2DPolygon& rPolygon, sal_uInt32 nQuadrant, double fStart, double fEnd)
-        {
-            OSL_ENSURE(fStart >= 0.0 && fStart <= 1.0, "appendUnitCircleQuadrantSegment: Access out of range (!)");
-            OSL_ENSURE(fEnd >= 0.0 && fEnd <= 1.0, "appendUnitCircleQuadrantSegment: Access out of range (!)");
-            OSL_ENSURE(fEnd >= fStart, "appendUnitCircleQuadrantSegment: Access out of range (!)");
-            const double fOne(1.0);
-            const bool bStartIsZero(fTools::equalZero(fStart));
-            const bool bEndIsOne(fTools::equal(fEnd, fOne));
-
-            if(bStartIsZero && bEndIsOne)
-            {
-                // add completely
-                appendUnitCircleQuadrant(rPolygon, nQuadrant);
-            }
-            else
-            {
-                // split and add
-                B2DPolygon aQuadrant;
-                appendUnitCircleQuadrant(aQuadrant, nQuadrant);
-                const bool bStartEndEqual(fTools::equal(fStart, fEnd));
+                    if(!aUnitCircleStartQuadrantOne.count())
+                    {
+                        ::osl::Mutex m_mutex;
+                        aUnitCircleStartQuadrantOne = impCreateUnitCircle(1);
+                    }
 
-                if(bStartEndEqual)
+                    return aUnitCircleStartQuadrantOne;
+                }
+                case 2 :
                 {
-                    if(bStartIsZero)
+                    static B2DPolygon aUnitCircleStartQuadrantTwo;
+
+                    if(!aUnitCircleStartQuadrantTwo.count())
                     {
-                        // both zero, add start point
-                        rPolygon.append(aQuadrant.getB2DPoint(0L));
+                        ::osl::Mutex m_mutex;
+                        aUnitCircleStartQuadrantTwo = impCreateUnitCircle(2);
                     }
-                    else if(bEndIsOne)
+
+                    return aUnitCircleStartQuadrantTwo;
+                }
+                case 3 :
+                {
+                    static B2DPolygon aUnitCircleStartQuadrantThree;
+
+                    if(!aUnitCircleStartQuadrantThree.count())
                     {
-                        // both one, add end point
-                        rPolygon.append(aQuadrant.getB2DPoint(1L));
+                        ::osl::Mutex m_mutex;
+                        aUnitCircleStartQuadrantThree = impCreateUnitCircle(3);
                     }
-                    else
-                    {
-                        // both equal but not zero, add split point
-                        B2DCubicBezier aCubicBezier(
-                            aQuadrant.getB2DPoint(0L), aQuadrant.getNextControlPoint(0L),
-                            aQuadrant.getPrevControlPoint(1L), aQuadrant.getB2DPoint(1L));
 
-                        aCubicBezier.split(fStart, &aCubicBezier, 0);
-                        rPolygon.append(aCubicBezier.getEndPoint());
-                    }
+                    return aUnitCircleStartQuadrantThree;
                 }
-                else
+                default : // case 0 :
                 {
-                    B2DCubicBezier aCubicBezier(
-                        aQuadrant.getB2DPoint(0L), aQuadrant.getNextControlPoint(0L),
-                        aQuadrant.getPrevControlPoint(1L), aQuadrant.getB2DPoint(1L));
+                    static B2DPolygon aUnitCircleStartQuadrantZero;
+
+                    if(!aUnitCircleStartQuadrantZero.count())
+                    {
+                        ::osl::Mutex m_mutex;
+                        aUnitCircleStartQuadrantZero = impCreateUnitCircle(0);
+                    }
 
-                    aCubicBezier = aCubicBezier.snippet(fStart, fEnd);
-                    rPolygon.append(aCubicBezier.getStartPoint());
-                    rPolygon.appendBezierSegment(aCubicBezier.getControlPointA(), aCubicBezier.getControlPointB(), aCubicBezier.getEndPoint());
+                    return aUnitCircleStartQuadrantZero;
                 }
             }
         }
 
+        B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY )
+        {
+            B2DPolygon aRetval(createPolygonFromUnitCircle());
+            const B2DHomMatrix aMatrix(createScaleTranslateB2DHomMatrix(fRadiusX, fRadiusY, rCenter.getX(), rCenter.getY()));
+
+            aRetval.transform(aMatrix);
+
+            return aRetval;
+        }
+
         B2DPolygon createPolygonFromUnitEllipseSegment( double fStart, double fEnd )
         {
             B2DPolygon aRetval;
@@ -1997,49 +1968,74 @@ namespace basegfx
                 fEnd = 0.0;
             }
 
-            const sal_uInt32 nQuadrantStart(sal_uInt32(fStart / F_PI2) % 4L);
-            const sal_uInt32 nQuadrantEnd(sal_uInt32(fEnd / F_PI2) % 4L);
-            sal_uInt32 nCurrentQuadrant(nQuadrantStart);
-            bool bStartDone(false);
-            bool bEndDone(false);
-
-            do
+            if(fTools::equal(fStart, fEnd))
             {
-                if(!bStartDone && nQuadrantStart == nCurrentQuadrant)
-                {
-                    if(nQuadrantStart == nQuadrantEnd && fTools::moreOrEqual(fEnd, fStart))
-                    {
-                        // both in one quadrant and defining the complete segment, create start to end
-                        double fSplitOffsetStart((fStart - (nCurrentQuadrant * F_PI2)) / F_PI2);
-                        double fSplitOffsetEnd((fEnd - (nCurrentQuadrant * F_PI2)) / F_PI2);
-                        appendUnitCircleQuadrantSegment(aRetval, nCurrentQuadrant, fSplitOffsetStart, fSplitOffsetEnd);
-                        bStartDone = bEndDone = true;
-                    }
-                    else
-                    {
-                        // create start to quadrant end
-                        const double fSplitOffsetStart((fStart - (nCurrentQuadrant * F_PI2)) / F_PI2);
-                        appendUnitCircleQuadrantSegment(aRetval, nCurrentQuadrant, fSplitOffsetStart, 1.0);
-                        bStartDone = true;
-                    }
-                }
-                else if(!bEndDone && nQuadrantEnd == nCurrentQuadrant)
+                // same start and end angle, add single point
+                aRetval.append(B2DPoint(cos(fStart), sin(fStart)));
+            }
+            else
+            {
+                const sal_uInt32 nSegments(STEPSPERQUARTER * 4);
+                const double fAnglePerSegment(F_PI2 / STEPSPERQUARTER);
+                const sal_uInt32 nStartSegment(sal_uInt32(fStart / fAnglePerSegment) % nSegments);
+                const sal_uInt32 nEndSegment(sal_uInt32(fEnd / fAnglePerSegment) % nSegments);
+                const double fKappa((M_SQRT2 - 1.0) * 4.0 / 3.0);
+                const double fScaledKappa(fKappa * (1.0 / STEPSPERQUARTER));
+
+                B2DPoint aSegStart(cos(fStart), sin(fStart));
+                aRetval.append(aSegStart);
+
+                if(nStartSegment == nEndSegment && fTools::more(fEnd, fStart))
                 {
-                    // create quadrant start to end
-                    const double fSplitOffsetEnd((fEnd - (nCurrentQuadrant * F_PI2)) / F_PI2);
-                    appendUnitCircleQuadrantSegment(aRetval, nCurrentQuadrant, 0.0, fSplitOffsetEnd);
-                    bEndDone = true;
+                    // start and end in one sector and in the right order, create in one segment
+                    const B2DPoint aSegEnd(cos(fEnd), sin(fEnd));
+                    const double fFactor(fScaledKappa * ((fEnd - fStart) / fAnglePerSegment));
+
+                    aRetval.appendBezierSegment(
+                        aSegStart + (B2DPoint(-aSegStart.getY(), aSegStart.getX()) * fFactor),
+                        aSegEnd - (B2DPoint(-aSegEnd.getY(), aSegEnd.getX()) * fFactor),
+                        aSegEnd);
                 }
                 else
                 {
-                    // add quadrant completely
-                    appendUnitCircleQuadrant(aRetval, nCurrentQuadrant);
-                }
+                    double fSegEndRad((nStartSegment + 1) * fAnglePerSegment);
+                    double fFactor(fScaledKappa * ((fSegEndRad - fStart) / fAnglePerSegment));
+                    B2DPoint aSegEnd(cos(fSegEndRad), sin(fSegEndRad));
+
+                    aRetval.appendBezierSegment(
+                        aSegStart + (B2DPoint(-aSegStart.getY(), aSegStart.getX()) * fFactor),
+                        aSegEnd - (B2DPoint(-aSegEnd.getY(), aSegEnd.getX()) * fFactor),
+                        aSegEnd);
+
+                    sal_uInt32 nSegment((nStartSegment + 1) % nSegments);
+                    aSegStart = aSegEnd;
+
+                    while(nSegment != nEndSegment)
+                    {
+                        // No end in this sector, add full sector.
+                        fSegEndRad = (nSegment + 1) * fAnglePerSegment;
+                        aSegEnd = B2DPoint(cos(fSegEndRad), sin(fSegEndRad));
+
+                        aRetval.appendBezierSegment(
+                            aSegStart + (B2DPoint(-aSegStart.getY(), aSegStart.getX()) * fScaledKappa),
+                            aSegEnd - (B2DPoint(-aSegEnd.getY(), aSegEnd.getX()) * fScaledKappa),
+                            aSegEnd);
+
+                        nSegment = (nSegment + 1) % nSegments;
+                        aSegStart = aSegEnd;
+                    }
 
-                // next step
-                nCurrentQuadrant = (nCurrentQuadrant + 1L) % 4L;
+                    // End in this sector
+                    const double fSegStartRad(nSegment * fAnglePerSegment);
+                    fFactor = fScaledKappa * ((fEnd - fSegStartRad) / fAnglePerSegment);
+                    aSegEnd = B2DPoint(cos(fEnd), sin(fEnd));
+
+                    aRetval.appendBezierSegment(
+                        aSegStart + (B2DPoint(-aSegStart.getY(), aSegStart.getX()) * fFactor),
+                        aSegEnd - (B2DPoint(-aSegEnd.getY(), aSegEnd.getX()) * fFactor),
+                        aSegEnd);
+                }
             }
-            while(!(bStartDone && bEndDone));
 
             // remove double points between segments created by segmented creation
             aRetval.removeDoublePoints();
@@ -2050,28 +2046,9 @@ namespace basegfx
         B2DPolygon createPolygonFromEllipseSegment( const B2DPoint& rCenter, double fRadiusX, double fRadiusY, double fStart, double fEnd )
         {
             B2DPolygon aRetval(createPolygonFromUnitEllipseSegment(fStart, fEnd));
+            const B2DHomMatrix aMatrix(createScaleTranslateB2DHomMatrix(fRadiusX, fRadiusY, rCenter.getX(), rCenter.getY()));
 
-            // transformation necessary?
-            const double fOne(1.0);
-            const sal_Bool bScale(!fTools::equal(fRadiusX, fOne) || !fTools::equal(fRadiusY, fOne));
-            const sal_Bool bTranslate(!rCenter.equalZero());
-
-            if(bScale || bTranslate)
-            {
-                B2DHomMatrix aMatrix;
-
-                if(bScale)
-                {
-                    aMatrix.scale(fRadiusX, fRadiusY);
-                }
-
-                if(bTranslate)
-                {
-                    aMatrix.translate(rCenter.getX(), rCenter.getY());
-                }
-
-                aRetval.transform(aMatrix);
-            }
+            aRetval.transform(aMatrix);
 
             return aRetval;
         }
@@ -2702,11 +2679,7 @@ namespace basegfx
 
             if(nPointCount)
             {
-                B2DHomMatrix aMatrix;
-
-                aMatrix.translate(-rCenter.getX(), -rCenter.getY());
-                aMatrix.rotate(fAngle);
-                aMatrix.translate(rCenter.getX(), rCenter.getY());
+                const B2DHomMatrix aMatrix(basegfx::tools::createRotateAroundPoint(rCenter, fAngle));
 
                 aRetval.transform(aMatrix);
             }
@@ -3270,6 +3243,9 @@ namespace basegfx
                 B2DCubicBezier aBezier;
                 aBezier.setStartPoint(rCandidate.getB2DPoint(0));
 
+                // try to avoid costly reallocations
+                aRetval.reserve( nEdgeCount+1);
+
                 // add start point
                 aRetval.append(aBezier.getStartPoint());
 
diff --git a/basegfx/source/polygon/b2dsvgpolypolygon.cxx b/basegfx/source/polygon/b2dsvgpolypolygon.cxx
index c18e6d5e5af8..e6633d9188a6 100644
--- a/basegfx/source/polygon/b2dsvgpolypolygon.cxx
+++ b/basegfx/source/polygon/b2dsvgpolypolygon.cxx
@@ -36,6 +36,7 @@
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
 #include <rtl/ustring.hxx>
 #include <rtl/math.hxx>
 
@@ -708,7 +709,7 @@ namespace basegfx
                                 // |y1'| = |-sin phi  cos phi|  |(y1 - y2)/2|
                                 const B2DPoint p1(nLastX, nLastY);
                                 const B2DPoint p2(nX, nY);
-                                B2DHomMatrix aTransform; aTransform.rotate(-fPhi*M_PI/180);
+                                B2DHomMatrix aTransform(basegfx::tools::createRotateB2DHomMatrix(-fPhi*M_PI/180));
 
                                 const B2DPoint p1_prime( aTransform * B2DPoint(((p1-p2)/2.0)) );
 
@@ -800,8 +801,7 @@ namespace basegfx
                                         fTheta1, fTheta2 ));
 
                                 // transform ellipse by rotation & move to final center
-                                aTransform.identity();
-                                aTransform.scale(fRX,fRY);
+                                aTransform = basegfx::tools::createScaleB2DHomMatrix(fRX, fRY);
                                 aTransform.translate(aCenter_prime.getX(),
                                                      aCenter_prime.getY());
                                 aTransform.rotate(fPhi*M_PI/180);
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index ea303886dd88..52e0f0fcc36f 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -875,52 +875,147 @@ namespace basegfx
             }
             else
             {
+                bool bRetval(false);
                 const B3DVector aPlaneNormal(rCandidate.getNormal());
 
                 if(!aPlaneNormal.equalZero())
                 {
-                    const double fAbsX(fabs(aPlaneNormal.getX()));
-                    const double fAbsY(fabs(aPlaneNormal.getY()));
-                    const double fAbsZ(fabs(aPlaneNormal.getZ()));
+                    const sal_uInt32 nPointCount(rCandidate.count());
 
-                    if(fAbsX > fAbsY && fAbsX > fAbsZ)
+                    if(nPointCount)
                     {
-                        // normal points mostly in X-Direction, use YZ-Polygon projection for check
-                        B3DHomMatrix aTrans;
+                        B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nPointCount - 1));
+                        const double fAbsX(fabs(aPlaneNormal.getX()));
+                        const double fAbsY(fabs(aPlaneNormal.getY()));
+                        const double fAbsZ(fabs(aPlaneNormal.getZ()));
 
-                        aTrans.set(0, 0, 0.0);
-                        aTrans.set(0, 1, 1.0);
-                        aTrans.set(1, 1, 0.0);
-                        aTrans.set(1, 2, 1.0);
-
-                        const B2DPolygon aYZ(createB2DPolygonFromB3DPolygon(rCandidate, aTrans));
-
-                        return isInside(aYZ, B2DPoint(rPoint.getY(), rPoint.getZ()), bWithBorder);
-                    }
-                    else if(fAbsY > fAbsX && fAbsY > fAbsZ)
-                    {
-                        // normal points mostly in Y-Direction, use XZ-Polygon projection for check
-                        B3DHomMatrix aTrans;
-
-                        aTrans.set(1, 1, 0.0);
-                        aTrans.set(1, 2, 1.0);
-
-                        const B2DPolygon aXZ(createB2DPolygonFromB3DPolygon(rCandidate, aTrans));
-
-                        return isInside(aXZ, B2DPoint(rPoint.getX(), rPoint.getZ()), bWithBorder);
-                    }
-                    else
-                    {
-                        // normal points mostly in Z-Direction, use XY-Polygon projection for check
-                        B3DHomMatrix aTrans;
-
-                        const B2DPolygon aXY(createB2DPolygonFromB3DPolygon(rCandidate, aTrans));
-
-                        return isInside(aXY, B2DPoint(rPoint.getX(), rPoint.getY()), bWithBorder);
+                        if(fAbsX > fAbsY && fAbsX > fAbsZ)
+                        {
+                            // normal points mostly in X-Direction, use YZ-Polygon projection for check
+                            // x -> y, y -> z
+                            for(sal_uInt32 a(0); a < nPointCount; a++)
+                            {
+                                const B3DPoint aPreviousPoint(aCurrentPoint);
+                                aCurrentPoint = rCandidate.getB3DPoint(a);
+
+                                // cross-over in Z?
+                                const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ()));
+                                const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ()));
+
+                                if(bCompZA != bCompZB)
+                                {
+                                    // cross-over in Y?
+                                    const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY()));
+                                    const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY()));
+
+                                    if(bCompYA == bCompYB)
+                                    {
+                                        if(bCompYA)
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        const double fCompare(
+                                            aCurrentPoint.getY() - (aCurrentPoint.getZ() - rPoint.getZ()) *
+                                            (aPreviousPoint.getY() - aCurrentPoint.getY()) /
+                                            (aPreviousPoint.getZ() - aCurrentPoint.getZ()));
+
+                                        if(fTools::more(fCompare, rPoint.getY()))
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else if(fAbsY > fAbsX && fAbsY > fAbsZ)
+                        {
+                            // normal points mostly in Y-Direction, use XZ-Polygon projection for check
+                            // x -> x, y -> z
+                            for(sal_uInt32 a(0); a < nPointCount; a++)
+                            {
+                                const B3DPoint aPreviousPoint(aCurrentPoint);
+                                aCurrentPoint = rCandidate.getB3DPoint(a);
+
+                                // cross-over in Z?
+                                const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ()));
+                                const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ()));
+
+                                if(bCompZA != bCompZB)
+                                {
+                                    // cross-over in X?
+                                    const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX()));
+                                    const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX()));
+
+                                    if(bCompXA == bCompXB)
+                                    {
+                                        if(bCompXA)
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        const double fCompare(
+                                            aCurrentPoint.getX() - (aCurrentPoint.getZ() - rPoint.getZ()) *
+                                            (aPreviousPoint.getX() - aCurrentPoint.getX()) /
+                                            (aPreviousPoint.getZ() - aCurrentPoint.getZ()));
+
+                                        if(fTools::more(fCompare, rPoint.getX()))
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // normal points mostly in Z-Direction, use XY-Polygon projection for check
+                            // x -> x, y -> y
+                            for(sal_uInt32 a(0); a < nPointCount; a++)
+                            {
+                                const B3DPoint aPreviousPoint(aCurrentPoint);
+                                aCurrentPoint = rCandidate.getB3DPoint(a);
+
+                                // cross-over in Y?
+                                const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY()));
+                                const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY()));
+
+                                if(bCompYA != bCompYB)
+                                {
+                                    // cross-over in X?
+                                    const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX()));
+                                    const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX()));
+
+                                    if(bCompXA == bCompXB)
+                                    {
+                                        if(bCompXA)
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        const double fCompare(
+                                            aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
+                                            (aPreviousPoint.getX() - aCurrentPoint.getX()) /
+                                            (aPreviousPoint.getY() - aCurrentPoint.getY()));
+
+                                        if(fTools::more(fCompare, rPoint.getX()))
+                                        {
+                                            bRetval = !bRetval;
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
 
-                return false;
+                return bRetval;
             }
         }
 
diff --git a/basegfx/source/tools/gradienttools.cxx b/basegfx/source/tools/gradienttools.cxx
index 447eac056c55..8a2d38f44c6f 100644
--- a/basegfx/source/tools/gradienttools.cxx
+++ b/basegfx/source/tools/gradienttools.cxx
@@ -32,9 +32,9 @@
 #include "precompiled_basegfx.hxx"
 
 #include <basegfx/tools/gradienttools.hxx>
-
 #include <basegfx/point/b2dpoint.hxx>
 #include <basegfx/range/b2drange.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
 
 namespace basegfx
 {
@@ -94,9 +94,9 @@ namespace basegfx
         {
             const B2DPoint aCenter(0.5*fTargetSizeX,
                                    0.5*fTargetSizeY);
-            o_rGradientInfo.maTextureTransform.translate(-aCenter.getX(), -aCenter.getY());
-            o_rGradientInfo.maTextureTransform.rotate(fAngle);
-            o_rGradientInfo.maTextureTransform.translate(aCenter.getX(), aCenter.getY());
+            o_rGradientInfo.maTextureTransform =
+                o_rGradientInfo.maTextureTransform
+                * basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
         }
 
         // add object translate
@@ -162,9 +162,9 @@ namespace basegfx
             {
                 const B2DPoint aCenter(0.5*fTargetSizeX,
                                        0.5*fTargetSizeY);
-                o_rGradientInfo.maTextureTransform.translate(-aCenter.getX(), -aCenter.getY());
-                o_rGradientInfo.maTextureTransform.rotate(fAngle);
-                o_rGradientInfo.maTextureTransform.translate(aCenter.getX(), aCenter.getY());
+                o_rGradientInfo.maTextureTransform =
+                    o_rGradientInfo.maTextureTransform
+                    * basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
             }
         }
 
@@ -232,9 +232,9 @@ namespace basegfx
         {
             const B2DPoint aCenter(0.5*fTargetSizeX,
                                    0.5*fTargetSizeY);
-            o_rGradientInfo.maTextureTransform.translate(-aCenter.getX(), -aCenter.getY());
-            o_rGradientInfo.maTextureTransform.rotate(fAngle);
-            o_rGradientInfo.maTextureTransform.translate(aCenter.getX(), aCenter.getY());
+            o_rGradientInfo.maTextureTransform =
+                o_rGradientInfo.maTextureTransform
+                * basegfx::tools::createRotateAroundPoint(aCenter, fAngle);
         }
 
         // add defined offsets after rotation
diff --git a/basegfx/source/tools/unopolypolygon.cxx b/basegfx/source/tools/unopolypolygon.cxx
index 6d8fcd83edb0..05dbe5b1c823 100755
--- a/basegfx/source/tools/unopolypolygon.cxx
+++ b/basegfx/source/tools/unopolypolygon.cxx
@@ -44,8 +44,8 @@
 #include <basegfx/tools/canvastools.hxx>
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolypolygontools.hxx>
-
 #include <basegfx/tools/unopolypolygon.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
 
 
 using namespace ::com::sun::star;
@@ -138,9 +138,7 @@ namespace unotools
 
         if( !aOffset.equalZero() )
         {
-            B2DHomMatrix aTranslate;
-            aTranslate.translate( aOffset.getX(), aOffset.getY() );
-
+            const B2DHomMatrix aTranslate(tools::createTranslateB2DHomMatrix(aOffset));
             aSrcPoly.transform( aTranslate );
         }