| /************************************************************** |
| * |
| * 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 <osl/diagnose.h> |
| #include <basegfx/polygon/b3dpolygontools.hxx> |
| #include <basegfx/polygon/b3dpolygon.hxx> |
| #include <basegfx/numeric/ftools.hxx> |
| #include <basegfx/range/b3drange.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/matrix/b3dhommatrix.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/tuple/b3ituple.hxx> |
| #include <numeric> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace basegfx |
| { |
| namespace tools |
| { |
| // B3DPolygon tools |
| void checkClosed(B3DPolygon& rCandidate) |
| { |
| while(rCandidate.count() > 1L |
| && rCandidate.getB3DPoint(0L).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L))) |
| { |
| rCandidate.setClosed(true); |
| rCandidate.remove(rCandidate.count() - 1L); |
| } |
| } |
| |
| // Get successor and predecessor indices. Returning the same index means there |
| // is none. Same for successor. |
| sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate) |
| { |
| OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)"); |
| |
| if(nIndex) |
| { |
| return nIndex - 1L; |
| } |
| else if(rCandidate.count()) |
| { |
| return rCandidate.count() - 1L; |
| } |
| else |
| { |
| return nIndex; |
| } |
| } |
| |
| sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate) |
| { |
| OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)"); |
| |
| if(nIndex + 1L < rCandidate.count()) |
| { |
| return nIndex + 1L; |
| } |
| else |
| { |
| return 0L; |
| } |
| } |
| |
| B3DRange getRange(const B3DPolygon& rCandidate) |
| { |
| B3DRange aRetval; |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| for(sal_uInt32 a(0L); a < nPointCount; a++) |
| { |
| const B3DPoint aTestPoint(rCandidate.getB3DPoint(a)); |
| aRetval.expand(aTestPoint); |
| } |
| |
| return aRetval; |
| } |
| |
| B3DVector getNormal(const B3DPolygon& rCandidate) |
| { |
| return rCandidate.getNormal(); |
| } |
| |
| B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate) |
| { |
| B3DVector aRetval(rCandidate.getNormal()); |
| |
| if(ORIENTATION_NEGATIVE == getOrientation(rCandidate)) |
| { |
| aRetval = -aRetval; |
| } |
| |
| return aRetval; |
| } |
| |
| B2VectorOrientation getOrientation(const B3DPolygon& rCandidate) |
| { |
| B2VectorOrientation eRetval(ORIENTATION_NEUTRAL); |
| |
| if(rCandidate.count() > 2L) |
| { |
| const double fSignedArea(getSignedArea(rCandidate)); |
| |
| if(fSignedArea > 0.0) |
| { |
| eRetval = ORIENTATION_POSITIVE; |
| } |
| else if(fSignedArea < 0.0) |
| { |
| eRetval = ORIENTATION_NEGATIVE; |
| } |
| } |
| |
| return eRetval; |
| } |
| |
| double getSignedArea(const B3DPolygon& rCandidate) |
| { |
| double fRetval(0.0); |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 2) |
| { |
| const B3DVector aAbsNormal(absolute(getNormal(rCandidate))); |
| sal_uInt16 nCase(3); // default: ignore z |
| |
| if(aAbsNormal.getX() > aAbsNormal.getY()) |
| { |
| if(aAbsNormal.getX() > aAbsNormal.getZ()) |
| { |
| nCase = 1; // ignore x |
| } |
| } |
| else if(aAbsNormal.getY() > aAbsNormal.getZ()) |
| { |
| nCase = 2; // ignore y |
| } |
| |
| B3DPoint aPreviousPoint(rCandidate.getB3DPoint(nPointCount - 1L)); |
| |
| for(sal_uInt32 a(0L); a < nPointCount; a++) |
| { |
| const B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a)); |
| |
| switch(nCase) |
| { |
| case 1: // ignore x |
| fRetval += aPreviousPoint.getZ() * aCurrentPoint.getY(); |
| fRetval -= aPreviousPoint.getY() * aCurrentPoint.getZ(); |
| break; |
| case 2: // ignore y |
| fRetval += aPreviousPoint.getX() * aCurrentPoint.getZ(); |
| fRetval -= aPreviousPoint.getZ() * aCurrentPoint.getX(); |
| break; |
| case 3: // ignore z |
| fRetval += aPreviousPoint.getX() * aCurrentPoint.getY(); |
| fRetval -= aPreviousPoint.getY() * aCurrentPoint.getX(); |
| break; |
| } |
| |
| // prepare next step |
| aPreviousPoint = aCurrentPoint; |
| } |
| |
| switch(nCase) |
| { |
| case 1: // ignore x |
| fRetval /= 2.0 * aAbsNormal.getX(); |
| break; |
| case 2: // ignore y |
| fRetval /= 2.0 * aAbsNormal.getY(); |
| break; |
| case 3: // ignore z |
| fRetval /= 2.0 * aAbsNormal.getZ(); |
| break; |
| } |
| } |
| |
| return fRetval; |
| } |
| |
| double getArea(const B3DPolygon& rCandidate) |
| { |
| double fRetval(0.0); |
| |
| if(rCandidate.count() > 2) |
| { |
| fRetval = getSignedArea(rCandidate); |
| const double fZero(0.0); |
| |
| if(fTools::less(fRetval, fZero)) |
| { |
| fRetval = -fRetval; |
| } |
| } |
| |
| return fRetval; |
| } |
| |
| double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex) |
| { |
| OSL_ENSURE(nIndex < rCandidate.count(), "getEdgeLength: Access to polygon out of range (!)"); |
| double fRetval(0.0); |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nIndex < nPointCount) |
| { |
| if(rCandidate.isClosed() || ((nIndex + 1L) != nPointCount)) |
| { |
| const sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate)); |
| const B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nIndex)); |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex)); |
| const B3DVector aVector(aNextPoint - aCurrentPoint); |
| fRetval = aVector.getLength(); |
| } |
| } |
| |
| return fRetval; |
| } |
| |
| double getLength(const B3DPolygon& rCandidate) |
| { |
| double fRetval(0.0); |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 1L) |
| { |
| const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L); |
| |
| for(sal_uInt32 a(0L); a < nLoopCount; a++) |
| { |
| const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate)); |
| const B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a)); |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex)); |
| const B3DVector aVector(aNextPoint - aCurrentPoint); |
| fRetval += aVector.getLength(); |
| } |
| } |
| |
| return fRetval; |
| } |
| |
| B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength) |
| { |
| B3DPoint aRetval; |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 1L) |
| { |
| sal_uInt32 nIndex(0L); |
| bool bIndexDone(false); |
| const double fZero(0.0); |
| double fEdgeLength(fZero); |
| |
| // get length if not given |
| if(fTools::equalZero(fLength)) |
| { |
| fLength = getLength(rCandidate); |
| } |
| |
| // handle fDistance < 0.0 |
| if(fTools::less(fDistance, fZero)) |
| { |
| if(rCandidate.isClosed()) |
| { |
| // if fDistance < 0.0 increment with multiple of fLength |
| sal_uInt32 nCount(sal_uInt32(-fDistance / fLength)); |
| fDistance += double(nCount + 1L) * fLength; |
| } |
| else |
| { |
| // crop to polygon start |
| fDistance = fZero; |
| bIndexDone = true; |
| } |
| } |
| |
| // handle fDistance >= fLength |
| if(fTools::moreOrEqual(fDistance, fLength)) |
| { |
| if(rCandidate.isClosed()) |
| { |
| // if fDistance >= fLength decrement with multiple of fLength |
| sal_uInt32 nCount(sal_uInt32(fDistance / fLength)); |
| fDistance -= (double)(nCount) * fLength; |
| } |
| else |
| { |
| // crop to polygon end |
| fDistance = fZero; |
| nIndex = nPointCount - 1L; |
| bIndexDone = true; |
| } |
| } |
| |
| // look for correct index. fDistance is now [0.0 .. fLength[ |
| if(!bIndexDone) |
| { |
| do |
| { |
| // get length of next edge |
| fEdgeLength = getEdgeLength(rCandidate, nIndex); |
| |
| if(fTools::moreOrEqual(fDistance, fEdgeLength)) |
| { |
| // go to next edge |
| fDistance -= fEdgeLength; |
| nIndex++; |
| } |
| else |
| { |
| // it's on this edge, stop |
| bIndexDone = true; |
| } |
| } while (!bIndexDone); |
| } |
| |
| // get the point using nIndex |
| aRetval = rCandidate.getB3DPoint(nIndex); |
| |
| // if fDistance != 0.0, move that length on the edge. The edge |
| // length is in fEdgeLength. |
| if(!fTools::equalZero(fDistance)) |
| { |
| sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate)); |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex)); |
| double fRelative(fZero); |
| |
| if(!fTools::equalZero(fEdgeLength)) |
| { |
| fRelative = fDistance / fEdgeLength; |
| } |
| |
| // add calculated average value to the return value |
| aRetval += interpolate(aRetval, aNextPoint, fRelative); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength) |
| { |
| // get length if not given |
| if(fTools::equalZero(fLength)) |
| { |
| fLength = getLength(rCandidate); |
| } |
| |
| // multiply fDistance with real length to get absolute position and |
| // use getPositionAbsolute |
| return getPositionAbsolute(rCandidate, fDistance * fLength, fLength); |
| } |
| |
| void applyLineDashing(const B3DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fDotDashLength) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| const sal_uInt32 nDotDashCount(rDotDashArray.size()); |
| |
| if(fTools::lessOrEqual(fDotDashLength, 0.0)) |
| { |
| fDotDashLength = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0); |
| } |
| |
| if(fTools::more(fDotDashLength, 0.0) && (pLineTarget || pGapTarget) && nPointCount) |
| { |
| // clear targets |
| if(pLineTarget) |
| { |
| pLineTarget->clear(); |
| } |
| |
| if(pGapTarget) |
| { |
| pGapTarget->clear(); |
| } |
| |
| // prepare current edge's start |
| B3DPoint aCurrentPoint(rCandidate.getB3DPoint(0)); |
| const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1); |
| |
| // prepare DotDashArray iteration and the line/gap switching bool |
| sal_uInt32 nDotDashIndex(0); |
| bool bIsLine(true); |
| double fDotDashMovingLength(rDotDashArray[0]); |
| B3DPolygon aSnippet; |
| |
| // iterate over all edges |
| for(sal_uInt32 a(0); a < nEdgeCount; a++) |
| { |
| // update current edge |
| double fLastDotDashMovingLength(0.0); |
| const sal_uInt32 nNextIndex((a + 1) % nPointCount); |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex)); |
| const double fEdgeLength(B3DVector(aNextPoint - aCurrentPoint).getLength()); |
| |
| if(!fTools::equalZero(fEdgeLength)) |
| { |
| while(fTools::less(fDotDashMovingLength, fEdgeLength)) |
| { |
| // new split is inside edge, create and append snippet [fLastDotDashMovingLength, fDotDashMovingLength] |
| const bool bHandleLine(bIsLine && pLineTarget); |
| const bool bHandleGap(!bIsLine && pGapTarget); |
| |
| if(bHandleLine || bHandleGap) |
| { |
| if(!aSnippet.count()) |
| { |
| aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fLastDotDashMovingLength / fEdgeLength)); |
| } |
| |
| aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fDotDashMovingLength / fEdgeLength)); |
| |
| if(bHandleLine) |
| { |
| pLineTarget->append(aSnippet); |
| } |
| else |
| { |
| pGapTarget->append(aSnippet); |
| } |
| |
| aSnippet.clear(); |
| } |
| |
| // prepare next DotDashArray step and flip line/gap flag |
| fLastDotDashMovingLength = fDotDashMovingLength; |
| fDotDashMovingLength += rDotDashArray[(++nDotDashIndex) % nDotDashCount]; |
| bIsLine = !bIsLine; |
| } |
| |
| // append snippet [fLastDotDashMovingLength, fEdgeLength] |
| const bool bHandleLine(bIsLine && pLineTarget); |
| const bool bHandleGap(!bIsLine && pGapTarget); |
| |
| if(bHandleLine || bHandleGap) |
| { |
| if(!aSnippet.count()) |
| { |
| aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fLastDotDashMovingLength / fEdgeLength)); |
| } |
| |
| aSnippet.append(aNextPoint); |
| } |
| |
| // prepare move to next edge |
| fDotDashMovingLength -= fEdgeLength; |
| } |
| |
| // prepare next edge step (end point gets new start point) |
| aCurrentPoint = aNextPoint; |
| } |
| |
| // append last intermediate results (if exists) |
| if(aSnippet.count()) |
| { |
| if(bIsLine && pLineTarget) |
| { |
| pLineTarget->append(aSnippet); |
| } |
| else if(!bIsLine && pGapTarget) |
| { |
| pGapTarget->append(aSnippet); |
| } |
| } |
| |
| // check if start and end polygon may be merged |
| if(pLineTarget) |
| { |
| const sal_uInt32 nCount(pLineTarget->count()); |
| |
| if(nCount > 1) |
| { |
| // these polygons were created above, there exists none with less than two points, |
| // thus dircet point access below is allowed |
| const B3DPolygon aFirst(pLineTarget->getB3DPolygon(0)); |
| B3DPolygon aLast(pLineTarget->getB3DPolygon(nCount - 1)); |
| |
| if(aFirst.getB3DPoint(0).equal(aLast.getB3DPoint(aLast.count() - 1))) |
| { |
| // start of first and end of last are the same -> merge them |
| aLast.append(aFirst); |
| aLast.removeDoublePoints(); |
| pLineTarget->setB3DPolygon(0, aLast); |
| pLineTarget->remove(nCount - 1); |
| } |
| } |
| } |
| |
| if(pGapTarget) |
| { |
| const sal_uInt32 nCount(pGapTarget->count()); |
| |
| if(nCount > 1) |
| { |
| // these polygons were created above, there exists none with less than two points, |
| // thus dircet point access below is allowed |
| const B3DPolygon aFirst(pGapTarget->getB3DPolygon(0)); |
| B3DPolygon aLast(pGapTarget->getB3DPolygon(nCount - 1)); |
| |
| if(aFirst.getB3DPoint(0).equal(aLast.getB3DPoint(aLast.count() - 1))) |
| { |
| // start of first and end of last are the same -> merge them |
| aLast.append(aFirst); |
| aLast.removeDoublePoints(); |
| pGapTarget->setB3DPolygon(0, aLast); |
| pGapTarget->remove(nCount - 1); |
| } |
| } |
| } |
| } |
| else |
| { |
| // parameters make no sense, just add source to targets |
| if(pLineTarget) |
| { |
| pLineTarget->append(rCandidate); |
| } |
| |
| if(pGapTarget) |
| { |
| pGapTarget->append(rCandidate); |
| } |
| } |
| } |
| |
| B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter) |
| { |
| B3DPolygon aRetval(rCandidate); |
| |
| for(sal_uInt32 a(0L); a < aRetval.count(); a++) |
| { |
| B3DVector aVector(aRetval.getB3DPoint(a) - rCenter); |
| aVector.normalize(); |
| aRetval.setNormal(a, aVector); |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolygon invertNormals( const B3DPolygon& rCandidate) |
| { |
| B3DPolygon aRetval(rCandidate); |
| |
| if(aRetval.areNormalsUsed()) |
| { |
| for(sal_uInt32 a(0L); a < aRetval.count(); a++) |
| { |
| aRetval.setNormal(a, -aRetval.getNormal(a)); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX, bool bChangeY) |
| { |
| B3DPolygon aRetval(rCandidate); |
| |
| if(bChangeX || bChangeY) |
| { |
| // create projection of standard texture coordinates in (X, Y) onto |
| // the 3d coordinates straight |
| const double fWidth(rRange.getWidth()); |
| const double fHeight(rRange.getHeight()); |
| const bool bWidthSet(!fTools::equalZero(fWidth)); |
| const bool bHeightSet(!fTools::equalZero(fHeight)); |
| const double fOne(1.0); |
| |
| for(sal_uInt32 a(0L); a < aRetval.count(); a++) |
| { |
| const B3DPoint aPoint(aRetval.getB3DPoint(a)); |
| B2DPoint aTextureCoordinate(aRetval.getTextureCoordinate(a)); |
| |
| if(bChangeX) |
| { |
| if(bWidthSet) |
| { |
| aTextureCoordinate.setX((aPoint.getX() - rRange.getMinX()) / fWidth); |
| } |
| else |
| { |
| aTextureCoordinate.setX(0.0); |
| } |
| } |
| |
| if(bChangeY) |
| { |
| if(bHeightSet) |
| { |
| aTextureCoordinate.setY(fOne - ((aPoint.getY() - rRange.getMinY()) / fHeight)); |
| } |
| else |
| { |
| aTextureCoordinate.setY(fOne); |
| } |
| } |
| |
| aRetval.setTextureCoordinate(a, aTextureCoordinate); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX, bool bChangeY) |
| { |
| B3DPolygon aRetval(rCandidate); |
| |
| if(bChangeX || bChangeY) |
| { |
| // create texture coordinates using sphere projection to cartesian coordinates, |
| // use object's center as base |
| const double fOne(1.0); |
| const sal_uInt32 nPointCount(aRetval.count()); |
| bool bPolarPoints(false); |
| sal_uInt32 a; |
| |
| // create center cartesian coordinates to have a possibility to decide if on boundary |
| // transitions which value to choose |
| const B3DRange aPlaneRange(getRange(rCandidate)); |
| const B3DPoint aPlaneCenter(aPlaneRange.getCenter() - rCenter); |
| const double fXCenter(fOne - ((atan2(aPlaneCenter.getZ(), aPlaneCenter.getX()) + F_PI) / F_2PI)); |
| |
| for(a = 0L; a < nPointCount; a++) |
| { |
| const B3DVector aVector(aRetval.getB3DPoint(a) - rCenter); |
| const double fY(fOne - ((atan2(aVector.getY(), aVector.getXZLength()) + F_PI2) / F_PI)); |
| B2DPoint aTexCoor(aRetval.getTextureCoordinate(a)); |
| |
| if(fTools::equalZero(fY)) |
| { |
| // point is a north polar point, no useful X-coordinate can be created. |
| if(bChangeY) |
| { |
| aTexCoor.setY(0.0); |
| |
| if(bChangeX) |
| { |
| bPolarPoints = true; |
| } |
| } |
| } |
| else if(fTools::equal(fY, fOne)) |
| { |
| // point is a south polar point, no useful X-coordinate can be created. Set |
| // Y-coordinte, though |
| if(bChangeY) |
| { |
| aTexCoor.setY(fOne); |
| |
| if(bChangeX) |
| { |
| bPolarPoints = true; |
| } |
| } |
| } |
| else |
| { |
| double fX(fOne - ((atan2(aVector.getZ(), aVector.getX()) + F_PI) / F_2PI)); |
| |
| // correct cartesinan point coordiante dependent from center value |
| if(fX > fXCenter + 0.5) |
| { |
| fX -= fOne; |
| } |
| else if(fX < fXCenter - 0.5) |
| { |
| fX += fOne; |
| } |
| |
| if(bChangeX) |
| { |
| aTexCoor.setX(fX); |
| } |
| |
| if(bChangeY) |
| { |
| aTexCoor.setY(fY); |
| } |
| } |
| |
| aRetval.setTextureCoordinate(a, aTexCoor); |
| } |
| |
| if(bPolarPoints) |
| { |
| // correct X-texture coordinates if polar points are contained. Those |
| // coordinates cannot be correct, so use prev or next X-coordinate |
| for(a = 0L; a < nPointCount; a++) |
| { |
| B2DPoint aTexCoor(aRetval.getTextureCoordinate(a)); |
| |
| if(fTools::equalZero(aTexCoor.getY()) || fTools::equal(aTexCoor.getY(), fOne)) |
| { |
| // get prev, next TexCoor and test for pole |
| const B2DPoint aPrevTexCoor(aRetval.getTextureCoordinate(a ? a - 1L : nPointCount - 1L)); |
| const B2DPoint aNextTexCoor(aRetval.getTextureCoordinate((a + 1L) % nPointCount)); |
| const bool bPrevPole(fTools::equalZero(aPrevTexCoor.getY()) || fTools::equal(aPrevTexCoor.getY(), fOne)); |
| const bool bNextPole(fTools::equalZero(aNextTexCoor.getY()) || fTools::equal(aNextTexCoor.getY(), fOne)); |
| |
| if(!bPrevPole && !bNextPole) |
| { |
| // both no poles, mix them |
| aTexCoor.setX((aPrevTexCoor.getX() + aNextTexCoor.getX()) / 2.0); |
| } |
| else if(!bNextPole) |
| { |
| // copy next |
| aTexCoor.setX(aNextTexCoor.getX()); |
| } |
| else |
| { |
| // copy prev, even if it's a pole, hopefully it is already corrected |
| aTexCoor.setX(aPrevTexCoor.getX()); |
| } |
| |
| aRetval.setTextureCoordinate(a, aTexCoor); |
| } |
| } |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance) |
| { |
| // build edge vector |
| const B3DVector aEdge(rEdgeEnd - rEdgeStart); |
| bool bDoDistanceTestStart(false); |
| bool bDoDistanceTestEnd(false); |
| |
| if(aEdge.equalZero()) |
| { |
| // no edge, just a point. Do one of the distance tests. |
| bDoDistanceTestStart = true; |
| } |
| else |
| { |
| // calculate fCut in aEdge |
| const B3DVector aTestEdge(rTestPosition - rEdgeStart); |
| const double fScalarTestEdge(aEdge.scalar(aTestEdge)); |
| const double fScalarStartEdge(aEdge.scalar(rEdgeStart)); |
| const double fScalarEdge(aEdge.scalar(aEdge)); |
| const double fCut((fScalarTestEdge - fScalarStartEdge) / fScalarEdge); |
| const double fZero(0.0); |
| const double fOne(1.0); |
| |
| if(fTools::less(fCut, fZero)) |
| { |
| // left of rEdgeStart |
| bDoDistanceTestStart = true; |
| } |
| else if(fTools::more(fCut, fOne)) |
| { |
| // right of rEdgeEnd |
| bDoDistanceTestEnd = true; |
| } |
| else |
| { |
| // inside line [0.0 .. 1.0] |
| const B3DPoint aCutPoint(interpolate(rEdgeStart, rEdgeEnd, fCut)); |
| const B3DVector aDelta(rTestPosition - aCutPoint); |
| const double fDistanceSquare(aDelta.scalar(aDelta)); |
| |
| if(fDistanceSquare <= fDistance * fDistance * fDistance) |
| { |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| } |
| |
| if(bDoDistanceTestStart) |
| { |
| const B3DVector aDelta(rTestPosition - rEdgeStart); |
| const double fDistanceSquare(aDelta.scalar(aDelta)); |
| |
| if(fDistanceSquare <= fDistance * fDistance * fDistance) |
| { |
| return true; |
| } |
| } |
| else if(bDoDistanceTestEnd) |
| { |
| const B3DVector aDelta(rTestPosition - rEdgeEnd); |
| const double fDistanceSquare(aDelta.scalar(aDelta)); |
| |
| if(fDistanceSquare <= fDistance * fDistance * fDistance) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount) |
| { |
| const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L); |
| B3DPoint aCurrent(rCandidate.getB3DPoint(0)); |
| |
| if(nEdgeCount) |
| { |
| // edges |
| for(sal_uInt32 a(0); a < nEdgeCount; a++) |
| { |
| const sal_uInt32 nNextIndex((a + 1) % nPointCount); |
| const B3DPoint aNext(rCandidate.getB3DPoint(nNextIndex)); |
| |
| if(isInEpsilonRange(aCurrent, aNext, rTestPosition, fDistance)) |
| { |
| return true; |
| } |
| |
| // prepare next step |
| aCurrent = aNext; |
| } |
| } |
| else |
| { |
| // no edges, but points -> not closed. Check single point. Just |
| // use isInEpsilonRange with twice the same point, it handles those well |
| if(isInEpsilonRange(aCurrent, aCurrent, rTestPosition, fDistance)) |
| { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder) |
| { |
| if(bWithBorder && isPointOnPolygon(rCandidate, rPoint, true)) |
| { |
| return true; |
| } |
| else |
| { |
| bool bRetval(false); |
| const B3DVector aPlaneNormal(rCandidate.getNormal()); |
| |
| if(!aPlaneNormal.equalZero()) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount) |
| { |
| B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nPointCount - 1)); |
| const double fAbsX(fabs(aPlaneNormal.getX())); |
| const double fAbsY(fabs(aPlaneNormal.getY())); |
| const double fAbsZ(fabs(aPlaneNormal.getZ())); |
| |
| if(fAbsX > fAbsY && fAbsX > fAbsZ) |
| { |
| // normal points mostly in X-Direction, use YZ-Polygon projection for check |
| // x -> y, y -> z |
| for(sal_uInt32 a(0); a < nPointCount; a++) |
| { |
| const B3DPoint aPreviousPoint(aCurrentPoint); |
| aCurrentPoint = rCandidate.getB3DPoint(a); |
| |
| // cross-over in Z? |
| const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ())); |
| const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ())); |
| |
| if(bCompZA != bCompZB) |
| { |
| // cross-over in Y? |
| const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY())); |
| const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY())); |
| |
| if(bCompYA == bCompYB) |
| { |
| if(bCompYA) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| else |
| { |
| const double fCompare( |
| aCurrentPoint.getY() - (aCurrentPoint.getZ() - rPoint.getZ()) * |
| (aPreviousPoint.getY() - aCurrentPoint.getY()) / |
| (aPreviousPoint.getZ() - aCurrentPoint.getZ())); |
| |
| if(fTools::more(fCompare, rPoint.getY())) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| } |
| } |
| } |
| else if(fAbsY > fAbsX && fAbsY > fAbsZ) |
| { |
| // normal points mostly in Y-Direction, use XZ-Polygon projection for check |
| // x -> x, y -> z |
| for(sal_uInt32 a(0); a < nPointCount; a++) |
| { |
| const B3DPoint aPreviousPoint(aCurrentPoint); |
| aCurrentPoint = rCandidate.getB3DPoint(a); |
| |
| // cross-over in Z? |
| const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ())); |
| const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ())); |
| |
| if(bCompZA != bCompZB) |
| { |
| // cross-over in X? |
| const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX())); |
| const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX())); |
| |
| if(bCompXA == bCompXB) |
| { |
| if(bCompXA) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| else |
| { |
| const double fCompare( |
| aCurrentPoint.getX() - (aCurrentPoint.getZ() - rPoint.getZ()) * |
| (aPreviousPoint.getX() - aCurrentPoint.getX()) / |
| (aPreviousPoint.getZ() - aCurrentPoint.getZ())); |
| |
| if(fTools::more(fCompare, rPoint.getX())) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| // normal points mostly in Z-Direction, use XY-Polygon projection for check |
| // x -> x, y -> y |
| for(sal_uInt32 a(0); a < nPointCount; a++) |
| { |
| const B3DPoint aPreviousPoint(aCurrentPoint); |
| aCurrentPoint = rCandidate.getB3DPoint(a); |
| |
| // cross-over in Y? |
| const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY())); |
| const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY())); |
| |
| if(bCompYA != bCompYB) |
| { |
| // cross-over in X? |
| const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX())); |
| const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX())); |
| |
| if(bCompXA == bCompXB) |
| { |
| if(bCompXA) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| else |
| { |
| const double fCompare( |
| aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) * |
| (aPreviousPoint.getX() - aCurrentPoint.getX()) / |
| (aPreviousPoint.getY() - aCurrentPoint.getY())); |
| |
| if(fTools::more(fCompare, rPoint.getX())) |
| { |
| bRetval = !bRetval; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| } |
| |
| bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder) |
| { |
| const sal_uInt32 nPointCount(rPolygon.count()); |
| |
| for(sal_uInt32 a(0L); a < nPointCount; a++) |
| { |
| const B3DPoint aTestPoint(rPolygon.getB3DPoint(a)); |
| |
| if(!isInside(rCandidate, aTestPoint, bWithBorder)) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints) |
| { |
| if(rCandidate.equal(rStart) || rCandidate.equal(rEnd)) |
| { |
| // candidate is in epsilon around start or end -> inside |
| return bWithPoints; |
| } |
| else if(rStart.equal(rEnd)) |
| { |
| // start and end are equal, but candidate is outside their epsilon -> outside |
| return false; |
| } |
| else |
| { |
| const B3DVector aEdgeVector(rEnd - rStart); |
| const B3DVector aTestVector(rCandidate - rStart); |
| |
| if(areParallel(aEdgeVector, aTestVector)) |
| { |
| const double fZero(0.0); |
| const double fOne(1.0); |
| double fParamTestOnCurr(0.0); |
| |
| if(aEdgeVector.getX() > aEdgeVector.getY()) |
| { |
| if(aEdgeVector.getX() > aEdgeVector.getZ()) |
| { |
| // X is biggest |
| fParamTestOnCurr = aTestVector.getX() / aEdgeVector.getX(); |
| } |
| else |
| { |
| // Z is biggest |
| fParamTestOnCurr = aTestVector.getZ() / aEdgeVector.getZ(); |
| } |
| } |
| else |
| { |
| if(aEdgeVector.getY() > aEdgeVector.getZ()) |
| { |
| // Y is biggest |
| fParamTestOnCurr = aTestVector.getY() / aEdgeVector.getY(); |
| } |
| else |
| { |
| // Z is biggest |
| fParamTestOnCurr = aTestVector.getZ() / aEdgeVector.getZ(); |
| } |
| } |
| |
| if(fTools::more(fParamTestOnCurr, fZero) && fTools::less(fParamTestOnCurr, fOne)) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| } |
| |
| bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 1L) |
| { |
| const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L); |
| B3DPoint aCurrentPoint(rCandidate.getB3DPoint(0)); |
| |
| for(sal_uInt32 a(0); a < nLoopCount; a++) |
| { |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint((a + 1) % nPointCount)); |
| |
| if(isPointOnLine(aCurrentPoint, aNextPoint, rPoint, bWithPoints)) |
| { |
| return true; |
| } |
| |
| aCurrentPoint = aNextPoint; |
| } |
| } |
| else if(nPointCount && bWithPoints) |
| { |
| return rPoint.equal(rCandidate.getB3DPoint(0)); |
| } |
| |
| return false; |
| } |
| |
| bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut) |
| { |
| if(!rPlaneNormal.equalZero() && !rEdgeStart.equal(rEdgeEnd)) |
| { |
| const B3DVector aTestEdge(rEdgeEnd - rEdgeStart); |
| const double fScalarEdge(rPlaneNormal.scalar(aTestEdge)); |
| |
| if(!fTools::equalZero(fScalarEdge)) |
| { |
| const B3DVector aCompareEdge(rPlanePoint - rEdgeStart); |
| const double fScalarCompare(rPlaneNormal.scalar(aCompareEdge)); |
| |
| fCut = fScalarCompare / fScalarEdge; |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 2 && !rEdgeStart.equal(rEdgeEnd)) |
| { |
| const B3DVector aPlaneNormal(rCandidate.getNormal()); |
| |
| if(!aPlaneNormal.equalZero()) |
| { |
| const B3DPoint aPointOnPlane(rCandidate.getB3DPoint(0)); |
| |
| return getCutBetweenLineAndPlane(aPlaneNormal, aPointOnPlane, rEdgeStart, rEdgeEnd, fCut); |
| } |
| } |
| |
| return false; |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| // comparators with tolerance for 3D Polygons |
| |
| bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue) |
| { |
| const sal_uInt32 nPointCount(rCandidateA.count()); |
| |
| if(nPointCount != rCandidateB.count()) |
| return false; |
| |
| const bool bClosed(rCandidateA.isClosed()); |
| |
| if(bClosed != rCandidateB.isClosed()) |
| return false; |
| |
| for(sal_uInt32 a(0); a < nPointCount; a++) |
| { |
| const B3DPoint aPoint(rCandidateA.getB3DPoint(a)); |
| |
| if(!aPoint.equal(rCandidateB.getB3DPoint(a), rfSmallValue)) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB) |
| { |
| const double fSmallValue(fTools::getSmallValue()); |
| |
| return equal(rCandidateA, rCandidateB, fSmallValue); |
| } |
| |
| // snap points of horizontal or vertical edges to discrete values |
| B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate) |
| { |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| |
| if(nPointCount > 1) |
| { |
| // Start by copying the source polygon to get a writeable copy. The closed state is |
| // copied by aRetval's initialisation, too, so no need to copy it in this method |
| B3DPolygon aRetval(rCandidate); |
| |
| // prepare geometry data. Get rounded from original |
| B3ITuple aPrevTuple(basegfx::fround(rCandidate.getB3DPoint(nPointCount - 1))); |
| B3DPoint aCurrPoint(rCandidate.getB3DPoint(0)); |
| B3ITuple aCurrTuple(basegfx::fround(aCurrPoint)); |
| |
| // loop over all points. This will also snap the implicit closing edge |
| // even when not closed, but that's no problem here |
| for(sal_uInt32 a(0); a < nPointCount; a++) |
| { |
| // get next point. Get rounded from original |
| const bool bLastRun(a + 1 == nPointCount); |
| const sal_uInt32 nNextIndex(bLastRun ? 0 : a + 1); |
| const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex)); |
| const B3ITuple aNextTuple(basegfx::fround(aNextPoint)); |
| |
| // get the states |
| const bool bPrevVertical(aPrevTuple.getX() == aCurrTuple.getX()); |
| const bool bNextVertical(aNextTuple.getX() == aCurrTuple.getX()); |
| const bool bPrevHorizontal(aPrevTuple.getY() == aCurrTuple.getY()); |
| const bool bNextHorizontal(aNextTuple.getY() == aCurrTuple.getY()); |
| const bool bSnapX(bPrevVertical || bNextVertical); |
| const bool bSnapY(bPrevHorizontal || bNextHorizontal); |
| |
| if(bSnapX || bSnapY) |
| { |
| const B3DPoint aSnappedPoint( |
| bSnapX ? aCurrTuple.getX() : aCurrPoint.getX(), |
| bSnapY ? aCurrTuple.getY() : aCurrPoint.getY(), |
| aCurrPoint.getZ()); |
| |
| aRetval.setB3DPoint(a, aSnappedPoint); |
| } |
| |
| // prepare next point |
| if(!bLastRun) |
| { |
| aPrevTuple = aCurrTuple; |
| aCurrPoint = aNextPoint; |
| aCurrTuple = aNextTuple; |
| } |
| } |
| |
| return aRetval; |
| } |
| else |
| { |
| return rCandidate; |
| } |
| } |
| |
| } // end of namespace tools |
| } // end of namespace basegfx |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // eof |
