| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_basegfx.hxx" |
| #include <cstdio> |
| #include <osl/diagnose.h> |
| #include <basegfx/polygon/b2dlinegeometry.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/vector/b2dvector.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> |
| #include <basegfx/range/b2drange.hxx> |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <basegfx/curve/b2dcubicbezier.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| #include <com/sun/star/drawing/LineCap.hpp>
|
| #include <basegfx/polygon/b2dpolypolygoncutter.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace basegfx |
| { |
| namespace tools |
| { |
| B2DPolyPolygon createAreaGeometryForLineStartEnd( |
| const B2DPolygon& rCandidate, |
| const B2DPolyPolygon& rArrow, |
| bool bStart, |
| double fWidth, |
| double fCandidateLength, |
| double fDockingPosition, // 0->top, 1->bottom |
| double* pConsumedLength) |
| { |
| B2DPolyPolygon aRetval; |
| OSL_ENSURE(rCandidate.count() > 1L, "createAreaGeometryForLineStartEnd: Line polygon has too less points (!)"); |
| OSL_ENSURE(rArrow.count() > 0L, "createAreaGeometryForLineStartEnd: Empty arrow PolyPolygon (!)"); |
| OSL_ENSURE(fWidth > 0.0, "createAreaGeometryForLineStartEnd: Width too small (!)"); |
| OSL_ENSURE(fDockingPosition >= 0.0 && fDockingPosition <= 1.0, |
| "createAreaGeometryForLineStartEnd: fDockingPosition out of range [0.0 .. 1.0] (!)"); |
| |
| if(fWidth < 0.0) |
| { |
| fWidth = -fWidth; |
| } |
| |
| if(rCandidate.count() > 1 && rArrow.count() && !fTools::equalZero(fWidth)) |
| { |
| if(fDockingPosition < 0.0) |
| { |
| fDockingPosition = 0.0; |
| } |
| else if(fDockingPosition > 1.0) |
| { |
| fDockingPosition = 1.0; |
| } |
| |
| // init return value from arrow |
| aRetval.append(rArrow); |
| |
| // get size of the arrow |
| const B2DRange aArrowSize(getRange(rArrow)); |
| |
| // build ArrowTransform; center in X, align with axis in Y |
| B2DHomMatrix aArrowTransform(basegfx::tools::createTranslateB2DHomMatrix( |
| -aArrowSize.getCenter().getX(), -aArrowSize.getMinimum().getY())); |
| |
| // scale to target size |
| const double fArrowScale(fWidth / (aArrowSize.getRange().getX())); |
| aArrowTransform.scale(fArrowScale, fArrowScale); |
| |
| // get arrow size in Y |
| B2DPoint aUpperCenter(aArrowSize.getCenter().getX(), aArrowSize.getMaximum().getY()); |
| aUpperCenter *= aArrowTransform; |
| const double fArrowYLength(B2DVector(aUpperCenter).getLength()); |
| |
| // move arrow to have docking position centered |
| aArrowTransform.translate(0.0, -fArrowYLength * fDockingPosition); |
| |
| // prepare polygon length |
| if(fTools::equalZero(fCandidateLength)) |
| { |
| fCandidateLength = getLength(rCandidate); |
| } |
| |
| // get the polygon vector we want to plant this arrow on |
| const double fConsumedLength(fArrowYLength * (1.0 - fDockingPosition)); |
| const B2DVector aHead(rCandidate.getB2DPoint((bStart) ? 0L : rCandidate.count() - 1L)); |
| const B2DVector aTail(getPositionAbsolute(rCandidate, |
| (bStart) ? fConsumedLength : fCandidateLength - fConsumedLength, fCandidateLength)); |
| |
| // from that vector, take the needed rotation and add rotate for arrow to transformation |
| const B2DVector aTargetDirection(aHead - aTail); |
| const double fRotation(atan2(aTargetDirection.getY(), aTargetDirection.getX()) + (90.0 * F_PI180)); |
| |
| // rotate around docking position |
| aArrowTransform.rotate(fRotation); |
| |
| // move arrow docking position to polygon head |
| aArrowTransform.translate(aHead.getX(), aHead.getY()); |
| |
| // transform retval and close |
| aRetval.transform(aArrowTransform); |
| aRetval.setClosed(true); |
| |
| // if pConsumedLength is asked for, fill it |
| if(pConsumedLength) |
| { |
| *pConsumedLength = fConsumedLength; |
| } |
| } |
| |
| return aRetval; |
| } |
| } // end of namespace tools |
| } // end of namespace basegfx |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace basegfx |
| { |
| // anonymus namespace for local helpers |
| namespace |
| { |
| bool impIsSimpleEdge(const B2DCubicBezier& rCandidate, double fMaxCosQuad, double fMaxPartOfEdgeQuad) |
| { |
| // isBezier() is true, already tested by caller |
| const B2DVector aEdge(rCandidate.getEndPoint() - rCandidate.getStartPoint()); |
| |
| if(aEdge.equalZero()) |
| { |
| // start and end point the same, but control vectors used -> baloon curve loop |
| // is not a simple edge |
| return false; |
| } |
| |
| // get tangentA and scalar with edge |
| const B2DVector aTangentA(rCandidate.getTangent(0.0)); |
| const double fScalarAE(aEdge.scalar(aTangentA)); |
| |
| if(fTools::lessOrEqual(fScalarAE, 0.0)) |
| { |
| // angle between TangentA and Edge is bigger or equal 90 degrees |
| return false; |
| } |
| |
| // get self-scalars for E and A |
| const double fScalarE(aEdge.scalar(aEdge)); |
| const double fScalarA(aTangentA.scalar(aTangentA)); |
| const double fLengthCompareE(fScalarE * fMaxPartOfEdgeQuad); |
| |
| if(fTools::moreOrEqual(fScalarA, fLengthCompareE)) |
| { |
| // length of TangentA is more than fMaxPartOfEdge of length of edge |
| return false; |
| } |
| |
| if(fTools::lessOrEqual(fScalarAE * fScalarAE, fScalarA * fScalarE * fMaxCosQuad)) |
| { |
| // angle between TangentA and Edge is bigger or equal angle defined by fMaxCos |
| return false; |
| } |
| |
| // get tangentB and scalar with edge |
| const B2DVector aTangentB(rCandidate.getTangent(1.0)); |
| const double fScalarBE(aEdge.scalar(aTangentB)); |
| |
| if(fTools::lessOrEqual(fScalarBE, 0.0)) |
| { |
| // angle between TangentB and Edge is bigger or equal 90 degrees |
| return false; |
| } |
| |
| // get self-scalar for B |
| const double fScalarB(aTangentB.scalar(aTangentB)); |
| |
| if(fTools::moreOrEqual(fScalarB, fLengthCompareE)) |
| { |
| // length of TangentB is more than fMaxPartOfEdge of length of edge |
| return false; |
| } |
| |
| if(fTools::lessOrEqual(fScalarBE * fScalarBE, fScalarB * fScalarE * fMaxCosQuad)) |
| { |
| // angle between TangentB and Edge is bigger or equal defined by fMaxCos |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void impSubdivideToSimple(const B2DCubicBezier& rCandidate, B2DPolygon& rTarget, double fMaxCosQuad, double fMaxPartOfEdgeQuad, sal_uInt32 nMaxRecursionDepth) |
| { |
| if(!nMaxRecursionDepth || impIsSimpleEdge(rCandidate, fMaxCosQuad, fMaxPartOfEdgeQuad)) |
| { |
| rTarget.appendBezierSegment(rCandidate.getControlPointA(), rCandidate.getControlPointB(), rCandidate.getEndPoint()); |
| } |
| else |
| { |
| B2DCubicBezier aLeft, aRight; |
| rCandidate.split(0.5, &aLeft, &aRight); |
| |
| impSubdivideToSimple(aLeft, rTarget, fMaxCosQuad, fMaxPartOfEdgeQuad, nMaxRecursionDepth - 1); |
| impSubdivideToSimple(aRight, rTarget, fMaxCosQuad, fMaxPartOfEdgeQuad, nMaxRecursionDepth - 1); |
| } |
| } |
| |
| B2DPolygon subdivideToSimple(const B2DPolygon& rCandidate, double fMaxCosQuad, double fMaxPartOfEdgeQuad) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(rCandidate.areControlPointsUsed() && nPointCount) |
| { |
| const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1); |
| B2DPolygon aRetval; |
| B2DCubicBezier aEdge; |
| |
| // prepare edge for loop |
| aEdge.setStartPoint(rCandidate.getB2DPoint(0)); |
| aRetval.append(aEdge.getStartPoint()); |
| |
| for(sal_uInt32 a(0); a < nEdgeCount; a++) |
| { |
| // fill B2DCubicBezier |
| const sal_uInt32 nNextIndex((a + 1) % nPointCount); |
| aEdge.setControlPointA(rCandidate.getNextControlPoint(a)); |
| aEdge.setControlPointB(rCandidate.getPrevControlPoint(nNextIndex)); |
| aEdge.setEndPoint(rCandidate.getB2DPoint(nNextIndex)); |
| |
| // get rid of unnecessary bezier segments |
| aEdge.testAndSolveTrivialBezier(); |
| |
| if(aEdge.isBezier()) |
| { |
| // before splitting recursively with internal simple criteria, use |
| // ExtremumPosFinder to remove those |
| ::std::vector< double > aExtremumPositions; |
| |
| aExtremumPositions.reserve(4); |
| aEdge.getAllExtremumPositions(aExtremumPositions); |
| |
| const sal_uInt32 nCount(aExtremumPositions.size()); |
| |
| if(nCount) |
| { |
| if(nCount > 1) |
| { |
| // create order from left to right |
| ::std::sort(aExtremumPositions.begin(), aExtremumPositions.end()); |
| } |
| |
| for(sal_uInt32 b(0); b < nCount;) |
| { |
| // split aEdge at next split pos |
| B2DCubicBezier aLeft; |
| const double fSplitPos(aExtremumPositions[b++]); |
| |
| aEdge.split(fSplitPos, &aLeft, &aEdge); |
| aLeft.testAndSolveTrivialBezier(); |
| |
| // consume left part |
| if(aLeft.isBezier()) |
| { |
| impSubdivideToSimple(aLeft, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6); |
| } |
| else |
| { |
| aRetval.append(aLeft.getEndPoint()); |
| } |
| |
| if(b < nCount) |
| { |
| // correct the remaining split positions to fit to shortened aEdge |
| const double fScaleFactor(1.0 / (1.0 - fSplitPos)); |
| |
| for(sal_uInt32 c(b); c < nCount; c++) |
| { |
| aExtremumPositions[c] = (aExtremumPositions[c] - fSplitPos) * fScaleFactor; |
| } |
| } |
| } |
| |
| // test the shortened rest of aEdge |
| aEdge.testAndSolveTrivialBezier(); |
| |
| // consume right part |
| if(aEdge.isBezier()) |
| { |
| impSubdivideToSimple(aEdge, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6); |
| } |
| else |
| { |
| aRetval.append(aEdge.getEndPoint()); |
| } |
| } |
| else |
| { |
| impSubdivideToSimple(aEdge, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6); |
| } |
| } |
| else |
| { |
| // straight edge, add point |
| aRetval.append(aEdge.getEndPoint()); |
| } |
| |
| // prepare edge for next step |
| aEdge.setStartPoint(aEdge.getEndPoint()); |
| } |
| |
| // copy closed flag and check for double points |
| aRetval.setClosed(rCandidate.isClosed()); |
| aRetval.removeDoublePoints(); |
| |
| return aRetval; |
| } |
| else |
| { |
| return rCandidate; |
| } |
| } |
| |
| B2DPolygon createAreaGeometryForEdge( |
| const B2DCubicBezier& rEdge, |
| double fHalfLineWidth, |
| bool bStartRound, |
| bool bEndRound, |
| bool bStartSquare, |
| bool bEndSquare) |
| { |
| // create polygon for edge |
| // Unfortunately, while it would be geometrically correct to not add |
| // the in-between points EdgeEnd and EdgeStart, it leads to rounding |
| // errors when converting to integer polygon coordinates for painting |
| if(rEdge.isBezier()) |
| { |
| // prepare target and data common for upper and lower |
| B2DPolygon aBezierPolygon; |
| const B2DVector aPureEdgeVector(rEdge.getEndPoint() - rEdge.getStartPoint()); |
| const double fEdgeLength(aPureEdgeVector.getLength()); |
| const bool bIsEdgeLengthZero(fTools::equalZero(fEdgeLength)); |
| B2DVector aTangentA(rEdge.getTangent(0.0)); aTangentA.normalize(); |
| B2DVector aTangentB(rEdge.getTangent(1.0)); aTangentB.normalize(); |
| const B2DVector aNormalizedPerpendicularA(getPerpendicular(aTangentA)); |
| const B2DVector aNormalizedPerpendicularB(getPerpendicular(aTangentB)); |
| |
| // create upper displacement vectors and check if they cut |
| const B2DVector aPerpendStartA(aNormalizedPerpendicularA * -fHalfLineWidth); |
| const B2DVector aPerpendEndA(aNormalizedPerpendicularB * -fHalfLineWidth); |
| double fCutA(0.0); |
| const tools::CutFlagValue aCutA(tools::findCut( |
| rEdge.getStartPoint(), aPerpendStartA, |
| rEdge.getEndPoint(), aPerpendEndA, |
| CUTFLAG_ALL, &fCutA)); |
| const bool bCutA(CUTFLAG_NONE != aCutA); |
| |
| // create lower displacement vectors and check if they cut |
| const B2DVector aPerpendStartB(aNormalizedPerpendicularA * fHalfLineWidth); |
| const B2DVector aPerpendEndB(aNormalizedPerpendicularB * fHalfLineWidth); |
| double fCutB(0.0); |
| const tools::CutFlagValue aCutB(tools::findCut( |
| rEdge.getEndPoint(), aPerpendEndB, |
| rEdge.getStartPoint(), aPerpendStartB, |
| CUTFLAG_ALL, &fCutB)); |
| const bool bCutB(CUTFLAG_NONE != aCutB); |
| |
| // check if cut happens |
| const bool bCut(bCutA || bCutB); |
| B2DPoint aCutPoint; |
| |
| // create left edge |
| if(bStartRound || bStartSquare) |
| { |
| if(bStartRound) |
| { |
| basegfx::B2DPolygon aStartPolygon(tools::createHalfUnitCircle()); |
| |
| aStartPolygon.transform( |
| tools::createScaleShearXRotateTranslateB2DHomMatrix( |
| fHalfLineWidth, fHalfLineWidth, |
| 0.0, |
| atan2(aTangentA.getY(), aTangentA.getX()) + F_PI2, |
| rEdge.getStartPoint().getX(), rEdge.getStartPoint().getY())); |
| aBezierPolygon.append(aStartPolygon); |
| } |
| else // bStartSquare |
| { |
| const basegfx::B2DPoint aStart(rEdge.getStartPoint() - (aTangentA * fHalfLineWidth)); |
| |
| if(bCutB) |
| { |
| aBezierPolygon.append(rEdge.getStartPoint() + aPerpendStartB); |
| } |
| |
| aBezierPolygon.append(aStart + aPerpendStartB); |
| aBezierPolygon.append(aStart + aPerpendStartA); |
| |
| if(bCutA) |
| { |
| aBezierPolygon.append(rEdge.getStartPoint() + aPerpendStartA); |
| } |
| } |
| } |
| else |
| { |
| // append original in-between point |
| aBezierPolygon.append(rEdge.getStartPoint()); |
| } |
| |
| // create upper edge. |
| { |
| if(bCutA) |
| { |
| // calculate cut point and add |
| aCutPoint = rEdge.getStartPoint() + (aPerpendStartA * fCutA); |
| aBezierPolygon.append(aCutPoint); |
| } |
| else |
| { |
| // create scaled bezier segment |
| const B2DPoint aStart(rEdge.getStartPoint() + aPerpendStartA); |
| const B2DPoint aEnd(rEdge.getEndPoint() + aPerpendEndA); |
| const B2DVector aEdge(aEnd - aStart); |
| const double fLength(aEdge.getLength()); |
| const double fScale(bIsEdgeLengthZero ? 1.0 : fLength / fEdgeLength); |
| const B2DVector fRelNext(rEdge.getControlPointA() - rEdge.getStartPoint()); |
| const B2DVector fRelPrev(rEdge.getControlPointB() - rEdge.getEndPoint()); |
| |
| aBezierPolygon.append(aStart); |
| aBezierPolygon.appendBezierSegment(aStart + (fRelNext * fScale), aEnd + (fRelPrev * fScale), aEnd); |
| } |
| } |
| |
| // create right edge |
| if(bEndRound || bEndSquare) |
| { |
| if(bEndRound) |
| { |
| basegfx::B2DPolygon aEndPolygon(tools::createHalfUnitCircle()); |
| |
| aEndPolygon.transform( |
| tools::createScaleShearXRotateTranslateB2DHomMatrix( |
| fHalfLineWidth, fHalfLineWidth, |
| 0.0, |
| atan2(aTangentB.getY(), aTangentB.getX()) - F_PI2, |
| rEdge.getEndPoint().getX(), rEdge.getEndPoint().getY())); |
| aBezierPolygon.append(aEndPolygon); |
| } |
| else // bEndSquare |
| { |
| const basegfx::B2DPoint aEnd(rEdge.getEndPoint() + (aTangentB * fHalfLineWidth)); |
| |
| if(bCutA) |
| { |
| aBezierPolygon.append(rEdge.getEndPoint() + aPerpendEndA); |
| } |
| |
| aBezierPolygon.append(aEnd + aPerpendEndA); |
| aBezierPolygon.append(aEnd + aPerpendEndB); |
| |
| if(bCutB) |
| { |
| aBezierPolygon.append(rEdge.getEndPoint() + aPerpendEndB); |
| } |
| } |
| } |
| else |
| { |
| // append original in-between point |
| aBezierPolygon.append(rEdge.getEndPoint()); |
| } |
| |
| // create lower edge. |
| { |
| if(bCutB) |
| { |
| // calculate cut point and add |
| aCutPoint = rEdge.getEndPoint() + (aPerpendEndB * fCutB); |
| aBezierPolygon.append(aCutPoint); |
| } |
| else |
| { |
| // create scaled bezier segment |
| const B2DPoint aStart(rEdge.getEndPoint() + aPerpendEndB); |
| const B2DPoint aEnd(rEdge.getStartPoint() + aPerpendStartB); |
| const B2DVector aEdge(aEnd - aStart); |
| const double fLength(aEdge.getLength()); |
| const double fScale(bIsEdgeLengthZero ? 1.0 : fLength / fEdgeLength); |
| const B2DVector fRelNext(rEdge.getControlPointB() - rEdge.getEndPoint()); |
| const B2DVector fRelPrev(rEdge.getControlPointA() - rEdge.getStartPoint()); |
| |
| aBezierPolygon.append(aStart); |
| aBezierPolygon.appendBezierSegment(aStart + (fRelNext * fScale), aEnd + (fRelPrev * fScale), aEnd); |
| } |
| } |
| |
| // close |
| aBezierPolygon.setClosed(true); |
| |
| if(bStartRound || bEndRound) |
| { |
| // double points possible when round caps are used at start or end |
| aBezierPolygon.removeDoublePoints(); |
| } |
| |
| if(bCut && ((bStartRound || bStartSquare) && (bEndRound || bEndSquare))) |
| { |
| // When cut exists and both ends are extended with caps, a self-intersecting polygon |
| // is created; one cut point is known, but there is a 2nd one in the caps geometry. |
| // Solve by using tooling. |
| // Remark: This nearly never happens due to curve preparations to extreme points |
| // and maximum angle turning, but I constructed a test case and checkd that it is |
| // working propery. |
| const B2DPolyPolygon aTemp(tools::solveCrossovers(aBezierPolygon)); |
| const sal_uInt32 nTempCount(aTemp.count()); |
| |
| if(nTempCount) |
| { |
| if(nTempCount > 1) |
| { |
| // as expected, multiple polygons (with same orientation). Remove |
| // the one which contains aCutPoint, or better take the one without |
| for (sal_uInt32 a(0); a < nTempCount; a++) |
| { |
| aBezierPolygon = aTemp.getB2DPolygon(a); |
| |
| const sal_uInt32 nCandCount(aBezierPolygon.count()); |
| |
| for(sal_uInt32 b(0); b < nCandCount; b++) |
| { |
| if(aCutPoint.equal(aBezierPolygon.getB2DPoint(b))) |
| { |
| aBezierPolygon.clear(); |
| break; |
| } |
| } |
| |
| if(aBezierPolygon.count()) |
| { |
| break; |
| } |
| } |
| |
| OSL_ENSURE(aBezierPolygon.count(), "Error in line geometry creation, could not solve self-intersection (!)"); |
| } |
| else |
| { |
| // none found, use result |
| aBezierPolygon = aTemp.getB2DPolygon(0); |
| } |
| } |
| else |
| { |
| OSL_ENSURE(false, "Error in line geometry creation, could not solve self-intersection (!)"); |
| } |
| } |
| |
| // return |
| return aBezierPolygon; |
| } |
| else |
| { |
| // Get start and end point, create tangent and set to needed length |
| B2DVector aTangent(rEdge.getEndPoint() - rEdge.getStartPoint()); |
| aTangent.setLength(fHalfLineWidth); |
| |
| // prepare return value |
| B2DPolygon aEdgePolygon; |
| |
| // buffered angle |
| double fAngle(0.0); |
| bool bAngle(false); |
| |
| // buffered perpendicular |
| B2DVector aPerpend; |
| bool bPerpend(false); |
| |
| // create left vertical |
| if(bStartRound) |
| { |
| aEdgePolygon = tools::createHalfUnitCircle(); |
| fAngle = atan2(aTangent.getY(), aTangent.getX()); |
| bAngle = true; |
| aEdgePolygon.transform( |
| tools::createScaleShearXRotateTranslateB2DHomMatrix( |
| fHalfLineWidth, fHalfLineWidth, |
| 0.0, |
| fAngle + F_PI2, |
| rEdge.getStartPoint().getX(), rEdge.getStartPoint().getY())); |
| } |
| else |
| { |
| aPerpend.setX(-aTangent.getY()); |
| aPerpend.setY(aTangent.getX()); |
| bPerpend = true; |
| |
| if(bStartSquare) |
| { |
| const basegfx::B2DPoint aStart(rEdge.getStartPoint() - aTangent); |
| |
| aEdgePolygon.append(aStart + aPerpend); |
| aEdgePolygon.append(aStart - aPerpend); |
| } |
| else |
| { |
| aEdgePolygon.append(rEdge.getStartPoint() + aPerpend); |
| aEdgePolygon.append(rEdge.getStartPoint()); // keep the in-between point for numerical reasons |
| aEdgePolygon.append(rEdge.getStartPoint() - aPerpend); |
| } |
| } |
| |
| // create right vertical |
| if(bEndRound) |
| { |
| basegfx::B2DPolygon aEndPolygon(tools::createHalfUnitCircle()); |
| |
| if(!bAngle) |
| { |
| fAngle = atan2(aTangent.getY(), aTangent.getX()); |
| } |
| |
| aEndPolygon.transform( |
| tools::createScaleShearXRotateTranslateB2DHomMatrix( |
| fHalfLineWidth, fHalfLineWidth, |
| 0.0, |
| fAngle - F_PI2, |
| rEdge.getEndPoint().getX(), rEdge.getEndPoint().getY())); |
| aEdgePolygon.append(aEndPolygon); |
| } |
| else |
| { |
| if(!bPerpend) |
| { |
| aPerpend.setX(-aTangent.getY()); |
| aPerpend.setY(aTangent.getX()); |
| } |
| |
| if(bEndSquare) |
| { |
| const basegfx::B2DPoint aEnd(rEdge.getEndPoint() + aTangent); |
| |
| aEdgePolygon.append(aEnd - aPerpend); |
| aEdgePolygon.append(aEnd + aPerpend); |
| } |
| else |
| { |
| aEdgePolygon.append(rEdge.getEndPoint() - aPerpend); |
| aEdgePolygon.append(rEdge.getEndPoint()); // keep the in-between point for numerical reasons |
| aEdgePolygon.append(rEdge.getEndPoint() + aPerpend); |
| } |
| } |
| |
| // close and return |
| aEdgePolygon.setClosed(true); |
| |
| return aEdgePolygon; |
| } |
| } |
| |
| B2DPolygon createAreaGeometryForJoin( |
| const B2DVector& rTangentPrev, |
| const B2DVector& rTangentEdge, |
| const B2DVector& rPerpendPrev, |
| const B2DVector& rPerpendEdge, |
| const B2DPoint& rPoint, |
| double fHalfLineWidth, |
| B2DLineJoin eJoin, |
| double fMiterMinimumAngle) |
| { |
| OSL_ENSURE(fHalfLineWidth > 0.0, "createAreaGeometryForJoin: LineWidth too small (!)"); |
| OSL_ENSURE(B2DLINEJOIN_NONE != eJoin, "createAreaGeometryForJoin: B2DLINEJOIN_NONE not allowed (!)"); |
| |
| // LineJoin from tangent rPerpendPrev to tangent rPerpendEdge in rPoint |
| B2DPolygon aEdgePolygon; |
| const B2DPoint aStartPoint(rPoint + rPerpendPrev); |
| const B2DPoint aEndPoint(rPoint + rPerpendEdge); |
| |
| // test if for Miter, the angle is too small and the fallback |
| // to bevel needs to be used |
| if(B2DLINEJOIN_MITER == eJoin) |
| { |
| const double fAngle(fabs(rPerpendPrev.angle(rPerpendEdge))); |
| |
| if((F_PI - fAngle) < fMiterMinimumAngle) |
| { |
| // fallback to bevel |
| eJoin = B2DLINEJOIN_BEVEL; |
| } |
| } |
| |
| switch(eJoin) |
| { |
| case B2DLINEJOIN_MITER : |
| { |
| aEdgePolygon.append(aEndPoint); |
| aEdgePolygon.append(rPoint); |
| aEdgePolygon.append(aStartPoint); |
| |
| // Look for the cut point between start point along rTangentPrev and |
| // end point along rTangentEdge. -rTangentEdge should be used, but since |
| // the cut value is used for interpolating along the first edge, the negation |
| // is not needed since the same fCut will be found on the first edge. |
| // If it exists, insert it to complete the mitered fill polygon. |
| double fCutPos(0.0); |
| tools::findCut(aStartPoint, rTangentPrev, aEndPoint, rTangentEdge, CUTFLAG_ALL, &fCutPos); |
| |
| if(0.0 != fCutPos) |
| { |
| const B2DPoint aCutPoint(aStartPoint + (rTangentPrev * fCutPos)); |
| aEdgePolygon.append(aCutPoint); |
| } |
| |
| break; |
| } |
| case B2DLINEJOIN_ROUND : |
| { |
| // use tooling to add needed EllipseSegment |
| double fAngleStart(atan2(rPerpendPrev.getY(), rPerpendPrev.getX())); |
| double fAngleEnd(atan2(rPerpendEdge.getY(), rPerpendEdge.getX())); |
| |
| // atan2 results are [-PI .. PI], consolidate to [0.0 .. 2PI] |
| if(fAngleStart < 0.0) |
| { |
| fAngleStart += F_2PI; |
| } |
| |
| if(fAngleEnd < 0.0) |
| { |
| fAngleEnd += F_2PI; |
| } |
| |
| const B2DPolygon aBow(tools::createPolygonFromEllipseSegment(rPoint, fHalfLineWidth, fHalfLineWidth, fAngleStart, fAngleEnd)); |
| |
| if(aBow.count() > 1) |
| { |
| // #i101491# |
| // use the original start/end positions; the ones from bow creation may be numerically |
| // different due to their different creation. To guarantee good merging quality with edges |
| // and edge roundings (and to reduce point count) |
| aEdgePolygon = aBow; |
| aEdgePolygon.setB2DPoint(0, aStartPoint); |
| aEdgePolygon.setB2DPoint(aEdgePolygon.count() - 1, aEndPoint); |
| aEdgePolygon.append(rPoint); |
| |
| break; |
| } |
| else |
| { |
| // wanted fall-through to default |
| } |
| } |
| default: // B2DLINEJOIN_BEVEL |
| { |
| aEdgePolygon.append(aEndPoint); |
| aEdgePolygon.append(rPoint); |
| aEdgePolygon.append(aStartPoint); |
| |
| break; |
| } |
| } |
| |
| // create last polygon part for edge |
| aEdgePolygon.setClosed(true); |
| |
| return aEdgePolygon; |
| } |
| } // end of anonymus namespace |
| |
| namespace tools |
| { |
| B2DPolyPolygon createAreaGeometry( |
| const B2DPolygon& rCandidate, |
| double fHalfLineWidth, |
| B2DLineJoin eJoin, |
| com::sun::star::drawing::LineCap eCap, |
| double fMaxAllowedAngle, |
| double fMaxPartOfEdge, |
| double fMiterMinimumAngle) |
| { |
| if(fMaxAllowedAngle > F_PI2) |
| { |
| fMaxAllowedAngle = F_PI2; |
| } |
| else if(fMaxAllowedAngle < 0.01 * F_PI2) |
| { |
| fMaxAllowedAngle = 0.01 * F_PI2; |
| } |
| |
| if(fMaxPartOfEdge > 1.0) |
| { |
| fMaxPartOfEdge = 1.0; |
| } |
| else if(fMaxPartOfEdge < 0.01) |
| { |
| fMaxPartOfEdge = 0.01; |
| } |
| |
| if(fMiterMinimumAngle > F_PI) |
| { |
| fMiterMinimumAngle = F_PI; |
| } |
| else if(fMiterMinimumAngle < 0.01 * F_PI) |
| { |
| fMiterMinimumAngle = 0.01 * F_PI; |
| } |
| |
| B2DPolygon aCandidate(rCandidate); |
| const double fMaxCos(cos(fMaxAllowedAngle)); |
| |
| aCandidate.removeDoublePoints(); |
| aCandidate = subdivideToSimple(aCandidate, fMaxCos * fMaxCos, fMaxPartOfEdge * fMaxPartOfEdge); |
| |
| const sal_uInt32 nPointCount(aCandidate.count()); |
| |
| if(nPointCount) |
| { |
| B2DPolyPolygon aRetval; |
| const bool bEventuallyCreateLineJoin(B2DLINEJOIN_NONE != eJoin); |
| const bool bIsClosed(aCandidate.isClosed()); |
| const sal_uInt32 nEdgeCount(bIsClosed ? nPointCount : nPointCount - 1); |
| const bool bLineCap(!bIsClosed && com::sun::star::drawing::LineCap_BUTT != eCap); |
| |
| if(nEdgeCount) |
| { |
| B2DCubicBezier aEdge; |
| B2DCubicBezier aPrev; |
| |
| // prepare edge |
| aEdge.setStartPoint(aCandidate.getB2DPoint(0)); |
| |
| if(bIsClosed && bEventuallyCreateLineJoin) |
| { |
| // prepare previous edge |
| const sal_uInt32 nPrevIndex(nPointCount - 1); |
| aPrev.setStartPoint(aCandidate.getB2DPoint(nPrevIndex)); |
| aPrev.setControlPointA(aCandidate.getNextControlPoint(nPrevIndex)); |
| aPrev.setControlPointB(aCandidate.getPrevControlPoint(0)); |
| aPrev.setEndPoint(aEdge.getStartPoint()); |
| } |
| |
| for(sal_uInt32 a(0); a < nEdgeCount; a++) |
| { |
| // fill current Edge |
| const sal_uInt32 nNextIndex((a + 1) % nPointCount); |
| aEdge.setControlPointA(aCandidate.getNextControlPoint(a)); |
| aEdge.setControlPointB(aCandidate.getPrevControlPoint(nNextIndex)); |
| aEdge.setEndPoint(aCandidate.getB2DPoint(nNextIndex)); |
| |
| // check and create linejoin |
| if(bEventuallyCreateLineJoin && (bIsClosed || 0 != a)) |
| { |
| B2DVector aTangentPrev(aPrev.getTangent(1.0)); aTangentPrev.normalize(); |
| B2DVector aTangentEdge(aEdge.getTangent(0.0)); aTangentEdge.normalize(); |
| B2VectorOrientation aOrientation(getOrientation(aTangentPrev, aTangentEdge)); |
| |
| if(ORIENTATION_NEUTRAL == aOrientation) |
| { |
| // they are parallell or empty; if they are both not zero and point |
| // in opposite direction, a half-circle is needed |
| if(!aTangentPrev.equalZero() && !aTangentEdge.equalZero()) |
| { |
| const double fAngle(fabs(aTangentPrev.angle(aTangentEdge))); |
| |
| if(fTools::equal(fAngle, F_PI)) |
| { |
| // for half-circle production, fallback to positive |
| // orientation |
| aOrientation = ORIENTATION_POSITIVE; |
| } |
| } |
| } |
| |
| if(ORIENTATION_POSITIVE == aOrientation) |
| { |
| const B2DVector aPerpendPrev(getPerpendicular(aTangentPrev) * -fHalfLineWidth); |
| const B2DVector aPerpendEdge(getPerpendicular(aTangentEdge) * -fHalfLineWidth); |
| |
| aRetval.append( |
| createAreaGeometryForJoin( |
| aTangentPrev, |
| aTangentEdge, |
| aPerpendPrev, |
| aPerpendEdge, |
| aEdge.getStartPoint(), |
| fHalfLineWidth, |
| eJoin, |
| fMiterMinimumAngle)); |
| } |
| else if(ORIENTATION_NEGATIVE == aOrientation) |
| { |
| const B2DVector aPerpendPrev(getPerpendicular(aTangentPrev) * fHalfLineWidth); |
| const B2DVector aPerpendEdge(getPerpendicular(aTangentEdge) * fHalfLineWidth); |
| |
| aRetval.append( |
| createAreaGeometryForJoin( |
| aTangentEdge, |
| aTangentPrev, |
| aPerpendEdge, |
| aPerpendPrev, |
| aEdge.getStartPoint(), |
| fHalfLineWidth, |
| eJoin, |
| fMiterMinimumAngle)); |
| } |
| } |
| |
| // create geometry for edge |
| const bool bLast(a + 1 == nEdgeCount); |
| |
| if(bLineCap) |
| { |
| const bool bFirst(!a); |
| |
| aRetval.append( |
| createAreaGeometryForEdge( |
| aEdge, |
| fHalfLineWidth, |
| bFirst && com::sun::star::drawing::LineCap_ROUND == eCap, |
| bLast && com::sun::star::drawing::LineCap_ROUND == eCap, |
| bFirst && com::sun::star::drawing::LineCap_SQUARE == eCap, |
| bLast && com::sun::star::drawing::LineCap_SQUARE == eCap)); |
| } |
| else |
| { |
| aRetval.append( |
| createAreaGeometryForEdge( |
| aEdge, |
| fHalfLineWidth, |
| false, |
| false, |
| false, |
| false)); |
| } |
| |
| // prepare next step |
| if(!bLast) |
| { |
| if(bEventuallyCreateLineJoin) |
| { |
| aPrev = aEdge; |
| } |
| |
| aEdge.setStartPoint(aEdge.getEndPoint()); |
| } |
| } |
| } |
| |
| return aRetval; |
| } |
| else |
| { |
| return B2DPolyPolygon(rCandidate); |
| } |
| } |
| } // end of namespace tools |
| } // end of namespace basegfx |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
