loplugin:flatten in basegfx

Change-Id: Ic8bc586e1a4977322dcb371c0fff6411783df9d7
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/92484
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

13 files changed, 1106 insertions, 1106 deletions

diff --git a/basegfx/source/color/bcolormodifier.cxx b/basegfx/source/color/bcolormodifier.cxx
index b98b19f98652..e2a2567288c6 100644
--- a/basegfx/source/color/bcolormodifier.cxx
+++ b/basegfx/source/color/bcolormodifier.cxx
@@ -232,33 +232,33 @@ namespace basegfx
         mfBlueOff(0.0),
         mbUseIt(false)
     {
-        if(!basegfx::fTools::equalZero(mfRed)
+        if(!(!basegfx::fTools::equalZero(mfRed)
             || !basegfx::fTools::equalZero(mfGreen)
             || !basegfx::fTools::equalZero(mfBlue)
             || !basegfx::fTools::equalZero(mfLuminance)
-            || !basegfx::fTools::equalZero(mfContrast))
+            || !basegfx::fTools::equalZero(mfContrast)))
+            return;
+
+        // calculate slope
+        if(mfContrast >= 0.0)
+        {
+            mfContrastOff = 128.0 / (128.0 - (mfContrast * 127.0));
+        }
+        else
         {
-            // calculate slope
-            if(mfContrast >= 0.0)
-            {
-                mfContrastOff = 128.0 / (128.0 - (mfContrast * 127.0));
-            }
-            else
-            {
-                mfContrastOff = ( 128.0 + (mfContrast * 127.0)) / 128.0;
-            }
-
-            // calculate unified contrast offset
-            const double fPreparedContrastOff((128.0 - mfContrastOff * 128.0) / 255.0);
-            const double fCombinedOffset(mfLuminance + fPreparedContrastOff);
-
-            // set full offsets
-            mfRedOff = mfRed + fCombinedOffset;
-            mfGreenOff = mfGreen + fCombinedOffset;
-            mfBlueOff = mfBlue + fCombinedOffset;
-
-            mbUseIt = true;
+            mfContrastOff = ( 128.0 + (mfContrast * 127.0)) / 128.0;
         }
+
+        // calculate unified contrast offset
+        const double fPreparedContrastOff((128.0 - mfContrastOff * 128.0) / 255.0);
+        const double fCombinedOffset(mfLuminance + fPreparedContrastOff);
+
+        // set full offsets
+        mfRedOff = mfRed + fCombinedOffset;
+        mfGreenOff = mfGreen + fCombinedOffset;
+        mfBlueOff = mfBlue + fCombinedOffset;
+
+        mbUseIt = true;
     }
 
     BColorModifier_RGBLuminanceContrast::~BColorModifier_RGBLuminanceContrast()
diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index e1fad1e8a552..4fd2e33fe299 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -381,86 +381,86 @@ namespace basegfx
 
     void B2DCubicBezier::testAndSolveTrivialBezier()
     {
-        if(maControlPointA != maStartPoint || maControlPointB != maEndPoint)
-        {
-            const B2DVector aEdge(maEndPoint - maStartPoint);
+        if(maControlPointA == maStartPoint && maControlPointB == maEndPoint)
+            return;
 
-            // controls parallel to edge can be trivial. No edge -> not parallel -> control can
-            // still not be trivial (e.g. ballon loop)
-            if(!aEdge.equalZero())
-            {
-                // get control vectors
-                const B2DVector aVecA(maControlPointA - maStartPoint);
-                const B2DVector aVecB(maControlPointB - maEndPoint);
-
-                // check if trivial per se
-                bool bAIsTrivial(aVecA.equalZero());
-                bool bBIsTrivial(aVecB.equalZero());
-
-                // #i102241# prepare inverse edge length to normalize cross values;
-                // else the small compare value used in fTools::equalZero
-                // will be length dependent and this detection will work as less
-                // precise as longer the edge is. In principle, the length of the control
-                // vector would need to be used too, but to be trivial it is assumed to
-                // be of roughly equal length to the edge, so edge length can be used
-                // for both. Only needed when one of both is not trivial per se.
-                const double fInverseEdgeLength(bAIsTrivial && bBIsTrivial
-                    ? 1.0
-                    : 1.0 / aEdge.getLength());
-
-                // if A is not zero, check if it could be
-                if(!bAIsTrivial)
-                {
-                    // #i102241# parallel to edge? Check aVecA, aEdge. Use cross() which does what
-                    // we need here with the precision we need
-                    const double fCross(aVecA.cross(aEdge) * fInverseEdgeLength);
+        const B2DVector aEdge(maEndPoint - maStartPoint);
 
-                    if(fTools::equalZero(fCross))
-                    {
-                        // get scale to edge. Use bigger distance for numeric quality
-                        const double fScale(fabs(aEdge.getX()) > fabs(aEdge.getY())
-                            ? aVecA.getX() / aEdge.getX()
-                            : aVecA.getY() / aEdge.getY());
+        // controls parallel to edge can be trivial. No edge -> not parallel -> control can
+        // still not be trivial (e.g. ballon loop)
+        if(aEdge.equalZero())
+            return;
 
-                        // relative end point of vector in edge range?
-                        if (fTools::betweenOrEqualEither(fScale, 0.0, 1.0))
-                        {
-                            bAIsTrivial = true;
-                        }
-                    }
-                }
+        // get control vectors
+        const B2DVector aVecA(maControlPointA - maStartPoint);
+        const B2DVector aVecB(maControlPointB - maEndPoint);
+
+        // check if trivial per se
+        bool bAIsTrivial(aVecA.equalZero());
+        bool bBIsTrivial(aVecB.equalZero());
+
+        // #i102241# prepare inverse edge length to normalize cross values;
+        // else the small compare value used in fTools::equalZero
+        // will be length dependent and this detection will work as less
+        // precise as longer the edge is. In principle, the length of the control
+        // vector would need to be used too, but to be trivial it is assumed to
+        // be of roughly equal length to the edge, so edge length can be used
+        // for both. Only needed when one of both is not trivial per se.
+        const double fInverseEdgeLength(bAIsTrivial && bBIsTrivial
+            ? 1.0
+            : 1.0 / aEdge.getLength());
+
+        // if A is not zero, check if it could be
+        if(!bAIsTrivial)
+        {
+            // #i102241# parallel to edge? Check aVecA, aEdge. Use cross() which does what
+            // we need here with the precision we need
+            const double fCross(aVecA.cross(aEdge) * fInverseEdgeLength);
 
-                // if B is not zero, check if it could be, but only if A is already trivial;
-                // else solve to trivial will not be possible for whole edge
-                if(bAIsTrivial && !bBIsTrivial)
+            if(fTools::equalZero(fCross))
+            {
+                // get scale to edge. Use bigger distance for numeric quality
+                const double fScale(fabs(aEdge.getX()) > fabs(aEdge.getY())
+                    ? aVecA.getX() / aEdge.getX()
+                    : aVecA.getY() / aEdge.getY());
+
+                // relative end point of vector in edge range?
+                if (fTools::betweenOrEqualEither(fScale, 0.0, 1.0))
                 {
-                    // parallel to edge? Check aVecB, aEdge
-                    const double fCross(aVecB.cross(aEdge) * fInverseEdgeLength);
+                    bAIsTrivial = true;
+                }
+            }
+        }
 
-                    if(fTools::equalZero(fCross))
-                    {
-                        // get scale to edge. Use bigger distance for numeric quality
-                        const double fScale(fabs(aEdge.getX()) > fabs(aEdge.getY())
-                            ? aVecB.getX() / aEdge.getX()
-                            : aVecB.getY() / aEdge.getY());
+        // if B is not zero, check if it could be, but only if A is already trivial;
+        // else solve to trivial will not be possible for whole edge
+        if(bAIsTrivial && !bBIsTrivial)
+        {
+            // parallel to edge? Check aVecB, aEdge
+            const double fCross(aVecB.cross(aEdge) * fInverseEdgeLength);
 
-                        // end point of vector in edge range? Caution: controlB is directed AGAINST edge
-                        if (fTools::betweenOrEqualEither(fScale, -1.0, 0.0))
-                        {
-                            bBIsTrivial = true;
-                        }
-                    }
-                }
+            if(fTools::equalZero(fCross))
+            {
+                // get scale to edge. Use bigger distance for numeric quality
+                const double fScale(fabs(aEdge.getX()) > fabs(aEdge.getY())
+                    ? aVecB.getX() / aEdge.getX()
+                    : aVecB.getY() / aEdge.getY());
 
-                // if both are/can be reduced, do it.
-                // Not possible if only one is/can be reduced (!)
-                if(bAIsTrivial && bBIsTrivial)
+                // end point of vector in edge range? Caution: controlB is directed AGAINST edge
+                if (fTools::betweenOrEqualEither(fScale, -1.0, 0.0))
                 {
-                    maControlPointA = maStartPoint;
-                    maControlPointB = maEndPoint;
+                    bBIsTrivial = true;
                 }
             }
         }
+
+        // if both are/can be reduced, do it.
+        // Not possible if only one is/can be reduced (!)
+        if(bAIsTrivial && bBIsTrivial)
+        {
+            maControlPointA = maStartPoint;
+            maControlPointB = maEndPoint;
+        }
     }
 
     namespace {
@@ -994,27 +994,27 @@ namespace basegfx
 
     void B2DCubicBezier::transform(const basegfx::B2DHomMatrix& rMatrix)
     {
-        if(!rMatrix.isIdentity())
+        if(rMatrix.isIdentity())
+            return;
+
+        if(maControlPointA == maStartPoint)
         {
-            if(maControlPointA == maStartPoint)
-            {
-                maControlPointA = maStartPoint = rMatrix * maStartPoint;
-            }
-            else
-            {
-                maStartPoint *= rMatrix;
-                maControlPointA *= rMatrix;
-            }
+            maControlPointA = maStartPoint = rMatrix * maStartPoint;
+        }
+        else
+        {
+            maStartPoint *= rMatrix;
+            maControlPointA *= rMatrix;
+        }
 
-            if(maControlPointB == maEndPoint)
-            {
-                maControlPointB = maEndPoint = rMatrix * maEndPoint;
-            }
-            else
-            {
-                maEndPoint *= rMatrix;
-                maControlPointB *= rMatrix;
-            }
+        if(maControlPointB == maEndPoint)
+        {
+            maControlPointB = maEndPoint = rMatrix * maEndPoint;
+        }
+        else
+        {
+            maEndPoint *= rMatrix;
+            maControlPointB *= rMatrix;
         }
     }
 
diff --git a/basegfx/source/matrix/b2dhommatrix.cxx b/basegfx/source/matrix/b2dhommatrix.cxx
index 61178c496011..89088e8ebdbf 100644
--- a/basegfx/source/matrix/b2dhommatrix.cxx
+++ b/basegfx/source/matrix/b2dhommatrix.cxx
@@ -181,21 +181,21 @@ namespace basegfx
 
     void B2DHomMatrix::rotate(double fRadiant)
     {
-        if(!fTools::equalZero(fRadiant))
-        {
-            double fSin(0.0);
-            double fCos(1.0);
+        if(fTools::equalZero(fRadiant))
+            return;
 
-            utils::createSinCosOrthogonal(fSin, fCos, fRadiant);
-            Impl2DHomMatrix aRotMat;
+        double fSin(0.0);
+        double fCos(1.0);
 
-            aRotMat.set(0, 0, fCos);
-            aRotMat.set(1, 1, fCos);
-            aRotMat.set(1, 0, fSin);
-            aRotMat.set(0, 1, -fSin);
+        utils::createSinCosOrthogonal(fSin, fCos, fRadiant);
+        Impl2DHomMatrix aRotMat;
 
-            mpImpl->doMulMatrix(aRotMat);
-        }
+        aRotMat.set(0, 0, fCos);
+        aRotMat.set(1, 1, fCos);
+        aRotMat.set(1, 0, fSin);
+        aRotMat.set(0, 1, -fSin);
+
+        mpImpl->doMulMatrix(aRotMat);
     }
 
     void B2DHomMatrix::translate(double fX, double fY)
diff --git a/basegfx/source/matrix/b3dhommatrix.cxx b/basegfx/source/matrix/b3dhommatrix.cxx
index e3f3d3d28475..2a56c7a28795 100644
--- a/basegfx/source/matrix/b3dhommatrix.cxx
+++ b/basegfx/source/matrix/b3dhommatrix.cxx
@@ -149,50 +149,50 @@ namespace basegfx
 
     void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
     {
-        if(!fTools::equalZero(fAngleX) || !fTools::equalZero(fAngleY) || !fTools::equalZero(fAngleZ))
+        if(!(!fTools::equalZero(fAngleX) || !fTools::equalZero(fAngleY) || !fTools::equalZero(fAngleZ)))
+            return;
+
+        if(!fTools::equalZero(fAngleX))
         {
-            if(!fTools::equalZero(fAngleX))
-            {
-                Impl3DHomMatrix aRotMatX;
-                double fSin(sin(fAngleX));
-                double fCos(cos(fAngleX));
+            Impl3DHomMatrix aRotMatX;
+            double fSin(sin(fAngleX));
+            double fCos(cos(fAngleX));
 
-                aRotMatX.set(1, 1, fCos);
-                aRotMatX.set(2, 2, fCos);
-                aRotMatX.set(2, 1, fSin);
-                aRotMatX.set(1, 2, -fSin);
+            aRotMatX.set(1, 1, fCos);
+            aRotMatX.set(2, 2, fCos);
+            aRotMatX.set(2, 1, fSin);
+            aRotMatX.set(1, 2, -fSin);
 
-                mpImpl->doMulMatrix(aRotMatX);
-            }
+            mpImpl->doMulMatrix(aRotMatX);
+        }
 
-            if(!fTools::equalZero(fAngleY))
-            {
-                Impl3DHomMatrix aRotMatY;
-                double fSin(sin(fAngleY));
-                double fCos(cos(fAngleY));
+        if(!fTools::equalZero(fAngleY))
+        {
+            Impl3DHomMatrix aRotMatY;
+            double fSin(sin(fAngleY));
+            double fCos(cos(fAngleY));
 
-                aRotMatY.set(0, 0, fCos);
-                aRotMatY.set(2, 2, fCos);
-                aRotMatY.set(0, 2, fSin);
-                aRotMatY.set(2, 0, -fSin);
+            aRotMatY.set(0, 0, fCos);
+            aRotMatY.set(2, 2, fCos);
+            aRotMatY.set(0, 2, fSin);
+            aRotMatY.set(2, 0, -fSin);
 
-                mpImpl->doMulMatrix(aRotMatY);
-            }
+            mpImpl->doMulMatrix(aRotMatY);
+        }
 
-            if(!fTools::equalZero(fAngleZ))
-            {
-                Impl3DHomMatrix aRotMatZ;
-                double fSin(sin(fAngleZ));
-                double fCos(cos(fAngleZ));
+        if(fTools::equalZero(fAngleZ))
+            return;
 
-                aRotMatZ.set(0, 0, fCos);
-                aRotMatZ.set(1, 1, fCos);
-                aRotMatZ.set(1, 0, fSin);
-                aRotMatZ.set(0, 1, -fSin);
+        Impl3DHomMatrix aRotMatZ;
+        double fSin(sin(fAngleZ));
+        double fCos(cos(fAngleZ));
 
-                mpImpl->doMulMatrix(aRotMatZ);
-            }
-        }
+        aRotMatZ.set(0, 0, fCos);
+        aRotMatZ.set(1, 1, fCos);
+        aRotMatZ.set(1, 0, fSin);
+        aRotMatZ.set(0, 1, -fSin);
+
+        mpImpl->doMulMatrix(aRotMatZ);
     }
 
     void B3DHomMatrix::rotate(const B3DTuple& rRotation)
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index 4cf280cd5b91..18695ec2be19 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -139,20 +139,20 @@ public:
 
     void flip(bool bIsClosed)
     {
-        if(maVector.size() > 1)
-        {
-            // to keep the same point at index 0, just flip all points except the
-            // first one when closed
-            const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
-            CoordinateData2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
-            CoordinateData2DVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                std::swap(*aStart, *aEnd);
-                ++aStart;
-                --aEnd;
-            }
+        // to keep the same point at index 0, just flip all points except the
+        // first one when closed
+        const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
+        CoordinateData2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
+        CoordinateData2DVector::iterator aEnd(maVector.end() - 1);
+
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            std::swap(*aStart, *aEnd);
+            ++aStart;
+            --aEnd;
         }
     }
 
@@ -359,101 +359,101 @@ public:
 
     void insert(sal_uInt32 nIndex, const ControlVectorPair2D& rValue, sal_uInt32 nCount)
     {
-        if(nCount)
-        {
-            // add nCount copies of rValue
-            ControlVectorPair2DVector::iterator aIndex(maVector.begin());
-            aIndex += nIndex;
-            maVector.insert(aIndex, nCount, rValue);
+        if(!nCount)
+            return;
 
-            if(!rValue.getPrevVector().equalZero())
-                mnUsedVectors += nCount;
+        // add nCount copies of rValue
+        ControlVectorPair2DVector::iterator aIndex(maVector.begin());
+        aIndex += nIndex;
+        maVector.insert(aIndex, nCount, rValue);
 
-            if(!rValue.getNextVector().equalZero())
-                mnUsedVectors += nCount;
-        }
+        if(!rValue.getPrevVector().equalZero())
+            mnUsedVectors += nCount;
+
+        if(!rValue.getNextVector().equalZero())
+            mnUsedVectors += nCount;
     }
 
     void insert(sal_uInt32 nIndex, const ControlVectorArray2D& rSource)
     {
         const sal_uInt32 nCount(rSource.maVector.size());
 
-        if(nCount)
-        {
-            // insert data
-            ControlVectorPair2DVector::iterator aIndex(maVector.begin());
-            aIndex += nIndex;
-            ControlVectorPair2DVector::const_iterator aStart(rSource.maVector.begin());
-            ControlVectorPair2DVector::const_iterator aEnd(rSource.maVector.end());
-            maVector.insert(aIndex, aStart, aEnd);
+        if(!nCount)
+            return;
 
-            for(; aStart != aEnd; ++aStart)
-            {
-                if(!aStart->getPrevVector().equalZero())
-                    mnUsedVectors++;
+        // insert data
+        ControlVectorPair2DVector::iterator aIndex(maVector.begin());
+        aIndex += nIndex;
+        ControlVectorPair2DVector::const_iterator aStart(rSource.maVector.begin());
+        ControlVectorPair2DVector::const_iterator aEnd(rSource.maVector.end());
+        maVector.insert(aIndex, aStart, aEnd);
 
-                if(!aStart->getNextVector().equalZero())
-                    mnUsedVectors++;
-            }
+        for(; aStart != aEnd; ++aStart)
+        {
+            if(!aStart->getPrevVector().equalZero())
+                mnUsedVectors++;
+
+            if(!aStart->getNextVector().equalZero())
+                mnUsedVectors++;
         }
     }
 
     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
     {
-        if(nCount)
-        {
-            const ControlVectorPair2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
-            const ControlVectorPair2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
-            ControlVectorPair2DVector::const_iterator aStart(aDeleteStart);
+        if(!nCount)
+            return;
 
-            for(; mnUsedVectors && aStart != aDeleteEnd; ++aStart)
-            {
-                if(!aStart->getPrevVector().equalZero())
-                    mnUsedVectors--;
+        const ControlVectorPair2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
+        const ControlVectorPair2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
+        ControlVectorPair2DVector::const_iterator aStart(aDeleteStart);
 
-                if(mnUsedVectors && !aStart->getNextVector().equalZero())
-                    mnUsedVectors--;
-            }
+        for(; mnUsedVectors && aStart != aDeleteEnd; ++aStart)
+        {
+            if(!aStart->getPrevVector().equalZero())
+                mnUsedVectors--;
 
-            // remove point data
-            maVector.erase(aDeleteStart, aDeleteEnd);
+            if(mnUsedVectors && !aStart->getNextVector().equalZero())
+                mnUsedVectors--;
         }
+
+        // remove point data
+        maVector.erase(aDeleteStart, aDeleteEnd);
     }
 
     void flip(bool bIsClosed)
     {
-        if(maVector.size() > 1)
-        {
-            // to keep the same point at index 0, just flip all points except the
-            // first one when closed
-            const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
-            ControlVectorPair2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
-            ControlVectorPair2DVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                // swap Prev and Next
-                aStart->flip();
-                aEnd->flip();
+        // to keep the same point at index 0, just flip all points except the
+        // first one when closed
+        const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
+        ControlVectorPair2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
+        ControlVectorPair2DVector::iterator aEnd(maVector.end() - 1);
 
-                // swap entries
-                std::swap(*aStart, *aEnd);
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            // swap Prev and Next
+            aStart->flip();
+            aEnd->flip();
 
-                ++aStart;
-                --aEnd;
-            }
+            // swap entries
+            std::swap(*aStart, *aEnd);
 
-            if(aStart == aEnd)
-            {
-                // swap Prev and Next at middle element (if exists)
-                aStart->flip();
-            }
+            ++aStart;
+            --aEnd;
+        }
 
-            if(bIsClosed)
-            {
-                // swap Prev and Next at start element
-                maVector.begin()->flip();
-            }
+        if(aStart == aEnd)
+        {
+            // swap Prev and Next at middle element (if exists)
+            aStart->flip();
+        }
+
+        if(bIsClosed)
+        {
+            // swap Prev and Next at start element
+            maVector.begin()->flip();
         }
     }
 };
@@ -858,63 +858,63 @@ public:
     {
         const sal_uInt32 nCount(rSource.maPoints.count());
 
-        if(nCount)
-        {
-            mpBufferedData.reset();
+        if(!nCount)
+            return;
 
-            if(rSource.mpControlVector && rSource.mpControlVector->isUsed() && !mpControlVector)
-            {
-                mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
-            }
+        mpBufferedData.reset();
 
-            maPoints.insert(nIndex, rSource.maPoints);
+        if(rSource.mpControlVector && rSource.mpControlVector->isUsed() && !mpControlVector)
+        {
+            mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
+        }
 
-            if(rSource.mpControlVector)
-            {
-                mpControlVector->insert(nIndex, *rSource.mpControlVector);
+        maPoints.insert(nIndex, rSource.maPoints);
 
-                if(!mpControlVector->isUsed())
-                    mpControlVector.reset();
-            }
-            else if(mpControlVector)
-            {
-                ControlVectorPair2D aVectorPair;
-                mpControlVector->insert(nIndex, aVectorPair, nCount);
-            }
+        if(rSource.mpControlVector)
+        {
+            mpControlVector->insert(nIndex, *rSource.mpControlVector);
+
+            if(!mpControlVector->isUsed())
+                mpControlVector.reset();
+        }
+        else if(mpControlVector)
+        {
+            ControlVectorPair2D aVectorPair;
+            mpControlVector->insert(nIndex, aVectorPair, nCount);
         }
     }
 
     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
     {
-        if(nCount)
-        {
-            mpBufferedData.reset();
-            maPoints.remove(nIndex, nCount);
+        if(!nCount)
+            return;
 
-            if(mpControlVector)
-            {
-                mpControlVector->remove(nIndex, nCount);
+        mpBufferedData.reset();
+        maPoints.remove(nIndex, nCount);
 
-                if(!mpControlVector->isUsed())
-                    mpControlVector.reset();
-            }
+        if(mpControlVector)
+        {
+            mpControlVector->remove(nIndex, nCount);
+
+            if(!mpControlVector->isUsed())
+                mpControlVector.reset();
         }
     }
 
     void flip()
     {
-        if(maPoints.count() > 1)
-        {
-            mpBufferedData.reset();
+        if(maPoints.count() <= 1)
+            return;
 
-            // flip points
-            maPoints.flip(mbIsClosed);
+        mpBufferedData.reset();
 
-            if(mpControlVector)
-            {
-                // flip control vector
-                mpControlVector->flip(mbIsClosed);
-            }
+        // flip points
+        maPoints.flip(mbIsClosed);
+
+        if(mpControlVector)
+        {
+            // flip control vector
+            mpControlVector->flip(mbIsClosed);
         }
     }
 
@@ -966,56 +966,56 @@ public:
     void removeDoublePointsAtBeginEnd()
     {
         // Only remove DoublePoints at Begin and End when poly is closed
-        if(mbIsClosed)
+        if(!mbIsClosed)
+            return;
+
+        mpBufferedData.reset();
+
+        if(mpControlVector)
         {
-            mpBufferedData.reset();
+            bool bRemove;
 
-            if(mpControlVector)
+            do
             {
-                bool bRemove;
+                bRemove = false;
 
-                do
+                if(maPoints.count() > 1)
                 {
-                    bRemove = false;
+                    const sal_uInt32 nIndex(maPoints.count() - 1);
 
-                    if(maPoints.count() > 1)
+                    if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
                     {
-                        const sal_uInt32 nIndex(maPoints.count() - 1);
-
-                        if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
+                        if(mpControlVector)
                         {
-                            if(mpControlVector)
-                            {
-                                if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
-                                {
-                                    bRemove = true;
-                                }
-                            }
-                            else
+                            if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
                             {
                                 bRemove = true;
                             }
                         }
-                    }
-
-                    if(bRemove)
-                    {
-                        const sal_uInt32 nIndex(maPoints.count() - 1);
-
-                        if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
+                        else
                         {
-                            mpControlVector->setPrevVector(0, mpControlVector->getPrevVector(nIndex));
+                            bRemove = true;
                         }
+                    }
+                }
 
-                        remove(nIndex, 1);
+                if(bRemove)
+                {
+                    const sal_uInt32 nIndex(maPoints.count() - 1);
+
+                    if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
+                    {
+                        mpControlVector->setPrevVector(0, mpControlVector->getPrevVector(nIndex));
                     }
+
+                    remove(nIndex, 1);
                 }
-                while(bRemove);
-            }
-            else
-            {
-                maPoints.removeDoublePointsAtBeginEnd();
             }
+            while(bRemove);
+        }
+        else
+        {
+            maPoints.removeDoublePointsAtBeginEnd();
         }
     }
 
@@ -1438,23 +1438,23 @@ namespace basegfx
 
     void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
     {
-        if(rPoly.count())
+        if(!rPoly.count())
+            return;
+
+        if(!nCount)
         {
-            if(!nCount)
-            {
-                nCount = rPoly.count();
-            }
+            nCount = rPoly.count();
+        }
 
-            if(nIndex == 0 && nCount == rPoly.count())
-            {
-                mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
-            }
-            else
-            {
-                OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
-                ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
-                mpPolygon->insert(mpPolygon->count(), aTempPoly);
-            }
+        if(nIndex == 0 && nCount == rPoly.count())
+        {
+            mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
+        }
+        else
+        {
+            OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
+            ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
+            mpPolygon->insert(mpPolygon->count(), aTempPoly);
         }
     }
 
diff --git a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
index d96a38ac7f30..a8ae6372d5ea 100644
--- a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
+++ b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
@@ -214,48 +214,48 @@ namespace basegfx
             temporaryPointVector& rTempPointsA, temporaryPointVector& rTempPointsB)
         {
             // no null length edges
-            if(!(rCurrA.equal(rNextA) || rCurrB.equal(rNextB)))
-            {
-                // no common start/end points, this can be no cuts
-                if(!(rCurrB.equal(rCurrA) || rCurrB.equal(rNextA) || rNextB.equal(rCurrA) || rNextB.equal(rNextA)))
-                {
-                    const B2DVector aVecA(rNextA - rCurrA);
-                    const B2DVector aVecB(rNextB - rCurrB);
-                    double fCut(aVecA.cross(aVecB));
+            if(rCurrA.equal(rNextA) || rCurrB.equal(rNextB))
+                return;
 
-                    if(!fTools::equalZero(fCut))
-                    {
-                        const double fZero(0.0);
-                        const double fOne(1.0);
-                        fCut = (aVecB.getY() * (rCurrB.getX() - rCurrA.getX()) + aVecB.getX() * (rCurrA.getY() - rCurrB.getY())) / fCut;
+            // no common start/end points, this can be no cuts
+            if(rCurrB.equal(rCurrA) || rCurrB.equal(rNextA) || rNextB.equal(rCurrA) || rNextB.equal(rNextA))
+                return;
 
-                        if (fTools::betweenOrEqualEither(fCut, fZero, fOne))
-                        {
-                            // it's a candidate, but also need to test parameter value of cut on line 2
-                            double fCut2;
+            const B2DVector aVecA(rNextA - rCurrA);
+            const B2DVector aVecB(rNextB - rCurrB);
+            double fCut(aVecA.cross(aVecB));
 
-                            // choose the more precise version
-                            if(fabs(aVecB.getX()) > fabs(aVecB.getY()))
-                            {
-                                fCut2 = (rCurrA.getX() + (fCut * aVecA.getX()) - rCurrB.getX()) / aVecB.getX();
-                            }
-                            else
-                            {
-                                fCut2 = (rCurrA.getY() + (fCut * aVecA.getY()) - rCurrB.getY()) / aVecB.getY();
-                            }
+            if(fTools::equalZero(fCut))
+                return;
 
-                            if (fTools::betweenOrEqualEither(fCut2, fZero, fOne))
-                            {
-                                // cut is in range, add point. Two edges can have only one cut, but
-                                // add a cut point to each list. The lists may be the same for
-                                // self intersections.
-                                const B2DPoint aCutPoint(interpolate(rCurrA, rNextA, fCut));
-                                rTempPointsA.emplace_back(aCutPoint, nIndA, fCut);
-                                rTempPointsB.emplace_back(aCutPoint, nIndB, fCut2);
-                            }
-                        }
-                    }
-                }
+            const double fZero(0.0);
+            const double fOne(1.0);
+            fCut = (aVecB.getY() * (rCurrB.getX() - rCurrA.getX()) + aVecB.getX() * (rCurrA.getY() - rCurrB.getY())) / fCut;
+
+            if (!fTools::betweenOrEqualEither(fCut, fZero, fOne))
+                return;
+
+            // it's a candidate, but also need to test parameter value of cut on line 2
+            double fCut2;
+
+            // choose the more precise version
+            if(fabs(aVecB.getX()) > fabs(aVecB.getY()))
+            {
+                fCut2 = (rCurrA.getX() + (fCut * aVecA.getX()) - rCurrB.getX()) / aVecB.getX();
+            }
+            else
+            {
+                fCut2 = (rCurrA.getY() + (fCut * aVecA.getY()) - rCurrB.getY()) / aVecB.getY();
+            }
+
+            if (fTools::betweenOrEqualEither(fCut2, fZero, fOne))
+            {
+                // cut is in range, add point. Two edges can have only one cut, but
+                // add a cut point to each list. The lists may be the same for
+                // self intersections.
+                const B2DPoint aCutPoint(interpolate(rCurrA, rNextA, fCut));
+                rTempPointsA.emplace_back(aCutPoint, nIndA, fCut);
+                rTempPointsB.emplace_back(aCutPoint, nIndB, fCut2);
             }
         }
 
@@ -278,104 +278,104 @@ namespace basegfx
             const sal_uInt32 nPointCountA(rCandidateA.count());
             const sal_uInt32 nPointCountB(rCandidateB.count());
 
-            if(nPointCountA > 1 && nPointCountB > 1)
+            if(!(nPointCountA > 1 && nPointCountB > 1))
+                return;
+
+            const sal_uInt32 nEdgeCountA(nPointCountA - 1);
+            const sal_uInt32 nEdgeCountB(nPointCountB - 1);
+            B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
+
+            for(sal_uInt32 a(0); a < nEdgeCountA; a++)
             {
-                const sal_uInt32 nEdgeCountA(nPointCountA - 1);
-                const sal_uInt32 nEdgeCountB(nPointCountB - 1);
-                B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
+                const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1));
+                const B2DRange aRangeA(aCurrA, aNextA);
+                B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
 
-                for(sal_uInt32 a(0); a < nEdgeCountA; a++)
+                for(sal_uInt32 b(0); b < nEdgeCountB; b++)
                 {
-                    const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1));
-                    const B2DRange aRangeA(aCurrA, aNextA);
-                    B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
+                    const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1));
+                    const B2DRange aRangeB(aCurrB, aNextB);
 
-                    for(sal_uInt32 b(0); b < nEdgeCountB; b++)
+                    if(aRangeA.overlaps(aRangeB))
                     {
-                        const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1));
-                        const B2DRange aRangeB(aCurrB, aNextB);
-
-                        if(aRangeA.overlaps(aRangeB))
+                        // no null length edges
+                        if(!(aCurrA.equal(aNextA) || aCurrB.equal(aNextB)))
                         {
-                            // no null length edges
-                            if(!(aCurrA.equal(aNextA) || aCurrB.equal(aNextB)))
+                            const B2DVector aVecA(aNextA - aCurrA);
+                            const B2DVector aVecB(aNextB - aCurrB);
+                            double fCutA(aVecA.cross(aVecB));
+
+                            if(!fTools::equalZero(fCutA))
                             {
-                                const B2DVector aVecA(aNextA - aCurrA);
-                                const B2DVector aVecB(aNextB - aCurrB);
-                                double fCutA(aVecA.cross(aVecB));
+                                const double fZero(0.0);
+                                const double fOne(1.0);
+                                fCutA = (aVecB.getY() * (aCurrB.getX() - aCurrA.getX()) + aVecB.getX() * (aCurrA.getY() - aCurrB.getY())) / fCutA;
 
-                                if(!fTools::equalZero(fCutA))
+                                // use range [0.0 .. 1.0[, thus in the loop, all direct aCurrA cuts will be registered
+                                // as 0.0 cut. The 1.0 cut will be registered in the next loop step
+                                if(fTools::moreOrEqual(fCutA, fZero) && fTools::less(fCutA, fOne))
                                 {
-                                    const double fZero(0.0);
-                                    const double fOne(1.0);
-                                    fCutA = (aVecB.getY() * (aCurrB.getX() - aCurrA.getX()) + aVecB.getX() * (aCurrA.getY() - aCurrB.getY())) / fCutA;
+                                    // it's a candidate, but also need to test parameter value of cut on line 2
+                                    double fCutB;
+
+                                    // choose the more precise version
+                                    if(fabs(aVecB.getX()) > fabs(aVecB.getY()))
+                                    {
+                                        fCutB = (aCurrA.getX() + (fCutA * aVecA.getX()) - aCurrB.getX()) / aVecB.getX();
+                                    }
+                                    else
+                                    {
+                                        fCutB = (aCurrA.getY() + (fCutA * aVecA.getY()) - aCurrB.getY()) / aVecB.getY();
+                                    }
 
                                     // use range [0.0 .. 1.0[, thus in the loop, all direct aCurrA cuts will be registered
                                     // as 0.0 cut. The 1.0 cut will be registered in the next loop step
-                                    if(fTools::moreOrEqual(fCutA, fZero) && fTools::less(fCutA, fOne))
+                                    if(fTools::moreOrEqual(fCutB, fZero) && fTools::less(fCutB, fOne))
                                     {
-                                        // it's a candidate, but also need to test parameter value of cut on line 2
-                                        double fCutB;
-
-                                        // choose the more precise version
-                                        if(fabs(aVecB.getX()) > fabs(aVecB.getY()))
+                                        // cut is in both ranges. Add points for A and B
+                                        // #i111715# use fTools::equal instead of fTools::equalZero for better accuracy
+                                        if(fTools::equal(fCutA, fZero))
                                         {
-                                            fCutB = (aCurrA.getX() + (fCutA * aVecA.getX()) - aCurrB.getX()) / aVecB.getX();
+                                            // ignore for start point in first edge; this is handled
+                                            // by outer methods and would just produce a double point
+                                            if(a)
+                                            {
+                                                rTempPointsA.emplace_back(aCurrA, a, 0.0);
+                                            }
                                         }
                                         else
                                         {
-                                            fCutB = (aCurrA.getY() + (fCutA * aVecA.getY()) - aCurrB.getY()) / aVecB.getY();
+                                            const B2DPoint aCutPoint(interpolate(aCurrA, aNextA, fCutA));
+                                            rTempPointsA.emplace_back(aCutPoint, a, fCutA);
                                         }
 
-                                        // use range [0.0 .. 1.0[, thus in the loop, all direct aCurrA cuts will be registered
-                                        // as 0.0 cut. The 1.0 cut will be registered in the next loop step
-                                        if(fTools::moreOrEqual(fCutB, fZero) && fTools::less(fCutB, fOne))
+                                        // #i111715# use fTools::equal instead of fTools::equalZero for better accuracy
+                                        if(fTools::equal(fCutB, fZero))
                                         {
-                                            // cut is in both ranges. Add points for A and B
-                                            // #i111715# use fTools::equal instead of fTools::equalZero for better accuracy
-                                            if(fTools::equal(fCutA, fZero))
-                                            {
-                                                // ignore for start point in first edge; this is handled
-                                                // by outer methods and would just produce a double point
-                                                if(a)
-                                                {
-                                                    rTempPointsA.emplace_back(aCurrA, a, 0.0);
-                                                }
-                                            }
-                                            else
-                                            {
-                                                const B2DPoint aCutPoint(interpolate(aCurrA, aNextA, fCutA));
-                                                rTempPointsA.emplace_back(aCutPoint, a, fCutA);
-                                            }
-
-                                            // #i111715# use fTools::equal instead of fTools::equalZero for better accuracy
-                                            if(fTools::equal(fCutB, fZero))
+                                            // ignore for start point in first edge; this is handled
+                                            // by outer methods and would just produce a double point
+                                            if(b)
                                             {
-                                                // ignore for start point in first edge; this is handled
-                                                // by outer methods and would just produce a double point
-                                                if(b)
-                                                {
-                                                    rTempPointsB.emplace_back(aCurrB, b, 0.0);
-                                                }
-                                            }
-                                            else
-                                            {
-                                                const B2DPoint aCutPoint(interpolate(aCurrB, aNextB, fCutB));
-                                                rTempPointsB.emplace_back(aCutPoint, b, fCutB);
+                                                rTempPointsB.emplace_back(aCurrB, b, 0.0);
                                             }
                                         }
+                                        else
+                                        {
+                                            const B2DPoint aCutPoint(interpolate(aCurrB, aNextB, fCutB));
+                                            rTempPointsB.emplace_back(aCutPoint, b, fCutB);
+                                        }
                                     }
                                 }
                             }
                         }
-
-                        // prepare next step
-                        aCurrB = aNextB;
                     }
 
                     // prepare next step
-                    aCurrA = aNextA;
+                    aCurrB = aNextB;
                 }
+
+                // prepare next step
+                aCurrA = aNextA;
             }
         }
 
@@ -493,107 +493,107 @@ namespace basegfx
             // entries to rTempPoints accordingly
             const sal_uInt32 nPointCount(rCandidate.count());
 
-            if(nPointCount)
+            if(!nPointCount)
+                return;
+
+            const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
+
+            if(!nEdgeCount)
+                return;
+
+            const bool bCurvesInvolved(rCandidate.areControlPointsUsed());
+
+            if(bCurvesInvolved)
             {
-                const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
+                B2DCubicBezier aCubicA;
+                B2DCubicBezier aCubicB;
 
-                if(nEdgeCount)
+                for(sal_uInt32 a(0); a < nEdgeCount - 1; a++)
                 {
-                    const bool bCurvesInvolved(rCandidate.areControlPointsUsed());
+                    rCandidate.getBezierSegment(a, aCubicA);
+                    aCubicA.testAndSolveTrivialBezier();
+                    const bool bEdgeAIsCurve(aCubicA.isBezier());
+                    const B2DRange aRangeA(aCubicA.getRange());
 
-                    if(bCurvesInvolved)
+                    if(bEdgeAIsCurve)
                     {
-                        B2DCubicBezier aCubicA;
-                        B2DCubicBezier aCubicB;
+                        // curved segments may have self-intersections, do not forget those (!)
+                        findEdgeCutsOneBezier(aCubicA, a, rTempPoints);
+                    }
 
-                        for(sal_uInt32 a(0); a < nEdgeCount - 1; a++)
+                    for(sal_uInt32 b(a + 1); b < nEdgeCount; b++)
+                    {
+                        rCandidate.getBezierSegment(b, aCubicB);
+                        aCubicB.testAndSolveTrivialBezier();
+                        const B2DRange aRangeB(aCubicB.getRange());
+
+                        // 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)
                         {
-                            rCandidate.getBezierSegment(a, aCubicA);
-                            aCubicA.testAndSolveTrivialBezier();
-                            const bool bEdgeAIsCurve(aCubicA.isBezier());
-                            const B2DRange aRangeA(aCubicA.getRange());
-
-                            if(bEdgeAIsCurve)
+                            const bool bEdgeBIsCurve(aCubicB.isBezier());
+                            if(bEdgeAIsCurve && bEdgeBIsCurve)
                             {
-                                // curved segments may have self-intersections, do not forget those (!)
-                                findEdgeCutsOneBezier(aCubicA, a, rTempPoints);
+                                // test for bezier-bezier cuts
+                                findEdgeCutsTwoBeziers(aCubicA, aCubicB, a, b, rTempPoints, rTempPoints);
                             }
-
-                            for(sal_uInt32 b(a + 1); b < nEdgeCount; b++)
+                            else if(bEdgeAIsCurve)
                             {
-                                rCandidate.getBezierSegment(b, aCubicB);
-                                aCubicB.testAndSolveTrivialBezier();
-                                const B2DRange aRangeB(aCubicB.getRange());
-
-                                // 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)
-                                {
-                                    const bool bEdgeBIsCurve(aCubicB.isBezier());
-                                    if(bEdgeAIsCurve && bEdgeBIsCurve)
-                                    {
-                                        // test for bezier-bezier cuts
-                                        findEdgeCutsTwoBeziers(aCubicA, aCubicB, a, b, rTempPoints, rTempPoints);
-                                    }
-                                    else if(bEdgeAIsCurve)
-                                    {
-                                        // test for bezier-edge cuts
-                                        findEdgeCutsBezierAndEdge(aCubicA, aCubicB.getStartPoint(), aCubicB.getEndPoint(), a, b, rTempPoints, rTempPoints);
-                                    }
-                                    else if(bEdgeBIsCurve)
-                                    {
-                                        // test for bezier-edge cuts
-                                        findEdgeCutsBezierAndEdge(aCubicB, aCubicA.getStartPoint(), aCubicA.getEndPoint(), b, a, rTempPoints, rTempPoints);
-                                    }
-                                    else
-                                    {
-                                        // test for simple edge-edge cuts
-                                        findEdgeCutsTwoEdges(aCubicA.getStartPoint(), aCubicA.getEndPoint(), aCubicB.getStartPoint(), aCubicB.getEndPoint(),
-                                            a, b, rTempPoints, rTempPoints);
-                                    }
-                                }
+                                // test for bezier-edge cuts
+                                findEdgeCutsBezierAndEdge(aCubicA, aCubicB.getStartPoint(), aCubicB.getEndPoint(), a, b, rTempPoints, rTempPoints);
+                            }
+                            else if(bEdgeBIsCurve)
+                            {
+                                // test for bezier-edge cuts
+                                findEdgeCutsBezierAndEdge(aCubicB, aCubicA.getStartPoint(), aCubicA.getEndPoint(), b, a, rTempPoints, rTempPoints);
+                            }
+                            else
+                            {
+                                // test for simple edge-edge cuts
+                                findEdgeCutsTwoEdges(aCubicA.getStartPoint(), aCubicA.getEndPoint(), aCubicB.getStartPoint(), aCubicB.getEndPoint(),
+                                    a, b, rTempPoints, rTempPoints);
                             }
                         }
                     }
-                    else
-                    {
-                        B2DPoint aCurrA(rCandidate.getB2DPoint(0));
-
-                        for(sal_uInt32 a(0); a < nEdgeCount - 1; a++)
-                        {
-                            const B2DPoint aNextA(rCandidate.getB2DPoint(a + 1 == nPointCount ? 0 : a + 1));
-                            const B2DRange aRangeA(aCurrA, aNextA);
-                            B2DPoint aCurrB(rCandidate.getB2DPoint(a + 1));
+                }
+            }
+            else
+            {
+                B2DPoint aCurrA(rCandidate.getB2DPoint(0));
 
-                            for(sal_uInt32 b(a + 1); b < nEdgeCount; b++)
-                            {
-                                const B2DPoint aNextB(rCandidate.getB2DPoint(b + 1 == nPointCount ? 0 : b + 1));
-                                const B2DRange aRangeB(aCurrB, aNextB);
-
-                                // 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);
-                                }
+                for(sal_uInt32 a(0); a < nEdgeCount - 1; a++)
+                {
+                    const B2DPoint aNextA(rCandidate.getB2DPoint(a + 1 == nPointCount ? 0 : a + 1));
+                    const B2DRange aRangeA(aCurrA, aNextA);
+                    B2DPoint aCurrB(rCandidate.getB2DPoint(a + 1));
 
-                                // prepare next step
-                                aCurrB = aNextB;
-                            }
+                    for(sal_uInt32 b(a + 1); b < nEdgeCount; b++)
+                    {
+                        const B2DPoint aNextB(rCandidate.getB2DPoint(b + 1 == nPointCount ? 0 : b + 1));
+                        const B2DRange aRangeB(aCurrB, aNextB);
 
-                            // prepare next step
-                            aCurrA = aNextA;
+                        // 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);
                         }
+
+                        // prepare next step
+                        aCurrB = aNextB;
                     }
+
+                    // prepare next step
+                    aCurrA = aNextA;
                 }
             }
         }
@@ -614,34 +614,34 @@ namespace basegfx
             // points there to represent touches (which may be enter or leave nodes later).
             const sal_uInt32 nPointCount(rPointPolygon.count());
 
-            if(nPointCount)
+            if(!nPointCount)
+                return;
+
+            const B2DRange aRange(rCurr, rNext);
+            const B2DVector aEdgeVector(rNext - rCurr);
+            bool bTestUsingX(fabs(aEdgeVector.getX()) > fabs(aEdgeVector.getY()));
+
+            for(sal_uInt32 a(0); a < nPointCount; a++)
             {
-                const B2DRange aRange(rCurr, rNext);
-                const B2DVector aEdgeVector(rNext - rCurr);
-                bool bTestUsingX(fabs(aEdgeVector.getX()) > fabs(aEdgeVector.getY()));
+                const B2DPoint aTestPoint(rPointPolygon.getB2DPoint(a));
 
-                for(sal_uInt32 a(0); a < nPointCount; a++)
+                if(aRange.isInside(aTestPoint))
                 {
-                    const B2DPoint aTestPoint(rPointPolygon.getB2DPoint(a));
-
-                    if(aRange.isInside(aTestPoint))
+                    if(!aTestPoint.equal(rCurr) && !aTestPoint.equal(rNext))
                     {
-                        if(!aTestPoint.equal(rCurr) && !aTestPoint.equal(rNext))
+                        const B2DVector aTestVector(aTestPoint - rCurr);
+
+                        if(areParallel(aEdgeVector, aTestVector))
                         {
-                            const B2DVector aTestVector(aTestPoint - rCurr);
+                            const double fCut(bTestUsingX
+                                ? aTestVector.getX() / aEdgeVector.getX()
+                                : aTestVector.getY() / aEdgeVector.getY());
+                            const double fZero(0.0);
+                            const double fOne(1.0);
 
-                            if(areParallel(aEdgeVector, aTestVector))
+                            if(fTools::more(fCut, fZero) && fTools::less(fCut, fOne))
                             {
-                                const double fCut(bTestUsingX
-                                    ? aTestVector.getX() / aEdgeVector.getX()
-                                    : aTestVector.getY() / aEdgeVector.getY());
-                                const double fZero(0.0);
-                                const double fOne(1.0);
-
-                                if(fTools::more(fCut, fZero) && fTools::less(fCut, fOne))
-                                {
-                                    rTempPoints.emplace_back(aTestPoint, nInd, fCut);
-                                }
+                                rTempPoints.emplace_back(aTestPoint, nInd, fCut);
                             }
                         }
                     }
@@ -680,43 +680,43 @@ namespace basegfx
             const sal_uInt32 nPointCount(rPointPolygon.count());
             const sal_uInt32 nEdgePointCount(rEdgePolygon.count());
 
-            if(nPointCount && nEdgePointCount)
+            if(!(nPointCount && nEdgePointCount))
+                return;
+
+            const sal_uInt32 nEdgeCount(rEdgePolygon.isClosed() ? nEdgePointCount : nEdgePointCount - 1);
+            B2DPoint aCurr(rEdgePolygon.getB2DPoint(0));
+
+            for(sal_uInt32 a(0); a < nEdgeCount; a++)
             {
-                const sal_uInt32 nEdgeCount(rEdgePolygon.isClosed() ? nEdgePointCount : nEdgePointCount - 1);
-                B2DPoint aCurr(rEdgePolygon.getB2DPoint(0));
+                const sal_uInt32 nNextIndex((a + 1) % nEdgePointCount);
+                const B2DPoint aNext(rEdgePolygon.getB2DPoint(nNextIndex));
 
-                for(sal_uInt32 a(0); a < nEdgeCount; a++)
+                if(!aCurr.equal(aNext))
                 {
-                    const sal_uInt32 nNextIndex((a + 1) % nEdgePointCount);
-                    const B2DPoint aNext(rEdgePolygon.getB2DPoint(nNextIndex));
+                    bool bHandleAsSimpleEdge(true);
 
-                    if(!aCurr.equal(aNext))
+                    if(rEdgePolygon.areControlPointsUsed())
                     {
-                        bool bHandleAsSimpleEdge(true);
-
-                        if(rEdgePolygon.areControlPointsUsed())
-                        {
-                            const B2DPoint aNextControlPoint(rEdgePolygon.getNextControlPoint(a));
-                            const B2DPoint aPrevControlPoint(rEdgePolygon.getPrevControlPoint(nNextIndex));
-                            const bool bEdgeIsCurve(!aNextControlPoint.equal(aCurr) || !aPrevControlPoint.equal(aNext));
-
-                            if(bEdgeIsCurve)
-                            {
-                                bHandleAsSimpleEdge = false;
-                                const B2DCubicBezier aCubicA(aCurr, aNextControlPoint, aPrevControlPoint, aNext);
-                                findTouchesOnCurve(aCubicA, rPointPolygon, a, rTempPoints);
-                            }
-                        }
+                        const B2DPoint aNextControlPoint(rEdgePolygon.getNextControlPoint(a));
+                        const B2DPoint aPrevControlPoint(rEdgePolygon.getPrevControlPoint(nNextIndex));
+                        const bool bEdgeIsCurve(!aNextControlPoint.equal(aCurr) || !aPrevControlPoint.equal(aNext));
 
-                        if(bHandleAsSimpleEdge)
+                        if(bEdgeIsCurve)
                         {
-                            findTouchesOnEdge(aCurr, aNext, rPointPolygon, a, rTempPoints);
+                            bHandleAsSimpleEdge = false;
+                            const B2DCubicBezier aCubicA(aCurr, aNextControlPoint, aPrevControlPoint, aNext);
+                            findTouchesOnCurve(aCubicA, rPointPolygon, a, rTempPoints);
                         }
                     }
 
-                    // next step
-                    aCurr = aNext;
+                    if(bHandleAsSimpleEdge)
+                    {
+                        findTouchesOnEdge(aCurr, aNext, rPointPolygon, a, rTempPoints);
+                    }
                 }
+
+                // next step
+                aCurr = aNext;
             }
         }
 
@@ -735,102 +735,102 @@ namespace basegfx
             const sal_uInt32 nPointCountA(rCandidateA.count());
             const sal_uInt32 nPointCountB(rCandidateB.count());
 
-            if(nPointCountA && nPointCountB)
+            if(!(nPointCountA && nPointCountB))
+                return;
+
+            const sal_uInt32 nEdgeCountA(rCandidateA.isClosed() ? nPointCountA : nPointCountA - 1);
+            const sal_uInt32 nEdgeCountB(rCandidateB.isClosed() ? nPointCountB : nPointCountB - 1);
+
+            if(!(nEdgeCountA && nEdgeCountB))
+                return;
+
+            const bool bCurvesInvolved(rCandidateA.areControlPointsUsed() || rCandidateB.areControlPointsUsed());
+
+            if(bCurvesInvolved)
             {
-                const sal_uInt32 nEdgeCountA(rCandidateA.isClosed() ? nPointCountA : nPointCountA - 1);
-                const sal_uInt32 nEdgeCountB(rCandidateB.isClosed() ? nPointCountB : nPointCountB - 1);
+                B2DCubicBezier aCubicA;
+                B2DCubicBezier aCubicB;
 
-                if(nEdgeCountA && nEdgeCountB)
+                for(sal_uInt32 a(0); a < nEdgeCountA; a++)
                 {
-                    const bool bCurvesInvolved(rCandidateA.areControlPointsUsed() || rCandidateB.areControlPointsUsed());
+                    rCandidateA.getBezierSegment(a, aCubicA);
+                    aCubicA.testAndSolveTrivialBezier();
+                    const bool bEdgeAIsCurve(aCubicA.isBezier());
+                    const B2DRange aRangeA(aCubicA.getRange());
 
-                    if(bCurvesInvolved)
+                    for(sal_uInt32 b(0); b < nEdgeCountB; b++)
                     {
-                        B2DCubicBezier aCubicA;
-                        B2DCubicBezier aCubicB;
-
-                        for(sal_uInt32 a(0); a < nEdgeCountA; a++)
+                        rCandidateB.getBezierSegment(b, aCubicB);
+                        aCubicB.testAndSolveTrivialBezier();
+                        const B2DRange aRangeB(aCubicB.getRange());
+
+                        // consecutive segments touch of course
+                        bool bOverlap = false;
+                        if( b > a+1)
+                            bOverlap = aRangeA.overlaps(aRangeB);
+                        else
+                            bOverlap = aRangeA.overlapsMore(aRangeB);
+                        if( bOverlap)
                         {
-                            rCandidateA.getBezierSegment(a, aCubicA);
-                            aCubicA.testAndSolveTrivialBezier();
-                            const bool bEdgeAIsCurve(aCubicA.isBezier());
-                            const B2DRange aRangeA(aCubicA.getRange());
-
-                            for(sal_uInt32 b(0); b < nEdgeCountB; b++)
+                            const bool bEdgeBIsCurve(aCubicB.isBezier());
+                            if(bEdgeAIsCurve && bEdgeBIsCurve)
                             {
-                                rCandidateB.getBezierSegment(b, aCubicB);
-                                aCubicB.testAndSolveTrivialBezier();
-                                const B2DRange aRangeB(aCubicB.getRange());
-
-                                // consecutive segments touch of course
-                                bool bOverlap = false;
-                                if( b > a+1)
-                                    bOverlap = aRangeA.overlaps(aRangeB);
-                                else
-                                    bOverlap = aRangeA.overlapsMore(aRangeB);
-                                if( bOverlap)
-                                {
-                                    const bool bEdgeBIsCurve(aCubicB.isBezier());
-                                    if(bEdgeAIsCurve && bEdgeBIsCurve)
-                                    {
-                                        // test for bezier-bezier cuts
-                                        findEdgeCutsTwoBeziers(aCubicA, aCubicB, a, b, rTempPointsA, rTempPointsB);
-                                    }
-                                    else if(bEdgeAIsCurve)
-                                    {
-                                        // test for bezier-edge cuts
-                                        findEdgeCutsBezierAndEdge(aCubicA, aCubicB.getStartPoint(), aCubicB.getEndPoint(), a, b, rTempPointsA, rTempPointsB);
-                                    }
-                                    else if(bEdgeBIsCurve)
-                                    {
-                                        // test for bezier-edge cuts
-                                        findEdgeCutsBezierAndEdge(aCubicB, aCubicA.getStartPoint(), aCubicA.getEndPoint(), b, a, rTempPointsB, rTempPointsA);
-                                    }
-                                    else
-                                    {
-                                        // test for simple edge-edge cuts
-                                        findEdgeCutsTwoEdges(aCubicA.getStartPoint(), aCubicA.getEndPoint(), aCubicB.getStartPoint(), aCubicB.getEndPoint(),
-                                            a, b, rTempPointsA, rTempPointsB);
-                                    }
-                                }
+                                // test for bezier-bezier cuts
+                                findEdgeCutsTwoBeziers(aCubicA, aCubicB, a, b, rTempPointsA, rTempPointsB);
+                            }
+                            else if(bEdgeAIsCurve)
+                            {
+                                // test for bezier-edge cuts
+                                findEdgeCutsBezierAndEdge(aCubicA, aCubicB.getStartPoint(), aCubicB.getEndPoint(), a, b, rTempPointsA, rTempPointsB);
+                            }
+                            else if(bEdgeBIsCurve)
+                            {
+                                // test for bezier-edge cuts
+                                findEdgeCutsBezierAndEdge(aCubicB, aCubicA.getStartPoint(), aCubicA.getEndPoint(), b, a, rTempPointsB, rTempPointsA);
+                            }
+                            else
+                            {
+                                // test for simple edge-edge cuts
+                                findEdgeCutsTwoEdges(aCubicA.getStartPoint(), aCubicA.getEndPoint(), aCubicB.getStartPoint(), aCubicB.getEndPoint(),
+                                    a, b, rTempPointsA, rTempPointsB);
                             }
                         }
                     }
-                    else
-                    {
-                        B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
-
-                        for(sal_uInt32 a(0); a < nEdgeCountA; a++)
-                        {
-                            const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1 == nPointCountA ? 0 : a + 1));
-                            const B2DRange aRangeA(aCurrA, aNextA);
-                            B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
+                }
+            }
+            else
+            {
+                B2DPoint aCurrA(rCandidateA.getB2DPoint(0));
 
-                            for(sal_uInt32 b(0); b < nEdgeCountB; b++)
-                            {
-                                const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1 == nPointCountB ? 0 : b + 1));
-                                const B2DRange aRangeB(aCurrB, aNextB);
-
-                                // 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);
-                                }
+                for(sal_uInt32 a(0); a < nEdgeCountA; a++)
+                {
+                    const B2DPoint aNextA(rCandidateA.getB2DPoint(a + 1 == nPointCountA ? 0 : a + 1));
+                    const B2DRange aRangeA(aCurrA, aNextA);
+                    B2DPoint aCurrB(rCandidateB.getB2DPoint(0));
 
-                                // prepare next step
-                                aCurrB = aNextB;
-                            }
+                    for(sal_uInt32 b(0); b < nEdgeCountB; b++)
+                    {
+                        const B2DPoint aNextB(rCandidateB.getB2DPoint(b + 1 == nPointCountB ? 0 : b + 1));
+                        const B2DRange aRangeB(aCurrB, aNextB);
 
-                            // prepare next step
-                            aCurrA = aNextA;
+                        // 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);
                         }
+
+                        // prepare next step
+                        aCurrB = aNextB;
                     }
+
+                    // prepare next step
+                    aCurrA = aNextA;
                 }
             }
         }
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index 1a5297e967b1..19aa7ee634b0 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -43,39 +43,39 @@ namespace basegfx::utils
 {
         void openWithGeometryChange(B2DPolygon& rCandidate)
         {
-            if(rCandidate.isClosed())
+            if(!rCandidate.isClosed())
+                return;
+
+            if(rCandidate.count())
             {
-                if(rCandidate.count())
-                {
-                    rCandidate.append(rCandidate.getB2DPoint(0));
+                rCandidate.append(rCandidate.getB2DPoint(0));
 
-                    if(rCandidate.areControlPointsUsed() && rCandidate.isPrevControlPointUsed(0))
-                    {
-                        rCandidate.setPrevControlPoint(rCandidate.count() - 1, rCandidate.getPrevControlPoint(0));
-                        rCandidate.resetPrevControlPoint(0);
-                    }
+                if(rCandidate.areControlPointsUsed() && rCandidate.isPrevControlPointUsed(0))
+                {
+                    rCandidate.setPrevControlPoint(rCandidate.count() - 1, rCandidate.getPrevControlPoint(0));
+                    rCandidate.resetPrevControlPoint(0);
                 }
-
-                rCandidate.setClosed(false);
             }
+
+            rCandidate.setClosed(false);
         }
 
         void closeWithGeometryChange(B2DPolygon& rCandidate)
         {
-            if(!rCandidate.isClosed())
+            if(rCandidate.isClosed())
+                return;
+
+            while(rCandidate.count() > 1 && rCandidate.getB2DPoint(0) == rCandidate.getB2DPoint(rCandidate.count() - 1))
             {
-                while(rCandidate.count() > 1 && rCandidate.getB2DPoint(0) == rCandidate.getB2DPoint(rCandidate.count() - 1))
+                if(rCandidate.areControlPointsUsed() && rCandidate.isPrevControlPointUsed(rCandidate.count() - 1))
                 {
-                    if(rCandidate.areControlPointsUsed() && rCandidate.isPrevControlPointUsed(rCandidate.count() - 1))
-                    {
-                        rCandidate.setPrevControlPoint(0, rCandidate.getPrevControlPoint(rCandidate.count() - 1));
-                    }
-
-                    rCandidate.remove(rCandidate.count() - 1);
+                    rCandidate.setPrevControlPoint(0, rCandidate.getPrevControlPoint(rCandidate.count() - 1));
                 }
 
-                rCandidate.setClosed(true);
+                rCandidate.remove(rCandidate.count() - 1);
             }
+
+            rCandidate.setClosed(true);
         }
 
         void checkClosed(B2DPolygon& rCandidate)
@@ -2178,22 +2178,22 @@ namespace basegfx::utils
         {
             const sal_uInt32 nCount(rCandidate.count());
 
-            if(nCount > 2)
-            {
-                const B2DPoint aStart(rCandidate.getB2DPoint(0));
-                B2DPoint aLast(rCandidate.getB2DPoint(1));
+            if(nCount <= 2)
+                return;
 
-                for(sal_uInt32 a(2); a < nCount; a++)
-                {
-                    const B2DPoint aCurrent(rCandidate.getB2DPoint(a));
-                    rTarget.emplace_back(
-                        aStart,
-                        aLast,
-                        aCurrent);
+            const B2DPoint aStart(rCandidate.getB2DPoint(0));
+            B2DPoint aLast(rCandidate.getB2DPoint(1));
 
-                    // prepare next
-                    aLast = aCurrent;
-                }
+            for(sal_uInt32 a(2); a < nCount; a++)
+            {
+                const B2DPoint aCurrent(rCandidate.getB2DPoint(a));
+                rTarget.emplace_back(
+                    aStart,
+                    aLast,
+                    aCurrent);
+
+                // prepare next
+                aLast = aCurrent;
             }
         }
 
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index 6263c78a1ef5..e5094c7dd30d 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -484,32 +484,32 @@ namespace basegfx
             {
                 const sal_uInt32 nOriginalCount(rOriginal.count());
 
-                if(nOriginalCount)
-                {
-                    B2DPolygon aGeometry(utils::addPointsAtCutsAndTouches(rOriginal));
-                    aGeometry.removeDoublePoints();
-                    aGeometry = utils::simplifyCurveSegments(aGeometry);
-                    mbIsCurve = aGeometry.areControlPointsUsed();
+                if(!nOriginalCount)
+                    return;
 
-                    const sal_uInt32 nPointCount(aGeometry.count());
+                B2DPolygon aGeometry(utils::addPointsAtCutsAndTouches(rOriginal));
+                aGeometry.removeDoublePoints();
+                aGeometry = utils::simplifyCurveSegments(aGeometry);
+                mbIsCurve = aGeometry.areControlPointsUsed();
 
-                    // If it's not a bezier polygon, at least four points are needed to create
-                    // a self-intersection. If it's a bezier polygon, the minimum point number
-                    // is two, since with a single point You get a curve, but no self-intersection
-                    if(nPointCount > 3 || (nPointCount > 1 && mbIsCurve))
-                    {
-                        // reserve space in point, control and sort vector.
-                        maSNV.reserve(nPointCount);
-                        maPNV.reserve(nPointCount);
-                        maVNV.reserve(mbIsCurve ? nPointCount : 0);
+                const sal_uInt32 nPointCount(aGeometry.count());
 
-                        // fill data
-                        impAddPolygon(0, aGeometry);
+                // If it's not a bezier polygon, at least four points are needed to create
+                // a self-intersection. If it's a bezier polygon, the minimum point number
+                // is two, since with a single point You get a curve, but no self-intersection
+                if(!(nPointCount > 3 || (nPointCount > 1 && mbIsCurve)))
+                    return;
 
-                        // solve common nodes
-                        impSolve();
-                    }
-                }
+                // reserve space in point, control and sort vector.
+                maSNV.reserve(nPointCount);
+                maPNV.reserve(nPointCount);
+                maVNV.reserve(mbIsCurve ? nPointCount : 0);
+
+                // fill data
+                impAddPolygon(0, aGeometry);
+
+                // solve common nodes
+                impSolve();
             }
 
             explicit solver(const B2DPolyPolygon& rOriginal)
@@ -519,65 +519,65 @@ namespace basegfx
             {
                 sal_uInt32 nOriginalCount(maOriginal.count());
 
-                if(nOriginalCount)
-                {
-                    B2DPolyPolygon aGeometry(utils::addPointsAtCutsAndTouches(maOriginal));
-                    aGeometry.removeDoublePoints();
-                    aGeometry = utils::simplifyCurveSegments(aGeometry);
-                    mbIsCurve = aGeometry.areControlPointsUsed();
-                    nOriginalCount = aGeometry.count();
+                if(!nOriginalCount)
+                    return;
 
-                    if(nOriginalCount)
-                    {
-                        sal_uInt32 nPointCount(0);
-                        sal_uInt32 a(0);
+                B2DPolyPolygon aGeometry(utils::addPointsAtCutsAndTouches(maOriginal));
+                aGeometry.removeDoublePoints();
+                aGeometry = utils::simplifyCurveSegments(aGeometry);
+                mbIsCurve = aGeometry.areControlPointsUsed();
+                nOriginalCount = aGeometry.count();
 
-                        // count points
-                        for(a = 0; a < nOriginalCount; a++)
-                        {
-                            const B2DPolygon& aCandidate(aGeometry.getB2DPolygon(a));
-                            const sal_uInt32 nCandCount(aCandidate.count());
-
-                            // If it's not a bezier curve, at least three points would be needed to have a
-                            // topological relevant (not empty) polygon. Since it's not known here if trivial
-                            // edges (dead ends) will be kept or sorted out, add non-bezier polygons with
-                            // more than one point.
-                            // For bezier curves, the minimum for defining an area is also one.
-                            if(nCandCount)
-                            {
-                                nPointCount += nCandCount;
-                            }
-                        }
+                if(!nOriginalCount)
+                    return;
 
-                        if(nPointCount)
-                        {
-                            // reserve space in point, control and sort vector.
-                            maSNV.reserve(nPointCount);
-                            maPNV.reserve(nPointCount);
-                            maVNV.reserve(mbIsCurve ? nPointCount : 0);
+                sal_uInt32 nPointCount(0);
+                sal_uInt32 a(0);
 
-                            // fill data
-                            sal_uInt32 nInsertIndex(0);
+                // count points
+                for(a = 0; a < nOriginalCount; a++)
+                {
+                    const B2DPolygon& aCandidate(aGeometry.getB2DPolygon(a));
+                    const sal_uInt32 nCandCount(aCandidate.count());
+
+                    // If it's not a bezier curve, at least three points would be needed to have a
+                    // topological relevant (not empty) polygon. Since it's not known here if trivial
+                    // edges (dead ends) will be kept or sorted out, add non-bezier polygons with
+                    // more than one point.
+                    // For bezier curves, the minimum for defining an area is also one.
+                    if(nCandCount)
+                    {
+                        nPointCount += nCandCount;
+                    }
+                }
 
-                            for(a = 0; a < nOriginalCount; a++)
-                            {
-                                const B2DPolygon& aCandidate(aGeometry.getB2DPolygon(a));
-                                const sal_uInt32 nCandCount(aCandidate.count());
+                if(!nPointCount)
+                    return;
 
-                                // use same condition as above, the data vector is
-                                // pre-allocated
-                                if(nCandCount)
-                                {
-                                    impAddPolygon(nInsertIndex, aCandidate);
-                                    nInsertIndex += nCandCount;
-                                }
-                            }
+                // reserve space in point, control and sort vector.
+                maSNV.reserve(nPointCount);
+                maPNV.reserve(nPointCount);
+                maVNV.reserve(mbIsCurve ? nPointCount : 0);
 
-                            // solve common nodes
-                            impSolve();
-                        }
+                // fill data
+                sal_uInt32 nInsertIndex(0);
+
+                for(a = 0; a < nOriginalCount; a++)
+                {
+                    const B2DPolygon& aCandidate(aGeometry.getB2DPolygon(a));
+                    const sal_uInt32 nCandCount(aCandidate.count());
+
+                    // use same condition as above, the data vector is
+                    // pre-allocated
+                    if(nCandCount)
+                    {
+                        impAddPolygon(nInsertIndex, aCandidate);
+                        nInsertIndex += nCandCount;
                     }
                 }
+
+                // solve common nodes
+                impSolve();
             }
 
             B2DPolyPolygon getB2DPolyPolygon()
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 75b6d38a19df..b763aef823c2 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -215,23 +215,23 @@ namespace basegfx::utils
                 fFullDashDotLen = std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
             }
 
-            if(rCandidate.count() && fFullDashDotLen > 0.0)
+            if(!(rCandidate.count() && fFullDashDotLen > 0.0))
+                return;
+
+            B2DPolyPolygon aLineTarget;
+
+            for(auto const& rPolygon : rCandidate)
             {
-                B2DPolyPolygon aLineTarget;
+                applyLineDashing(
+                    rPolygon,
+                    rDotDashArray,
+                    pLineTarget ? &aLineTarget : nullptr,
+                    nullptr,
+                    fFullDashDotLen);
 
-                for(auto const& rPolygon : rCandidate)
+                if(pLineTarget)
                 {
-                    applyLineDashing(
-                        rPolygon,
-                        rDotDashArray,
-                        pLineTarget ? &aLineTarget : nullptr,
-                        nullptr,
-                        fFullDashDotLen);
-
-                    if(pLineTarget)
-                    {
-                        pLineTarget->append(aLineTarget);
-                    }
+                    pLineTarget->append(aLineTarget);
                 }
             }
         }
diff --git a/basegfx/source/polygon/b2dtrapezoid.cxx b/basegfx/source/polygon/b2dtrapezoid.cxx
index 36c0c483a291..5648aa3be81c 100644
--- a/basegfx/source/polygon/b2dtrapezoid.cxx
+++ b/basegfx/source/polygon/b2dtrapezoid.cxx
@@ -422,61 +422,61 @@ namespace basegfx::trapezoidhelper
 
             void solveHorizontalEdges(TrDeSimpleEdges& rTrDeSimpleEdges)
             {
-                if(!rTrDeSimpleEdges.empty() && !maTrDeEdgeEntries.empty())
+                if(rTrDeSimpleEdges.empty() || maTrDeEdgeEntries.empty())
+                    return;
+
+                // there were horizontal edges. These can be excluded, but
+                // cuts with other edges need to be solved and added before
+                // ignoring them
+                for(const TrDeSimpleEdge & rHorEdge : rTrDeSimpleEdges)
                 {
-                    // there were horizontal edges. These can be excluded, but
-                    // cuts with other edges need to be solved and added before
-                    // ignoring them
-                    for(const TrDeSimpleEdge & rHorEdge : rTrDeSimpleEdges)
-                    {
-                        // get horizontal edge as candidate; prepare its range and fixed Y
-                        const B1DRange aRange(rHorEdge.getStart().getX(), rHorEdge.getEnd().getX());
-                        const double fFixedY(rHorEdge.getStart().getY());
+                    // get horizontal edge as candidate; prepare its range and fixed Y
+                    const B1DRange aRange(rHorEdge.getStart().getX(), rHorEdge.getEnd().getX());
+                    const double fFixedY(rHorEdge.getStart().getY());
+
+                    // loop over traversing edges
+                    TrDeEdgeEntries::iterator aCurrent(maTrDeEdgeEntries.begin());
 
-                        // loop over traversing edges
-                        TrDeEdgeEntries::iterator aCurrent(maTrDeEdgeEntries.begin());
+                    do
+                    {
+                        // get compare edge
+                        TrDeEdgeEntries::reference aCompare(*aCurrent++);
 
-                        do
+                        if(fTools::lessOrEqual(aCompare.getEnd().getY(), fFixedY))
                         {
-                            // get compare edge
-                            TrDeEdgeEntries::reference aCompare(*aCurrent++);
+                            // edge ends above horizontal edge, continue
+                            continue;
+                        }
 
-                            if(fTools::lessOrEqual(aCompare.getEnd().getY(), fFixedY))
-                            {
-                                // edge ends above horizontal edge, continue
-                                continue;
-                            }
+                        if(fTools::moreOrEqual(aCompare.getStart().getY(), fFixedY))
+                        {
+                            // edge starts below horizontal edge, continue
+                            continue;
+                        }
 
-                            if(fTools::moreOrEqual(aCompare.getStart().getY(), fFixedY))
-                            {
-                                // edge starts below horizontal edge, continue
-                                continue;
-                            }
+                        // vertical overlap, get horizontal range
+                        const B1DRange aCompareRange(aCompare.getStart().getX(), aCompare.getEnd().getX());
 
-                            // vertical overlap, get horizontal range
-                            const B1DRange aCompareRange(aCompare.getStart().getX(), aCompare.getEnd().getX());
+                        if(aRange.overlaps(aCompareRange))
+                        {
+                            // possible cut, get cut point
+                            const B2DPoint aSplit(aCompare.getCutPointForGivenY(fFixedY));
 
-                            if(aRange.overlaps(aCompareRange))
+                            if(fTools::more(aSplit.getX(), aRange.getMinimum())
+                                && fTools::less(aSplit.getX(), aRange.getMaximum()))
                             {
-                                // possible cut, get cut point
-                                const B2DPoint aSplit(aCompare.getCutPointForGivenY(fFixedY));
+                                // cut is in XRange of horizontal edge, potentially needed cut
+                                B2DPoint* pNewPoint = maNewPoints.allocatePoint(aSplit);
 
-                                if(fTools::more(aSplit.getX(), aRange.getMinimum())
-                                    && fTools::less(aSplit.getX(), aRange.getMaximum()))
+                                if(!splitEdgeAtGivenPoint(aCompare, *pNewPoint, aCurrent))
                                 {
-                                    // cut is in XRange of horizontal edge, potentially needed cut
-                                    B2DPoint* pNewPoint = maNewPoints.allocatePoint(aSplit);
-
-                                    if(!splitEdgeAtGivenPoint(aCompare, *pNewPoint, aCurrent))
-                                    {
-                                        maNewPoints.freeIfLast(pNewPoint);
-                                    }
+                                    maNewPoints.freeIfLast(pNewPoint);
                                 }
                             }
                         }
-                        while(aCurrent != maTrDeEdgeEntries.end()
-                            && fTools::less(aCurrent->getStart().getY(), fFixedY));
                     }
+                    while(aCurrent != maTrDeEdgeEntries.end()
+                        && fTools::less(aCurrent->getStart().getY(), fFixedY));
                 }
             }
 
diff --git a/basegfx/source/polygon/b3dpolygon.cxx b/basegfx/source/polygon/b3dpolygon.cxx
index 422353fba8ad..e3aa78d9bf3f 100644
--- a/basegfx/source/polygon/b3dpolygon.cxx
+++ b/basegfx/source/polygon/b3dpolygon.cxx
@@ -210,18 +210,18 @@ public:
 
     void flip()
     {
-        if(maVector.size() > 1)
-        {
-            const sal_uInt32 nHalfSize(maVector.size() >> 1);
-            CoordinateData3DVector::iterator aStart(maVector.begin());
-            CoordinateData3DVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                std::swap(*aStart, *aEnd);
-                ++aStart;
-                --aEnd;
-            }
+        const sal_uInt32 nHalfSize(maVector.size() >> 1);
+        CoordinateData3DVector::iterator aStart(maVector.begin());
+        CoordinateData3DVector::iterator aEnd(maVector.end() - 1);
+
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            std::swap(*aStart, *aEnd);
+            ++aStart;
+            --aEnd;
         }
     }
 
@@ -360,18 +360,18 @@ public:
 
     void flip()
     {
-        if(maVector.size() > 1)
-        {
-            const sal_uInt32 nHalfSize(maVector.size() >> 1);
-            BColorDataVector::iterator aStart(maVector.begin());
-            BColorDataVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                std::swap(*aStart, *aEnd);
-                ++aStart;
-                --aEnd;
-            }
+        const sal_uInt32 nHalfSize(maVector.size() >> 1);
+        BColorDataVector::iterator aStart(maVector.begin());
+        BColorDataVector::iterator aEnd(maVector.end() - 1);
+
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            std::swap(*aStart, *aEnd);
+            ++aStart;
+            --aEnd;
         }
     }
 };
@@ -501,18 +501,18 @@ public:
 
     void flip()
     {
-        if(maVector.size() > 1)
-        {
-            const sal_uInt32 nHalfSize(maVector.size() >> 1);
-            NormalsData3DVector::iterator aStart(maVector.begin());
-            NormalsData3DVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                std::swap(*aStart, *aEnd);
-                ++aStart;
-                --aEnd;
-            }
+        const sal_uInt32 nHalfSize(maVector.size() >> 1);
+        NormalsData3DVector::iterator aStart(maVector.begin());
+        NormalsData3DVector::iterator aEnd(maVector.end() - 1);
+
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            std::swap(*aStart, *aEnd);
+            ++aStart;
+            --aEnd;
         }
     }
 
@@ -650,18 +650,18 @@ public:
 
     void flip()
     {
-        if(maVector.size() > 1)
-        {
-            const sal_uInt32 nHalfSize(maVector.size() >> 1);
-            TextureData2DVector::iterator aStart(maVector.begin());
-            TextureData2DVector::iterator aEnd(maVector.end() - 1);
+        if(maVector.size() <= 1)
+            return;
 
-            for(sal_uInt32 a(0); a < nHalfSize; a++)
-            {
-                std::swap(*aStart, *aEnd);
-                ++aStart;
-                --aEnd;
-            }
+        const sal_uInt32 nHalfSize(maVector.size() >> 1);
+        TextureData2DVector::iterator aStart(maVector.begin());
+        TextureData2DVector::iterator aEnd(maVector.end() - 1);
+
+        for(sal_uInt32 a(0); a < nHalfSize; a++)
+        {
+            std::swap(*aStart, *aEnd);
+            ++aStart;
+            --aEnd;
         }
     }
 
@@ -922,26 +922,26 @@ public:
 
     void insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
     {
-        if(nCount)
-        {
-            CoordinateData3D aCoordinate(rPoint);
-            maPoints.insert(nIndex, aCoordinate, nCount);
-            invalidatePlaneNormal();
+        if(!nCount)
+            return;
 
-            if(mpBColors)
-            {
-                mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
-            }
+        CoordinateData3D aCoordinate(rPoint);
+        maPoints.insert(nIndex, aCoordinate, nCount);
+        invalidatePlaneNormal();
 
-            if(mpNormals)
-            {
-                mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
-            }
+        if(mpBColors)
+        {
+            mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
+        }
 
-            if(mpTextureCoordinates)
-            {
-                mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
-            }
+        if(mpNormals)
+        {
+            mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
+        }
+
+        if(mpTextureCoordinates)
+        {
+            mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
         }
     }
 
@@ -1105,129 +1105,129 @@ public:
     {
         const sal_uInt32 nCount(rSource.maPoints.count());
 
-        if(nCount)
-        {
-            maPoints.insert(nIndex, rSource.maPoints);
-            invalidatePlaneNormal();
+        if(!nCount)
+            return;
 
-            if(rSource.mpBColors && rSource.mpBColors->isUsed())
-            {
-                if(!mpBColors)
-                {
-                    mpBColors.reset( new BColorArray(maPoints.count()) );
-                }
+        maPoints.insert(nIndex, rSource.maPoints);
+        invalidatePlaneNormal();
 
-                mpBColors->insert(nIndex, *rSource.mpBColors);
-            }
-            else
+        if(rSource.mpBColors && rSource.mpBColors->isUsed())
+        {
+            if(!mpBColors)
             {
-                if(mpBColors)
-                {
-                    mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
-                }
+                mpBColors.reset( new BColorArray(maPoints.count()) );
             }
 
-            if(rSource.mpNormals && rSource.mpNormals->isUsed())
+            mpBColors->insert(nIndex, *rSource.mpBColors);
+        }
+        else
+        {
+            if(mpBColors)
             {
-                if(!mpNormals)
-                {
-                    mpNormals.reset( new NormalsArray3D(maPoints.count()) );
-                }
-
-                mpNormals->insert(nIndex, *rSource.mpNormals);
+                mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
             }
-            else
+        }
+
+        if(rSource.mpNormals && rSource.mpNormals->isUsed())
+        {
+            if(!mpNormals)
             {
-                if(mpNormals)
-                {
-                    mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
-                }
+                mpNormals.reset( new NormalsArray3D(maPoints.count()) );
             }
 
-            if(rSource.mpTextureCoordinates && rSource.mpTextureCoordinates->isUsed())
+            mpNormals->insert(nIndex, *rSource.mpNormals);
+        }
+        else
+        {
+            if(mpNormals)
             {
-                if(!mpTextureCoordinates)
-                {
-                    mpTextureCoordinates.reset( new TextureCoordinate2D(maPoints.count()) );
-                }
+                mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
+            }
+        }
 
-                mpTextureCoordinates->insert(nIndex, *rSource.mpTextureCoordinates);
+        if(rSource.mpTextureCoordinates && rSource.mpTextureCoordinates->isUsed())
+        {
+            if(!mpTextureCoordinates)
+            {
+                mpTextureCoordinates.reset( new TextureCoordinate2D(maPoints.count()) );
             }
-            else
+
+            mpTextureCoordinates->insert(nIndex, *rSource.mpTextureCoordinates);
+        }
+        else
+        {
+            if(mpTextureCoordinates)
             {
-                if(mpTextureCoordinates)
-                {
-                    mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
-                }
+                mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
             }
         }
     }
 
     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
     {
-        if(nCount)
+        if(!nCount)
+            return;
+
+        maPoints.remove(nIndex, nCount);
+        invalidatePlaneNormal();
+
+        if(mpBColors)
         {
-            maPoints.remove(nIndex, nCount);
-            invalidatePlaneNormal();
+            mpBColors->remove(nIndex, nCount);
 
-            if(mpBColors)
+            if(!mpBColors->isUsed())
             {
-                mpBColors->remove(nIndex, nCount);
-
-                if(!mpBColors->isUsed())
-                {
-                    mpBColors.reset();
-                }
+                mpBColors.reset();
             }
+        }
 
-            if(mpNormals)
-            {
-                mpNormals->remove(nIndex, nCount);
+        if(mpNormals)
+        {
+            mpNormals->remove(nIndex, nCount);
 
-                if(!mpNormals->isUsed())
-                {
-                    mpNormals.reset();
-                }
+            if(!mpNormals->isUsed())
+            {
+                mpNormals.reset();
             }
+        }
 
-            if(mpTextureCoordinates)
-            {
-                mpTextureCoordinates->remove(nIndex, nCount);
+        if(mpTextureCoordinates)
+        {
+            mpTextureCoordinates->remove(nIndex, nCount);
 
-                if(!mpTextureCoordinates->isUsed())
-                {
-                    mpTextureCoordinates.reset();
-                }
+            if(!mpTextureCoordinates->isUsed())
+            {
+                mpTextureCoordinates.reset();
             }
         }
     }
 
     void flip()
     {
-        if(maPoints.count() > 1)
-        {
-            maPoints.flip();
+        if(maPoints.count() <= 1)
+            return;
 
-            if(mbPlaneNormalValid)
-            {
-                // mirror plane normal
-                maPlaneNormal = -maPlaneNormal;
-            }
+        maPoints.flip();
 
-            if(mpBColors)
-            {
-                mpBColors->flip();
-            }
+        if(mbPlaneNormalValid)
+        {
+            // mirror plane normal
+            maPlaneNormal = -maPlaneNormal;
+        }
 
-            if(mpNormals)
-            {
-                mpNormals->flip();
-            }
+        if(mpBColors)
+        {
+            mpBColors->flip();
+        }
 
-            if(mpTextureCoordinates)
-            {
-                mpTextureCoordinates->flip();
-            }
+        if(mpNormals)
+        {
+            mpNormals->flip();
+        }
+
+        if(mpTextureCoordinates)
+        {
+            mpTextureCoordinates->flip();
         }
     }
 
@@ -1289,42 +1289,42 @@ public:
     void removeDoublePointsAtBeginEnd()
     {
         // Only remove DoublePoints at Begin and End when poly is closed
-        if(mbIsClosed)
+        if(!mbIsClosed)
+            return;
+
+        bool bRemove;
+
+        do
         {
-            bool bRemove;
+            bRemove = false;
 
-            do
+            if(maPoints.count() > 1)
             {
-                bRemove = false;
+                const sal_uInt32 nIndex(maPoints.count() - 1);
+                bRemove = (maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex));
 
-                if(maPoints.count() > 1)
+                if(bRemove && mpBColors && mpBColors->getBColor(0) != mpBColors->getBColor(nIndex))
                 {
-                    const sal_uInt32 nIndex(maPoints.count() - 1);
-                    bRemove = (maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex));
-
-                    if(bRemove && mpBColors && mpBColors->getBColor(0) != mpBColors->getBColor(nIndex))
-                    {
-                        bRemove = false;
-                    }
-
-                    if(bRemove && mpNormals && mpNormals->getNormal(0) != mpNormals->getNormal(nIndex))
-                    {
-                        bRemove = false;
-                    }
+                    bRemove = false;
+                }
 
-                    if(bRemove && mpTextureCoordinates && mpTextureCoordinates->getTextureCoordinate(0) != mpTextureCoordinates->getTextureCoordinate(nIndex))
-                    {
-                        bRemove = false;
-                    }
+                if(bRemove && mpNormals && mpNormals->getNormal(0) != mpNormals->getNormal(nIndex))
+                {
+                    bRemove = false;
                 }
 
-                if(bRemove)
+                if(bRemove && mpTextureCoordinates && mpTextureCoordinates->getTextureCoordinate(0) != mpTextureCoordinates->getTextureCoordinate(nIndex))
                 {
-                    const sal_uInt32 nIndex(maPoints.count() - 1);
-                    remove(nIndex, 1);
+                    bRemove = false;
                 }
-            } while(bRemove);
-        }
+            }
+
+            if(bRemove)
+            {
+                const sal_uInt32 nIndex(maPoints.count() - 1);
+                remove(nIndex, 1);
+            }
+        } while(bRemove);
     }
 
     void removeDoublePointsWholeTrack()
@@ -1542,23 +1542,23 @@ namespace basegfx
 
     void B3DPolygon::append(const B3DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
     {
-        if(rPoly.count())
+        if(!rPoly.count())
+            return;
+
+        if(!nCount)
         {
-            if(!nCount)
-            {
-                nCount = rPoly.count();
-            }
+            nCount = rPoly.count();
+        }
 
-            if(nIndex == 0 && nCount == rPoly.count())
-            {
-                mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
-            }
-            else
-            {
-                OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
-                ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
-                mpPolygon->insert(mpPolygon->count(), aTempPoly);
-            }
+        if(nIndex == 0 && nCount == rPoly.count())
+        {
+            mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
+        }
+        else
+        {
+            OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
+            ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
+            mpPolygon->insert(mpPolygon->count(), aTempPoly);
         }
     }
 
diff --git a/basegfx/source/range/b3drange.cxx b/basegfx/source/range/b3drange.cxx
index a8e5f359c3e3..89bb98a1e1a5 100644
--- a/basegfx/source/range/b3drange.cxx
+++ b/basegfx/source/range/b3drange.cxx
@@ -24,19 +24,19 @@ namespace basegfx
 {
     void B3DRange::transform(const B3DHomMatrix& rMatrix)
     {
-        if(!isEmpty() && !rMatrix.isIdentity())
-        {
-            const B3DRange aSource(*this);
-            reset();
-            expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMinY(), aSource.getMinZ()));
-            expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMinY(), aSource.getMinZ()));
-            expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMaxY(), aSource.getMinZ()));
-            expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMaxY(), aSource.getMinZ()));
-            expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMinY(), aSource.getMaxZ()));
-            expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMinY(), aSource.getMaxZ()));
-            expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMaxY(), aSource.getMaxZ()));
-            expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMaxY(), aSource.getMaxZ()));
-        }
+        if(isEmpty() || rMatrix.isIdentity())
+            return;
+
+        const B3DRange aSource(*this);
+        reset();
+        expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMinY(), aSource.getMinZ()));
+        expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMinY(), aSource.getMinZ()));
+        expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMaxY(), aSource.getMinZ()));
+        expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMaxY(), aSource.getMinZ()));
+        expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMinY(), aSource.getMaxZ()));
+        expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMinY(), aSource.getMaxZ()));
+        expand(rMatrix * B3DPoint(aSource.getMinX(), aSource.getMaxY(), aSource.getMaxZ()));
+        expand(rMatrix * B3DPoint(aSource.getMaxX(), aSource.getMaxY(), aSource.getMaxZ()));
     }
 
     B3DRange& B3DRange::operator*=( const ::basegfx::B3DHomMatrix& rMat )
diff --git a/basegfx/source/raster/rasterconvert3d.cxx b/basegfx/source/raster/rasterconvert3d.cxx
index 2e654831c5f3..48a5c7bb518f 100644
--- a/basegfx/source/raster/rasterconvert3d.cxx
+++ b/basegfx/source/raster/rasterconvert3d.cxx
@@ -57,96 +57,96 @@ namespace basegfx
 
     void RasterConverter3D::rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine)
     {
-        if(!maLineEntries.empty())
-        {
-            OSL_ENSURE(nStopLine >= nStartLine, "nStopLine is bigger than nStartLine (!)");
+        if(maLineEntries.empty())
+            return;
+
+        OSL_ENSURE(nStopLine >= nStartLine, "nStopLine is bigger than nStartLine (!)");
 
-            // sort global entries by Y, X once. After this, the vector
-            // is seen as frozen. Pointers to its entries will be used in the following code.
-            std::sort(maLineEntries.begin(), maLineEntries.end());
+        // sort global entries by Y, X once. After this, the vector
+        // is seen as frozen. Pointers to its entries will be used in the following code.
+        std::sort(maLineEntries.begin(), maLineEntries.end());
 
-            // local parameters
-            std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin());
-            std::vector< RasterConversionLineEntry3D* > aCurrentLine;
-            std::vector< RasterConversionLineEntry3D* > aNextLine;
-            std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D;
+        // local parameters
+        std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin());
+        std::vector< RasterConversionLineEntry3D* > aCurrentLine;
+        std::vector< RasterConversionLineEntry3D* > aNextLine;
+        std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D;
 
-            // get scanlines first LineNumber as start
-            sal_Int32 nLineNumber(std::max(aCurrentEntry->getY(), nStartLine));
+        // get scanlines first LineNumber as start
+        sal_Int32 nLineNumber(std::max(aCurrentEntry->getY(), nStartLine));
 
-            while((!aCurrentLine.empty() || aCurrentEntry != maLineEntries.end()) && (nLineNumber < nStopLine))
+        while((!aCurrentLine.empty() || aCurrentEntry != maLineEntries.end()) && (nLineNumber < nStopLine))
+        {
+            // add all entries which start at current line to current scanline
+            while(aCurrentEntry != maLineEntries.end())
             {
-                // add all entries which start at current line to current scanline
-                while(aCurrentEntry != maLineEntries.end())
+                const sal_Int32 nCurrentLineNumber(aCurrentEntry->getY());
+
+                if(nCurrentLineNumber > nLineNumber)
+                {
+                    // line is below current one, done (since array is sorted)
+                    break;
+                }
+                else
                 {
-                    const sal_Int32 nCurrentLineNumber(aCurrentEntry->getY());
+                    // less or equal. Line is above or at current one. Advance it exactly to
+                    // current line
+                    const sal_uInt32 nStep(nLineNumber - nCurrentLineNumber);
 
-                    if(nCurrentLineNumber > nLineNumber)
-                    {
-                        // line is below current one, done (since array is sorted)
-                        break;
-                    }
-                    else
+                    if(!nStep || aCurrentEntry->decrementRasterConversionLineEntry3D(nStep))
                     {
-                        // less or equal. Line is above or at current one. Advance it exactly to
-                        // current line
-                        const sal_uInt32 nStep(nLineNumber - nCurrentLineNumber);
-
-                        if(!nStep || aCurrentEntry->decrementRasterConversionLineEntry3D(nStep))
+                        // add when exactly on current line or when increment to it did not
+                        // completely consume it
+                        if(nStep)
                         {
-                            // add when exactly on current line or when increment to it did not
-                            // completely consume it
-                            if(nStep)
-                            {
-                                aCurrentEntry->incrementRasterConversionLineEntry3D(nStep, *this);
-                            }
-
-                            aCurrentLine.push_back(&(*aCurrentEntry));
+                            aCurrentEntry->incrementRasterConversionLineEntry3D(nStep, *this);
                         }
-                    }
 
-                    ++aCurrentEntry;
+                        aCurrentLine.push_back(&(*aCurrentEntry));
+                    }
                 }
 
-                // sort current scanline using comparator. Only X is used there
-                // since all entries are already in one processed line. This needs to be done
-                // every time since not only new spans may have benn added or old removed,
-                // but incrementing may also have changed the order
-                std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator());
+                ++aCurrentEntry;
+            }
 
-                // process current scanline
-                aRasterConversionLineEntry3D = aCurrentLine.begin();
-                aNextLine.clear();
-                sal_uInt32 nPairCount(0);
+            // sort current scanline using comparator. Only X is used there
+            // since all entries are already in one processed line. This needs to be done
+            // every time since not only new spans may have benn added or old removed,
+            // but incrementing may also have changed the order
+            std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator());
 
-                while(aRasterConversionLineEntry3D != aCurrentLine.end())
-                {
-                    RasterConversionLineEntry3D& rPrevScanRasterConversionLineEntry3D(**aRasterConversionLineEntry3D++);
+            // process current scanline
+            aRasterConversionLineEntry3D = aCurrentLine.begin();
+            aNextLine.clear();
+            sal_uInt32 nPairCount(0);
 
-                    // look for 2nd span
-                    if(aRasterConversionLineEntry3D != aCurrentLine.end())
-                    {
-                        // work on span from rPrevScanRasterConversionLineEntry3D to aRasterConversionLineEntry3D, fLineNumber is valid
-                        processLineSpan(rPrevScanRasterConversionLineEntry3D, **aRasterConversionLineEntry3D, nLineNumber, nPairCount++);
-                    }
+            while(aRasterConversionLineEntry3D != aCurrentLine.end())
+            {
+                RasterConversionLineEntry3D& rPrevScanRasterConversionLineEntry3D(**aRasterConversionLineEntry3D++);
 
-                    // increment to next line
-                    if(rPrevScanRasterConversionLineEntry3D.decrementRasterConversionLineEntry3D(1))
-                    {
-                        rPrevScanRasterConversionLineEntry3D.incrementRasterConversionLineEntry3D(1, *this);
-                        aNextLine.push_back(&rPrevScanRasterConversionLineEntry3D);
-                    }
+                // look for 2nd span
+                if(aRasterConversionLineEntry3D != aCurrentLine.end())
+                {
+                    // work on span from rPrevScanRasterConversionLineEntry3D to aRasterConversionLineEntry3D, fLineNumber is valid
+                    processLineSpan(rPrevScanRasterConversionLineEntry3D, **aRasterConversionLineEntry3D, nLineNumber, nPairCount++);
                 }
 
-                // copy back next scanline if count has changed
-                if(aNextLine.size() != aCurrentLine.size())
+                // increment to next line
+                if(rPrevScanRasterConversionLineEntry3D.decrementRasterConversionLineEntry3D(1))
                 {
-                    aCurrentLine = aNextLine;
+                    rPrevScanRasterConversionLineEntry3D.incrementRasterConversionLineEntry3D(1, *this);
+                    aNextLine.push_back(&rPrevScanRasterConversionLineEntry3D);
                 }
+            }
 
-                // increment fLineNumber
-                nLineNumber++;
+            // copy back next scanline if count has changed
+            if(aNextLine.size() != aCurrentLine.size())
+            {
+                aCurrentLine = aNextLine;
             }
+
+            // increment fLineNumber
+            nLineNumber++;
         }
     }
 
@@ -157,55 +157,55 @@ namespace basegfx
         sal_Int32 nYStart(fround(aStart.getY()));
         sal_Int32 nYEnd(fround(aEnd.getY()));
 
-        if(nYStart != nYEnd)
+        if(nYStart == nYEnd)
+            return;
+
+        if(nYStart > nYEnd)
         {
-            if(nYStart > nYEnd)
-            {
-                std::swap(aStart, aEnd);
-                std::swap(nYStart, nYEnd);
-                std::swap(a, b);
-            }
+            std::swap(aStart, aEnd);
+            std::swap(nYStart, nYEnd);
+            std::swap(a, b);
+        }
 
-            const sal_uInt32 nYDelta(nYEnd - nYStart);
-            const double fInvYDelta(1.0 / nYDelta);
-            maLineEntries.emplace_back(
-                aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta,
-                aStart.getZ(), (aEnd.getZ() - aStart.getZ()) * fInvYDelta,
-                nYStart, nYDelta);
+        const sal_uInt32 nYDelta(nYEnd - nYStart);
+        const double fInvYDelta(1.0 / nYDelta);
+        maLineEntries.emplace_back(
+            aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta,
+            aStart.getZ(), (aEnd.getZ() - aStart.getZ()) * fInvYDelta,
+            nYStart, nYDelta);
 
-            // if extra interpolation data is used, add it to the last created entry
-            RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1];
+        // if extra interpolation data is used, add it to the last created entry
+        RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1];
 
-            if(rFill.areBColorsUsed())
-            {
-                rEntry.setColorIndex(addColorInterpolator(rFill.getBColor(a), rFill.getBColor(b), fInvYDelta));
-            }
+        if(rFill.areBColorsUsed())
+        {
+            rEntry.setColorIndex(addColorInterpolator(rFill.getBColor(a), rFill.getBColor(b), fInvYDelta));
+        }
 
-            if(rFill.areNormalsUsed())
-            {
-                rEntry.setNormalIndex(addNormalInterpolator(rFill.getNormal(a), rFill.getNormal(b), fInvYDelta));
-            }
+        if(rFill.areNormalsUsed())
+        {
+            rEntry.setNormalIndex(addNormalInterpolator(rFill.getNormal(a), rFill.getNormal(b), fInvYDelta));
+        }
 
-            if(rFill.areTextureCoordinatesUsed())
-            {
-                if(pViewToEye)
-                {
-                    const double fEyeA(((*pViewToEye) * aStart).getZ());
-                    const double fEyeB(((*pViewToEye) * aEnd).getZ());
+        if(!rFill.areTextureCoordinatesUsed())
+            return;
 
-                    rEntry.setInverseTextureIndex(addInverseTextureInterpolator(
-                        rFill.getTextureCoordinate(a),
-                        rFill.getTextureCoordinate(b),
-                        fEyeA, fEyeB, fInvYDelta));
-                }
-                else
-                {
-                    rEntry.setTextureIndex(addTextureInterpolator(
-                        rFill.getTextureCoordinate(a),
-                        rFill.getTextureCoordinate(b),
-                        fInvYDelta));
-                }
-            }
+        if(pViewToEye)
+        {
+            const double fEyeA(((*pViewToEye) * aStart).getZ());
+            const double fEyeB(((*pViewToEye) * aEnd).getZ());
+
+            rEntry.setInverseTextureIndex(addInverseTextureInterpolator(
+                rFill.getTextureCoordinate(a),
+                rFill.getTextureCoordinate(b),
+                fEyeA, fEyeB, fInvYDelta));
+        }
+        else
+        {
+            rEntry.setTextureIndex(addTextureInterpolator(
+                rFill.getTextureCoordinate(a),
+                rFill.getTextureCoordinate(b),
+                fInvYDelta));
         }
     }