| /************************************************************** |
| * |
| * 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 <basegfx/polygon/b3dpolygonclipper.hxx> |
| #include <osl/diagnose.h> |
| #include <basegfx/polygon/b3dpolygontools.hxx> |
| #include <basegfx/numeric/ftools.hxx> |
| #include <basegfx/matrix/b3dhommatrix.hxx> |
| #include <basegfx/polygon/b3dpolygontools.hxx> |
| #include <basegfx/range/b3drange.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/range/b2drange.hxx> |
| #include <basegfx/color/bcolor.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace basegfx |
| { |
| namespace |
| { |
| inline bool impIsInside(const B3DPoint& rCandidate, double fPlaneOffset, tools::B3DOrientation ePlaneOrthogonal) |
| { |
| if(tools::B3DORIENTATION_X == ePlaneOrthogonal) |
| { |
| return fTools::moreOrEqual(rCandidate.getX(), fPlaneOffset); |
| } |
| else if(tools::B3DORIENTATION_Y == ePlaneOrthogonal) |
| { |
| return fTools::moreOrEqual(rCandidate.getY(), fPlaneOffset); |
| } |
| else |
| { |
| return fTools::moreOrEqual(rCandidate.getZ(), fPlaneOffset); |
| } |
| } |
| |
| inline double impGetCut(const B3DPoint& rCurrent, const B3DPoint& rNext, double fPlaneOffset, tools::B3DOrientation ePlaneOrthogonal) |
| { |
| if(tools::B3DORIENTATION_X == ePlaneOrthogonal) |
| { |
| return ((fPlaneOffset - rCurrent.getX())/(rNext.getX() - rCurrent.getX())); |
| } |
| else if(tools::B3DORIENTATION_Y == ePlaneOrthogonal) |
| { |
| return ((fPlaneOffset - rCurrent.getY())/(rNext.getY() - rCurrent.getY())); |
| } |
| else |
| { |
| return ((fPlaneOffset - rCurrent.getZ())/(rNext.getZ() - rCurrent.getZ())); |
| } |
| } |
| |
| void impAppendCopy(B3DPolygon& rDest, const B3DPolygon& rSource, sal_uInt32 nIndex) |
| { |
| rDest.append(rSource.getB3DPoint(nIndex)); |
| |
| if(rSource.areBColorsUsed()) |
| { |
| rDest.setBColor(rDest.count() - 1L, rSource.getBColor(nIndex)); |
| } |
| |
| if(rSource.areNormalsUsed()) |
| { |
| rDest.setNormal(rDest.count() - 1L, rSource.getNormal(nIndex)); |
| } |
| |
| if(rSource.areTextureCoordinatesUsed()) |
| { |
| rDest.setTextureCoordinate(rDest.count() - 1L, rSource.getTextureCoordinate(nIndex)); |
| } |
| } |
| |
| void impAppendInterpolate(B3DPolygon& rDest, const B3DPolygon& rSource, sal_uInt32 nIndA, sal_uInt32 nIndB, double fCut) |
| { |
| const B3DPoint aCurrPoint(rSource.getB3DPoint(nIndA)); |
| const B3DPoint aNextPoint(rSource.getB3DPoint(nIndB)); |
| rDest.append(interpolate(aCurrPoint, aNextPoint, fCut)); |
| |
| if(rSource.areBColorsUsed()) |
| { |
| const BColor aCurrBColor(rSource.getBColor(nIndA)); |
| const BColor aNextBColor(rSource.getBColor(nIndB)); |
| rDest.setBColor(rDest.count() - 1L, interpolate(aCurrBColor, aNextBColor, fCut)); |
| } |
| |
| if(rSource.areNormalsUsed()) |
| { |
| const B3DVector aCurrVector(rSource.getNormal(nIndA)); |
| const B3DVector aNextVector(rSource.getNormal(nIndB)); |
| rDest.setNormal(rDest.count() - 1L, interpolate(aCurrVector, aNextVector, fCut)); |
| } |
| |
| if(rSource.areTextureCoordinatesUsed()) |
| { |
| const B2DPoint aCurrTxCo(rSource.getTextureCoordinate(nIndA)); |
| const B2DPoint aNextTxCo(rSource.getTextureCoordinate(nIndB)); |
| rDest.setTextureCoordinate(rDest.count() - 1L, interpolate(aCurrTxCo, aNextTxCo, fCut)); |
| } |
| } |
| } |
| } // end of namespace basegfx |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace basegfx |
| { |
| namespace tools |
| { |
| B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| if(rCandidate.count()) |
| { |
| const B3DRange aCandidateRange(getRange(rCandidate)); |
| |
| if(B3DORIENTATION_X == ePlaneOrthogonal && fTools::moreOrEqual(aCandidateRange.getMinX(), fPlaneOffset)) |
| { |
| // completely above and on the clip plane. |
| if(bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(B3DORIENTATION_X == ePlaneOrthogonal && fTools::lessOrEqual(aCandidateRange.getMaxX(), fPlaneOffset)) |
| { |
| // completely below and on the clip plane. |
| if(!bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(B3DORIENTATION_Y == ePlaneOrthogonal && fTools::moreOrEqual(aCandidateRange.getMinY(), fPlaneOffset)) |
| { |
| // completely above and on the clip plane. |
| if(bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(B3DORIENTATION_Y == ePlaneOrthogonal && fTools::lessOrEqual(aCandidateRange.getMaxY(), fPlaneOffset)) |
| { |
| // completely below and on the clip plane. |
| if(!bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(B3DORIENTATION_Z == ePlaneOrthogonal && fTools::moreOrEqual(aCandidateRange.getMinZ(), fPlaneOffset)) |
| { |
| // completely above and on the clip plane. |
| if(bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(B3DORIENTATION_Z == ePlaneOrthogonal && fTools::lessOrEqual(aCandidateRange.getMaxZ(), fPlaneOffset)) |
| { |
| // completely below and on the clip plane. |
| if(!bClipPositive) |
| { |
| // add completely |
| aRetval.append(rCandidate); |
| } |
| } |
| else |
| { |
| // prepare loop(s) |
| B3DPolygon aNewPolygon; |
| B3DPoint aCurrent(rCandidate.getB3DPoint(0L)); |
| const sal_uInt32 nPointCount(rCandidate.count()); |
| const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L); |
| bool bCurrentInside(impIsInside(aCurrent, fPlaneOffset, ePlaneOrthogonal) == bClipPositive); |
| |
| if(bCurrentInside) |
| { |
| impAppendCopy(aNewPolygon, rCandidate, 0L); |
| } |
| |
| if(bStroke) |
| { |
| // open polygon, create clipped line snippets. |
| for(sal_uInt32 a(0L); a < nEdgeCount; a++) |
| { |
| // get next point data |
| const sal_uInt32 nNextIndex((a + 1L == nPointCount) ? 0L : a + 1L); |
| const B3DPoint aNext(rCandidate.getB3DPoint(nNextIndex)); |
| const bool bNextInside(impIsInside(aNext, fPlaneOffset, ePlaneOrthogonal) == bClipPositive); |
| |
| if(bCurrentInside != bNextInside) |
| { |
| // change inside/outside |
| if(bNextInside) |
| { |
| // entering, finish existing and start new line polygon |
| if(aNewPolygon.count() > 1L) |
| { |
| aRetval.append(aNewPolygon); |
| } |
| |
| aNewPolygon.clear(); |
| } |
| |
| // calculate and add cut point |
| const double fCut(impGetCut(aCurrent, aNext, fPlaneOffset, ePlaneOrthogonal)); |
| impAppendInterpolate(aNewPolygon, rCandidate, a, nNextIndex, fCut); |
| |
| // pepare next step |
| bCurrentInside = bNextInside; |
| } |
| |
| if(bNextInside) |
| { |
| impAppendCopy(aNewPolygon, rCandidate, nNextIndex); |
| } |
| |
| // pepare next step |
| aCurrent = aNext; |
| } |
| |
| if(aNewPolygon.count() > 1L) |
| { |
| aRetval.append(aNewPolygon); |
| } |
| } |
| else |
| { |
| // closed polygon, create single clipped closed polygon |
| for(sal_uInt32 a(0L); a < nEdgeCount; a++) |
| { |
| // get next point data, use offset |
| const sal_uInt32 nNextIndex((a + 1L == nPointCount) ? 0L : a + 1L); |
| const B3DPoint aNext(rCandidate.getB3DPoint(nNextIndex)); |
| const bool bNextInside(impIsInside(aNext, fPlaneOffset, ePlaneOrthogonal) == bClipPositive); |
| |
| if(bCurrentInside != bNextInside) |
| { |
| // calculate and add cut point |
| const double fCut(impGetCut(aCurrent, aNext, fPlaneOffset, ePlaneOrthogonal)); |
| impAppendInterpolate(aNewPolygon, rCandidate, a, nNextIndex, fCut); |
| |
| // pepare next step |
| bCurrentInside = bNextInside; |
| } |
| |
| if(bNextInside && nNextIndex) |
| { |
| impAppendCopy(aNewPolygon, rCandidate, nNextIndex); |
| } |
| |
| // pepare next step |
| aCurrent = aNext; |
| } |
| |
| if(aNewPolygon.count() > 2L) |
| { |
| aNewPolygon.setClosed(true); |
| aRetval.append(aNewPolygon); |
| } |
| } |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| for(sal_uInt32 a(0L); a < rCandidate.count(); a++) |
| { |
| aRetval.append(clipPolygonOnOrthogonalPlane(rCandidate.getB3DPolygon(a), ePlaneOrthogonal, bClipPositive, fPlaneOffset, bStroke)); |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| for(sal_uInt32 a(0L); a < rCandidate.count(); a++) |
| { |
| aRetval.append(clipPolygonOnRange(rCandidate.getB3DPolygon(a), rRange, bInside, bStroke)); |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| if(rRange.isEmpty()) |
| { |
| // clipping against an empty range. Nothing is inside an empty range, so the polygon |
| // is outside the range. So only return if not inside is wanted |
| if(!bInside && rCandidate.count()) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(rCandidate.count()) |
| { |
| const B3DRange aCandidateRange3D(getRange(rCandidate)); |
| const B2DRange aCandidateRange( |
| aCandidateRange3D.getMinX(), aCandidateRange3D.getMinY(), |
| aCandidateRange3D.getMaxX(), aCandidateRange3D.getMaxY()); |
| |
| if(rRange.isInside(aCandidateRange)) |
| { |
| // candidate is completely inside given range, nothing to do. Is also true with curves. |
| if(bInside) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(!rRange.overlaps(aCandidateRange)) |
| { |
| // candidate is completely outside given range, nothing to do. Is also true with curves. |
| if(!bInside) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else |
| { |
| // clip against the six planes of the range |
| // against lower X |
| aRetval = clipPolygonOnOrthogonalPlane(rCandidate, tools::B3DORIENTATION_X, bInside, rRange.getMinX(), bStroke); |
| |
| if(aRetval.count()) |
| { |
| // against lower Y |
| if(1L == aRetval.count()) |
| { |
| aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Y, bInside, rRange.getMinY(), bStroke); |
| } |
| else |
| { |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Y, bInside, rRange.getMinY(), bStroke); |
| } |
| |
| if(aRetval.count()) |
| { |
| // against higher X |
| if(1L == aRetval.count()) |
| { |
| aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_X, !bInside, rRange.getMaxX(), bStroke); |
| } |
| else |
| { |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_X, !bInside, rRange.getMaxX(), bStroke); |
| } |
| |
| if(aRetval.count()) |
| { |
| // against higher Y |
| if(1L == aRetval.count()) |
| { |
| aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Y, !bInside, rRange.getMaxY(), bStroke); |
| } |
| else |
| { |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Y, !bInside, rRange.getMaxY(), bStroke); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| for(sal_uInt32 a(0L); a < rCandidate.count(); a++) |
| { |
| aRetval.append(clipPolygonOnRange(rCandidate.getB3DPolygon(a), rRange, bInside, bStroke)); |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| if(rRange.isEmpty()) |
| { |
| // clipping against an empty range. Nothing is inside an empty range, so the polygon |
| // is outside the range. So only return if not inside is wanted |
| if(!bInside && rCandidate.count()) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(rCandidate.count()) |
| { |
| const B3DRange aCandidateRange(getRange(rCandidate)); |
| |
| if(rRange.isInside(aCandidateRange)) |
| { |
| // candidate is completely inside given range, nothing to do. Is also true with curves. |
| if(bInside) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else if(!rRange.overlaps(aCandidateRange)) |
| { |
| // candidate is completely outside given range, nothing to do. Is also true with curves. |
| if(!bInside) |
| { |
| aRetval.append(rCandidate); |
| } |
| } |
| else |
| { |
| // clip against X,Y first and see if there's something left |
| const B2DRange aCandidateRange2D(rRange.getMinX(), rRange.getMinY(), rRange.getMaxX(), rRange.getMaxY()); |
| aRetval = clipPolygonOnRange(rCandidate, aCandidateRange2D, bInside, bStroke); |
| |
| if(aRetval.count()) |
| { |
| // against lower Z |
| if(1L == aRetval.count()) |
| { |
| aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Z, bInside, rRange.getMinZ(), bStroke); |
| } |
| else |
| { |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Z, bInside, rRange.getMinZ(), bStroke); |
| } |
| |
| if(aRetval.count()) |
| { |
| // against higher Z |
| if(1L == aRetval.count()) |
| { |
| aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Z, !bInside, rRange.getMaxZ(), bStroke); |
| } |
| else |
| { |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Z, !bInside, rRange.getMaxZ(), bStroke); |
| } |
| } |
| } |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| if(rPlaneNormal.equalZero()) |
| { |
| // not really a plane definition, return polygon |
| aRetval.append(rCandidate); |
| } |
| else if(rCandidate.count()) |
| { |
| // build transform to project planeNormal on X-Axis and pointOnPlane to null point |
| B3DHomMatrix aMatrixTransform; |
| aMatrixTransform.translate(-rPointOnPlane.getX(), -rPointOnPlane.getY(), -rPointOnPlane.getZ()); |
| const double fRotInXY(atan2(rPlaneNormal.getY(), rPlaneNormal.getX())); |
| const double fRotInXZ(atan2(-rPlaneNormal.getZ(), rPlaneNormal.getXYLength())); |
| if(!fTools::equalZero(fRotInXY) || !fTools::equalZero(fRotInXZ)) |
| { |
| aMatrixTransform.rotate(0.0, fRotInXZ, fRotInXY); |
| } |
| |
| // transform polygon to clip scenario |
| B3DPolygon aCandidate(rCandidate); |
| aCandidate.transform(aMatrixTransform); |
| |
| // clip on YZ plane |
| aRetval = clipPolygonOnOrthogonalPlane(aCandidate, tools::B3DORIENTATION_X, bClipPositive, 0.0, bStroke); |
| |
| if(aRetval.count()) |
| { |
| // if there is a result, it needs to be transformed back |
| aMatrixTransform.invert(); |
| aRetval.transform(aMatrixTransform); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke) |
| { |
| B3DPolyPolygon aRetval; |
| |
| if(rPlaneNormal.equalZero()) |
| { |
| // not really a plane definition, return polygon |
| aRetval = rCandidate; |
| } |
| else if(rCandidate.count()) |
| { |
| // build transform to project planeNormal on X-Axis and pointOnPlane to null point |
| B3DHomMatrix aMatrixTransform; |
| aMatrixTransform.translate(-rPointOnPlane.getX(), -rPointOnPlane.getY(), -rPointOnPlane.getZ()); |
| const double fRotInXY(atan2(rPlaneNormal.getY(), rPlaneNormal.getX())); |
| const double fRotInXZ(atan2(-rPlaneNormal.getZ(), rPlaneNormal.getXYLength())); |
| if(!fTools::equalZero(fRotInXY) || !fTools::equalZero(fRotInXZ)) |
| { |
| aMatrixTransform.rotate(0.0, fRotInXZ, fRotInXY); |
| } |
| |
| // transform polygon to clip scenario |
| aRetval = rCandidate; |
| aRetval.transform(aMatrixTransform); |
| |
| // clip on YZ plane |
| aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_X, bClipPositive, 0.0, bStroke); |
| |
| if(aRetval.count()) |
| { |
| // if there is a result, it needs to be transformed back |
| aMatrixTransform.invert(); |
| aRetval.transform(aMatrixTransform); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| } // end of namespace tools |
| } // end of namespace basegfx |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| // eof |
