summaryrefslogtreecommitdiff
path: root/basegfx
diff options
context:
space:
mode:
authorArmin Weiss <aw@openoffice.org>2003-11-28 10:18:16 +0000
committerArmin Weiss <aw@openoffice.org>2003-11-28 10:18:16 +0000
commitd539c95155ccc7030411f7494704894a3ac610a8 (patch)
treedc3dbd283a5f501f6e48dd585d80bb158db920e3 /basegfx
parentce0ce72d1fd37f7b8e7cb4ebc372d8cd6b4ab9c0 (diff)
Removed in-between namespaces (curve, matrix, numeric, point, polygon, range, tuple, vector). Names were too common and e.g. vector leaded to problems with some defines. This is now avoided. Also some bug fixes, addition of 3d polygon tooling etc.
Diffstat (limited to 'basegfx')
-rw-r--r--basegfx/inc/basegfx/curve/b2dbeziertools.hxx245
-rw-r--r--basegfx/inc/basegfx/curve/b2dcubicbezier.hxx69
-rw-r--r--basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx59
-rw-r--r--basegfx/inc/basegfx/matrix/b2dhommatrix.hxx192
-rw-r--r--basegfx/inc/basegfx/matrix/b3dhommatrix.hxx206
-rw-r--r--basegfx/inc/basegfx/numeric/ftools.hxx145
-rw-r--r--basegfx/inc/basegfx/point/b2dhompoint.hxx303
-rw-r--r--basegfx/inc/basegfx/point/b2dpoint.hxx182
-rw-r--r--basegfx/inc/basegfx/point/b3dhompoint.hxx607
-rw-r--r--basegfx/inc/basegfx/point/b3dpoint.hxx206
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygon.hxx162
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygontools.hxx263
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx104
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx272
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx91
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolygon.hxx112
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolygontools.hxx113
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx100
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx33
-rw-r--r--basegfx/inc/basegfx/range/b1drange.hxx161
-rw-r--r--basegfx/inc/basegfx/range/b2drange.hxx223
-rw-r--r--basegfx/inc/basegfx/range/b3drange.hxx253
-rw-r--r--basegfx/inc/basegfx/range/basicrange.hxx151
-rw-r--r--basegfx/inc/basegfx/tuple/b2dtuple.hxx499
-rw-r--r--basegfx/inc/basegfx/tuple/b3dtuple.hxx647
-rw-r--r--basegfx/inc/basegfx/vector/b2dvector.hxx382
-rw-r--r--basegfx/inc/basegfx/vector/b3dvector.hxx464
-rw-r--r--basegfx/prj/d.lst5
-rw-r--r--basegfx/source/curve/b2dbeziertools.cxx767
-rw-r--r--basegfx/source/curve/b2dcubicbezier.cxx146
-rw-r--r--basegfx/source/curve/b2dquadraticbezier.cxx117
-rw-r--r--basegfx/source/inc/hommatrixtemplate.hxx30
-rw-r--r--basegfx/source/matrix/b2dhommatrix.cxx493
-rw-r--r--basegfx/source/matrix/b3dhommatrix.cxx861
-rw-r--r--basegfx/source/numeric/ftools.cxx11
-rw-r--r--basegfx/source/point/b2dhompoint.cxx383
-rw-r--r--basegfx/source/point/b2dpoint.cxx41
-rw-r--r--basegfx/source/point/b3dhompoint.cxx21
-rw-r--r--basegfx/source/point/b3dpoint.cxx43
-rw-r--r--basegfx/source/polygon/b2dpolygon.cxx495
-rw-r--r--basegfx/source/polygon/b2dpolygontools.cxx1410
-rw-r--r--basegfx/source/polygon/b2dpolypolygon.cxx349
-rw-r--r--basegfx/source/polygon/b2dpolypolygoncutter.cxx1542
-rw-r--r--basegfx/source/polygon/b2dpolypolygontools.cxx221
-rw-r--r--basegfx/source/polygon/b3dpolygon.cxx373
-rw-r--r--basegfx/source/polygon/b3dpolygontools.cxx453
-rw-r--r--basegfx/source/polygon/b3dpolypolygon.cxx331
-rw-r--r--basegfx/source/polygon/b3dpolypolygontools.cxx43
-rw-r--r--basegfx/source/range/b1drange.cxx7
-rw-r--r--basegfx/source/range/b2drange.cxx7
-rw-r--r--basegfx/source/range/b3drange.cxx7
-rw-r--r--basegfx/source/tuple/b2dtuple.cxx93
-rw-r--r--basegfx/source/tuple/b3dtuple.cxx11
-rw-r--r--basegfx/source/vector/b2dvector.cxx233
-rw-r--r--basegfx/source/vector/b3dvector.cxx99
55 files changed, 7384 insertions, 7452 deletions
diff --git a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
index f9d72cb47873..c3fa31095e10 100644
--- a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
+++ b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dbeziertools.hxx,v $
*
- * $Revision: 1.2 $
+ * $Revision: 1.3 $
*
- * last change: $Author: thb $ $Date: 2003-11-12 12:09:50 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:46 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,169 +71,160 @@
namespace basegfx
{
- namespace polygon
- {
- class B2DPolygon;
- }
+ class B2DPolygon;
+ class B2DCubicBezier;
+ class B2DQuadraticBezier;
- namespace curve
- {
+ /** Subdivide given cubic bezier segment.
- class B2DCubicBezier;
- class B2DQuadraticBezier;
+ This function adaptively subdivides the given bezier
+ segment into as much straight line segments as necessary,
+ such that the maximal orthogonal distance from any of the
+ segments to the true curve is less than the given error
+ value.
- /** Subdivide given cubic bezier segment.
+ @param rPoly
+ Output polygon. The subdivided bezier segment is added to
+ this polygon via B2DPolygon::append().
- This function adaptively subdivides the given bezier
- segment into as much straight line segments as necessary,
- such that the maximal orthogonal distance from any of the
- segments to the true curve is less than the given error
- value.
+ @param rCurve
+ The cubic bezier curve to subdivide
- @param rPoly
- Output polygon. The subdivided bezier segment is added to
- this polygon via B2DPolygon::append().
+ @param distanceBound
+ Bound on the maximal distance of the approximation to the
+ true curve.
- @param rCurve
- The cubic bezier curve to subdivide
-
- @param distanceBound
- Bound on the maximal distance of the approximation to the
- true curve.
-
- @return the number of line segments created
- */
- sal_Int32 adaptiveSubdivideByDistance( polygon::B2DPolygon& rPoly,
- const B2DCubicBezier& rCurve,
- double distanceBound );
+ @return the number of line segments created
+ */
+ sal_Int32 adaptiveSubdivideByDistance( B2DPolygon& rPoly,
+ const B2DCubicBezier& rCurve,
+ double distanceBound );
- /** Subdivide given cubic bezier segment.
+ /** Subdivide given cubic bezier segment.
- This function adaptively subdivides the given bezier
- segment into as much quadratic bezier curve segments as
- necessary, such that the maximal orthogonal distance from
- any of the segments to the true curve is less than the
- given error value.
+ This function adaptively subdivides the given bezier
+ segment into as much quadratic bezier curve segments as
+ necessary, such that the maximal orthogonal distance from
+ any of the segments to the true curve is less than the
+ given error value.
- @param rPoly
- Output polygon. The subdivided bezier segments are added to
- this polygon via B2DPolygon::append().
+ @param rPoly
+ Output polygon. The subdivided bezier segments are added to
+ this polygon via B2DPolygon::append().
- @param rCurve
- The cubic bezier curve to subdivide
+ @param rCurve
+ The cubic bezier curve to subdivide
- @param distanceBound
- Bound on the maximal distance of the approximation to the
- true curve.
+ @param distanceBound
+ Bound on the maximal distance of the approximation to the
+ true curve.
- @return the number of quadratic curve segments created
- */
- sal_Int32 adaptiveDegreeReductionByDistance( polygon::B2DPolygon& rPoly,
- const B2DCubicBezier& rCurve,
- double distanceBound );
+ @return the number of quadratic curve segments created
+ */
+ sal_Int32 adaptiveDegreeReductionByDistance( B2DPolygon& rPoly,
+ const B2DCubicBezier& rCurve,
+ double distanceBound );
- /** Subdivide given cubic bezier segment.
+ /** Subdivide given cubic bezier segment.
- This function adaptively subdivides the given bezier
- segment into as much straight line segments as necessary,
- such that the maximal angle change between any adjacent
- lines is less than the given error value.
+ This function adaptively subdivides the given bezier
+ segment into as much straight line segments as necessary,
+ such that the maximal angle change between any adjacent
+ lines is less than the given error value.
- @param rPoly
- Output polygon. The subdivided bezier segment is added to
- this polygon via B2DPolygon::append().
+ @param rPoly
+ Output polygon. The subdivided bezier segment is added to
+ this polygon via B2DPolygon::append().
- @param rCurve
- The cubic bezier curve to subdivide
+ @param rCurve
+ The cubic bezier curve to subdivide
- @param angleBound
- Bound on the maximal angle difference between two adjacent
- polygon lines, in degrees.
+ @param angleBound
+ Bound on the maximal angle difference between two adjacent
+ polygon lines, in degrees.
- @return the number of line segments created
- */
- sal_Int32 adaptiveSubdivideByAngle( polygon::B2DPolygon& rPoly,
- const B2DCubicBezier& rCurve,
- double angleBound );
+ @return the number of line segments created
+ */
+ sal_Int32 adaptiveSubdivideByAngle( B2DPolygon& rPoly,
+ const B2DCubicBezier& rCurve,
+ double angleBound );
- /** Subdivide given cubic bezier segment.
+ /** Subdivide given cubic bezier segment.
- This function adaptively subdivides the given bezier
- segment into as much quadratic bezier curve segments as
- necessary, such that the maximal angle difference of the
- control vectors of any generated quadratic bezier segment
- is less than the given error value.
+ This function adaptively subdivides the given bezier
+ segment into as much quadratic bezier curve segments as
+ necessary, such that the maximal angle difference of the
+ control vectors of any generated quadratic bezier segment
+ is less than the given error value.
- @param rPoly
- Output polygon. The subdivided bezier segments are added to
- this polygon via B2DPolygon::append().
+ @param rPoly
+ Output polygon. The subdivided bezier segments are added to
+ this polygon via B2DPolygon::append().
- @param rCurve
- The cubic bezier curve to subdivide
+ @param rCurve
+ The cubic bezier curve to subdivide
- @param distanceBound
- Bound on the maximal angle difference between the control
- vectors of any of the generated quadratic bezier
- segments. The angle must be given in degrees.
+ @param distanceBound
+ Bound on the maximal angle difference between the control
+ vectors of any of the generated quadratic bezier
+ segments. The angle must be given in degrees.
- @return the number of quadratic curve segments created
- */
- sal_Int32 adaptiveDegreeReductionByAngle( polygon::B2DPolygon& rPoly,
- const B2DCubicBezier& rCurve,
- double angleBound );
+ @return the number of quadratic curve segments created
+ */
+ sal_Int32 adaptiveDegreeReductionByAngle( B2DPolygon& rPoly,
+ const B2DCubicBezier& rCurve,
+ double angleBound );
- /** Subdivide given quadratic bezier segment.
+ /** Subdivide given quadratic bezier segment.
- This function adaptively subdivides the given bezier
- segment into as much straight line segments as necessary,
- such that the maximal orthogonal distance from any of the
- segments to the true curve is less than the given error
- value.
+ This function adaptively subdivides the given bezier
+ segment into as much straight line segments as necessary,
+ such that the maximal orthogonal distance from any of the
+ segments to the true curve is less than the given error
+ value.
- @param rPoly
- Output polygon. The subdivided bezier segment is added to
- this polygon via B2DPolygon::append().
+ @param rPoly
+ Output polygon. The subdivided bezier segment is added to
+ this polygon via B2DPolygon::append().
- @param rCurve
- The cubic bezier curve to subdivide
+ @param rCurve
+ The cubic bezier curve to subdivide
- @param distanceBound
- Bound on the maximal distance of the approximation to the
- true curve
+ @param distanceBound
+ Bound on the maximal distance of the approximation to the
+ true curve
- @return the number of line segments created
- */
- sal_Int32 adaptiveSubdivideByDistance( polygon::B2DPolygon& rPoly,
- const B2DQuadraticBezier& rCurve,
- double distanceBound );
-
- /** Subdivide given quadratic bezier segment.
+ @return the number of line segments created
+ */
+ sal_Int32 adaptiveSubdivideByDistance( B2DPolygon& rPoly,
+ const B2DQuadraticBezier& rCurve,
+ double distanceBound );
- This function adaptively subdivides the given bezier
- segment into as much straight line segments as necessary,
- such that the maximal angle change between any adjacent
- lines is less than the given error value.
+ /** Subdivide given quadratic bezier segment.
- @param rPoly
- Output polygon. The subdivided bezier segment is added to
- this polygon via B2DPolygon::append().
+ This function adaptively subdivides the given bezier
+ segment into as much straight line segments as necessary,
+ such that the maximal angle change between any adjacent
+ lines is less than the given error value.
- @param rCurve
- The cubic bezier curve to subdivide
+ @param rPoly
+ Output polygon. The subdivided bezier segment is added to
+ this polygon via B2DPolygon::append().
- @param angleBound
- Bound on the maximal angle difference between two adjacent
- polygon lines, in degrees.
+ @param rCurve
+ The cubic bezier curve to subdivide
- @return the number of line segments created
- */
- sal_Int32 adaptiveSubdivideByAngle( polygon::B2DPolygon& rPoly,
- const B2DQuadraticBezier& rCurve,
- double angleBound );
+ @param angleBound
+ Bound on the maximal angle difference between two adjacent
+ polygon lines, in degrees.
- }
+ @return the number of line segments created
+ */
+ sal_Int32 adaptiveSubdivideByAngle( B2DPolygon& rPoly,
+ const B2DQuadraticBezier& rCurve,
+ double angleBound );
}
#endif // _BGFX_CURVE_B2DBEZIERTOOLS_HXX2
diff --git a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
index 9761367bdd1b..83b18f9c75c5 100644
--- a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
+++ b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dcubicbezier.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-06 16:30:23 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:46 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,50 +70,47 @@
namespace basegfx
{
- namespace curve
+ class B2DCubicBezier
{
- class B2DCubicBezier
- {
- ::basegfx::point::B2DPoint maStartPoint;
- ::basegfx::point::B2DPoint maEndPoint;
- ::basegfx::point::B2DPoint maControlPointA;
- ::basegfx::point::B2DPoint maControlPointB;
+ ::basegfx::B2DPoint maStartPoint;
+ ::basegfx::B2DPoint maEndPoint;
+ ::basegfx::B2DPoint maControlPointA;
+ ::basegfx::B2DPoint maControlPointB;
- public:
- B2DCubicBezier();
- B2DCubicBezier(const B2DCubicBezier& rBezier);
- B2DCubicBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rEnd);
- B2DCubicBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rControlPointA,
- const ::basegfx::point::B2DPoint& rControlPointB, const ::basegfx::point::B2DPoint& rEnd);
- ~B2DCubicBezier();
+ public:
+ B2DCubicBezier();
+ B2DCubicBezier(const B2DCubicBezier& rBezier);
+ B2DCubicBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rEnd);
+ B2DCubicBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rControlPointA,
+ const ::basegfx::B2DPoint& rControlPointB, const ::basegfx::B2DPoint& rEnd);
+ ~B2DCubicBezier();
- // assignment operator
- B2DCubicBezier& operator=(const B2DCubicBezier& rBezier);
+ // assignment operator
+ B2DCubicBezier& operator=(const B2DCubicBezier& rBezier);
- // compare operators
- sal_Bool operator==(const B2DCubicBezier& rBezier) const;
- sal_Bool operator!=(const B2DCubicBezier& rBezier) const;
+ // compare operators
+ sal_Bool operator==(const B2DCubicBezier& rBezier) const;
+ sal_Bool operator!=(const B2DCubicBezier& rBezier) const;
- // test if vectors are used
- sal_Bool isBezier() const;
+ // test if vectors are used
+ sal_Bool isBezier() const;
- // test if contained bezier is trivial and reset vectors accordingly
- void testAndSolveTrivialBezier();
+ // test if contained bezier is trivial and reset vectors accordingly
+ void testAndSolveTrivialBezier();
- // data interface
- ::basegfx::point::B2DPoint getStartPoint() const { return maStartPoint; }
- void setStartPoint(const ::basegfx::point::B2DPoint& rValue) { maStartPoint = rValue; }
+ // data interface
+ ::basegfx::B2DPoint getStartPoint() const { return maStartPoint; }
+ void setStartPoint(const ::basegfx::B2DPoint& rValue) { maStartPoint = rValue; }
- ::basegfx::point::B2DPoint getEndPoint() const { return maEndPoint; }
- void setEndPoint(const ::basegfx::point::B2DPoint& rValue) { maEndPoint = rValue; }
+ ::basegfx::B2DPoint getEndPoint() const { return maEndPoint; }
+ void setEndPoint(const ::basegfx::B2DPoint& rValue) { maEndPoint = rValue; }
- ::basegfx::point::B2DPoint getControlPointA() const { return maControlPointA; }
- void setControlPointA(const ::basegfx::point::B2DPoint& rValue) { maControlPointA = rValue; }
+ ::basegfx::B2DPoint getControlPointA() const { return maControlPointA; }
+ void setControlPointA(const ::basegfx::B2DPoint& rValue) { maControlPointA = rValue; }
- ::basegfx::point::B2DPoint getControlPointB() const { return maControlPointB; }
- void setControlPointB(const ::basegfx::point::B2DPoint& rValue) { maControlPointB = rValue; }
- };
- } // end of namespace curve
+ ::basegfx::B2DPoint getControlPointB() const { return maControlPointB; }
+ void setControlPointB(const ::basegfx::B2DPoint& rValue) { maControlPointB = rValue; }
+ };
} // end of namespace basegfx
#endif // _BGFX_CURVE_B2DCUBICBEZIER_HXX
diff --git a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
index 95f7eeda845a..6f81f26d97a7 100644
--- a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
+++ b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dquadraticbezier.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-06 16:30:23 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:46 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,43 +70,40 @@
namespace basegfx
{
- namespace curve
+ class B2DQuadraticBezier
{
- class B2DQuadraticBezier
- {
- ::basegfx::point::B2DPoint maStartPoint;
- ::basegfx::point::B2DPoint maEndPoint;
- ::basegfx::point::B2DPoint maControlPoint;
+ ::basegfx::B2DPoint maStartPoint;
+ ::basegfx::B2DPoint maEndPoint;
+ ::basegfx::B2DPoint maControlPoint;
- public:
- B2DQuadraticBezier();
- B2DQuadraticBezier(const B2DQuadraticBezier& rBezier);
- B2DQuadraticBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rEnd);
- B2DQuadraticBezier(const ::basegfx::point::B2DPoint& rStart,
- const ::basegfx::point::B2DPoint& rControlPoint, const ::basegfx::point::B2DPoint& rEnd);
- ~B2DQuadraticBezier();
+ public:
+ B2DQuadraticBezier();
+ B2DQuadraticBezier(const B2DQuadraticBezier& rBezier);
+ B2DQuadraticBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rEnd);
+ B2DQuadraticBezier(const ::basegfx::B2DPoint& rStart,
+ const ::basegfx::B2DPoint& rControlPoint, const ::basegfx::B2DPoint& rEnd);
+ ~B2DQuadraticBezier();
- // assignment operator
- B2DQuadraticBezier& operator=(const B2DQuadraticBezier& rBezier);
+ // assignment operator
+ B2DQuadraticBezier& operator=(const B2DQuadraticBezier& rBezier);
- // compare operators
- sal_Bool operator==(const B2DQuadraticBezier& rBezier) const;
- sal_Bool operator!=(const B2DQuadraticBezier& rBezier) const;
+ // compare operators
+ sal_Bool operator==(const B2DQuadraticBezier& rBezier) const;
+ sal_Bool operator!=(const B2DQuadraticBezier& rBezier) const;
- // test if control point is placed on the edge
- sal_Bool isBezier() const;
+ // test if control point is placed on the edge
+ sal_Bool isBezier() const;
- // data interface
- ::basegfx::point::B2DPoint getStartPoint() const { return maStartPoint; }
- void setStartPoint(const ::basegfx::point::B2DPoint& rValue) { maStartPoint = rValue; }
+ // data interface
+ ::basegfx::B2DPoint getStartPoint() const { return maStartPoint; }
+ void setStartPoint(const ::basegfx::B2DPoint& rValue) { maStartPoint = rValue; }
- ::basegfx::point::B2DPoint getEndPoint() const { return maEndPoint; }
- void setEndPoint(const ::basegfx::point::B2DPoint& rValue) { maEndPoint = rValue; }
+ ::basegfx::B2DPoint getEndPoint() const { return maEndPoint; }
+ void setEndPoint(const ::basegfx::B2DPoint& rValue) { maEndPoint = rValue; }
- ::basegfx::point::B2DPoint getControlPoint() const { return maControlPoint; }
- void setControlPoint(const ::basegfx::point::B2DPoint& rValue) { maControlPoint = rValue; }
- };
- } // end of namespace curve
+ ::basegfx::B2DPoint getControlPoint() const { return maControlPoint; }
+ void setControlPoint(const ::basegfx::B2DPoint& rValue) { maControlPoint = rValue; }
+ };
} // end of namespace basegfx
#endif // _BGFX_CURVE_B2DQUADRATICBEZIER_HXX
diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
index 7ff8dfec5ed3..f574e062f5c1 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dhommatrix.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: thb $ $Date: 2003-11-12 12:12:40 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:47 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,127 +68,121 @@
namespace basegfx
{
- namespace tuple
- {
- // predeclaration
- class B2DTuple;
- } // end of namespace tuple
+ // predeclaration
+ class B2DTuple;
+
+ // forward declaration
+ class Impl2DHomMatrix;
- namespace matrix
+ class B2DHomMatrix
{
- // forward declaration
- class Impl2DHomMatrix;
+ private:
+ Impl2DHomMatrix* mpM;
- class B2DHomMatrix
- {
- private:
- Impl2DHomMatrix* mpM;
+ void implPrepareChange();
- void implPrepareChange();
+ public:
+ B2DHomMatrix();
+ B2DHomMatrix(const B2DHomMatrix& rMat);
+ ~B2DHomMatrix();
- public:
- B2DHomMatrix();
- B2DHomMatrix(const B2DHomMatrix& rMat);
- ~B2DHomMatrix();
+ double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
+ void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
- double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
- void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
+ // Auf Einheitsmatrix zuruecksetzen
+ sal_Bool isIdentity() const;
+ void identity();
- // Auf Einheitsmatrix zuruecksetzen
- sal_Bool isIdentity() const;
- void identity();
+ // Invertierung
+ sal_Bool isInvertible() const;
+ sal_Bool invert();
- // Invertierung
- sal_Bool isInvertible() const;
- sal_Bool invert();
+ // Normalisierung
+ sal_Bool isNormalized() const;
+ void normalize();
- // Normalisierung
- sal_Bool isNormalized() const;
- void normalize();
+ // Determinante
+ double determinant() const;
- // Determinante
- double determinant() const;
+ // Trace
+ double trace() const;
- // Trace
- double trace() const;
+ // Transpose
+ void transpose();
- // Transpose
- void transpose();
+ // Rotation
+ void rotate(double fRadiant);
- // Rotation
- void rotate(double fRadiant);
+ // Translation
+ void translate(double fX, double fY);
- // Translation
- void translate(double fX, double fY);
+ // Skalierung
+ void scale(double fX, double fY);
- // Skalierung
- void scale(double fX, double fY);
+ // Shearing-Matrices
+ void shearX(double fSx);
+ void shearY(double fSy);
- // Shearing-Matrices
- void shearX(double fSx);
- void shearY(double fSy);
+ // Addition, Subtraktion
+ B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
+ B2DHomMatrix& operator-=(const B2DHomMatrix& rMat);
- // Addition, Subtraktion
- B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
- B2DHomMatrix& operator-=(const B2DHomMatrix& rMat);
+ // Vergleichsoperatoren
+ sal_Bool operator==(const B2DHomMatrix& rMat) const;
+ sal_Bool operator!=(const B2DHomMatrix& rMat) const;
- // Vergleichsoperatoren
- sal_Bool operator==(const B2DHomMatrix& rMat) const;
- sal_Bool operator!=(const B2DHomMatrix& rMat) const;
+ // Multiplikation, Division mit Konstante
+ B2DHomMatrix& operator*=(double fValue);
+ B2DHomMatrix& operator/=(double fValue);
- // Multiplikation, Division mit Konstante
- B2DHomMatrix& operator*=(double fValue);
- B2DHomMatrix& operator/=(double fValue);
+ // Matritzenmultiplikation von links auf die lokale
+ B2DHomMatrix& operator*=(const B2DHomMatrix& rMat);
- // Matritzenmultiplikation von links auf die lokale
- B2DHomMatrix& operator*=(const B2DHomMatrix& rMat);
+ // assignment operator
+ B2DHomMatrix& operator=(const B2DHomMatrix& rMat);
- // assignment operator
- B2DHomMatrix& operator=(const B2DHomMatrix& rMat);
+ // Help routine to decompose given homogen 3x3 matrix to components. A correction of
+ // the components is done to avoid inaccuracies.
+ // Zerlegung
+ sal_Bool decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const;
+ };
- // Help routine to decompose given homogen 3x3 matrix to components. A correction of
- // the components is done to avoid inaccuracies.
- // Zerlegung
- sal_Bool decompose(tuple::B2DTuple& rScale, tuple::B2DTuple& rTranslate, double& rRotate, double& rShearX) const;
- };
+ // Addition, Subtraktion
+ inline B2DHomMatrix operator+(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
+ {
+ B2DHomMatrix aSum(rMatA);
+ aSum += rMatB;
+ return aSum;
+ }
- // Addition, Subtraktion
- inline B2DHomMatrix operator+(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
- {
- B2DHomMatrix aSum(rMatA);
- aSum += rMatB;
- return aSum;
- }
-
- inline B2DHomMatrix operator-(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
- {
- B2DHomMatrix aDiv(rMatA);
- aDiv -= rMatB;
- return aDiv;
- }
+ inline B2DHomMatrix operator-(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
+ {
+ B2DHomMatrix aDiv(rMatA);
+ aDiv -= rMatB;
+ return aDiv;
+ }
- // Multiplikation, Division mit Konstante
- inline B2DHomMatrix operator*(const B2DHomMatrix& rMat, double fValue)
- {
- B2DHomMatrix aNew(rMat);
- aNew *= fValue;
- return aNew;
- }
-
- inline B2DHomMatrix operator/(const B2DHomMatrix& rMat, double fValue)
- {
- B2DHomMatrix aNew(rMat);
- aNew *= 1.0 / fValue;
- return aNew;
- }
-
- inline B2DHomMatrix operator*(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
- {
- B2DHomMatrix aMul(rMatB);
- aMul *= rMatA;
- return aMul;
- }
- } // end of namespace matrix
+ // Multiplikation, Division mit Konstante
+ inline B2DHomMatrix operator*(const B2DHomMatrix& rMat, double fValue)
+ {
+ B2DHomMatrix aNew(rMat);
+ aNew *= fValue;
+ return aNew;
+ }
+
+ inline B2DHomMatrix operator/(const B2DHomMatrix& rMat, double fValue)
+ {
+ B2DHomMatrix aNew(rMat);
+ aNew *= 1.0 / fValue;
+ return aNew;
+ }
+
+ inline B2DHomMatrix operator*(const B2DHomMatrix& rMatA, const B2DHomMatrix& rMatB)
+ {
+ B2DHomMatrix aMul(rMatB);
+ aMul *= rMatA;
+ return aMul;
+ }
} // end of namespace basegfx
#endif // _BGFX_MATRIX_B2DHOMMATRIX_HXX
diff --git a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
index f16b81c930d7..e2751a76c3cd 100644
--- a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dhommatrix.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: thb $ $Date: 2003-11-12 12:12:40 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:48 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,136 +68,130 @@
namespace basegfx
{
- namespace tuple
- {
- // predeclaration
- class B3DTuple;
- } // end of namespace tuple
+ // predeclaration
+ class B3DTuple;
+
+ // forward declaration
+ class Impl3DHomMatrix;
- namespace matrix
+ class B3DHomMatrix
{
- // forward declaration
- class Impl3DHomMatrix;
+ private:
+ Impl3DHomMatrix* mpM;
- class B3DHomMatrix
- {
- private:
- Impl3DHomMatrix* mpM;
+ void implPrepareChange();
- void implPrepareChange();
+ public:
+ B3DHomMatrix();
+ B3DHomMatrix(const B3DHomMatrix& rMat);
+ ~B3DHomMatrix();
- public:
- B3DHomMatrix();
- B3DHomMatrix(const B3DHomMatrix& rMat);
- ~B3DHomMatrix();
+ double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
+ void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
- double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
- void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
+ sal_Bool isIdentity() const;
+ /// Reset to the identity matrix
+ void identity();
- sal_Bool isIdentity() const;
- /// Reset to the identity matrix
- void identity();
+ sal_Bool isInvertible() const;
+ /// Invert the matrix (if possible)
+ sal_Bool invert();
- sal_Bool isInvertible() const;
- /// Invert the matrix (if possible)
- sal_Bool invert();
+ sal_Bool isNormalized() const;
+ /// Normalize (i.e. force w=1) the matrix
+ void normalize();
- sal_Bool isNormalized() const;
- /// Normalize (i.e. force w=1) the matrix
- void normalize();
+ /// Calc the matrix determinant
+ double determinant() const;
- /// Calc the matrix determinant
- double determinant() const;
+ /// Calc the matrix trace
+ double trace() const;
- /// Calc the matrix trace
- double trace() const;
+ /// Transpose the matrix
+ void transpose();
- /// Transpose the matrix
- void transpose();
+ /// Rotation
+ void rotate(double fAngleX,double fAngleY,double fAngleZ);
- /// Rotation
- void rotate(double fAngleX,double fAngleY,double fAngleZ);
+ /// Translation
+ void translate(double fX, double fY, double fZ);
- /// Translation
- void translate(double fX, double fY, double fZ);
+ /// Scaling
+ void scale(double fX, double fY, double fZ);
- /// Scaling
- void scale(double fX, double fY, double fZ);
+ // Shearing-Matrices
+ void shearXY(double fSx, double fSy);
+ void shearYZ(double fSy, double fSz);
+ void shearXZ(double fSx, double fSz);
- // Shearing-Matrices
- void shearXY(double fSx, double fSy);
- void shearYZ(double fSy, double fSz);
- void shearXZ(double fSx, double fSz);
+ // Projection matrices, used for converting between eye and
+ // clip coordinates
+ void frustum(double fLeft = -1.0, double fRight = 1.0,
+ double fBottom = -1.0, double fTop = 1.0,
+ double fNear = 0.001, double fFar = 1.0);
- // Projection matrices, used for converting between eye and
- // clip coordinates
- void frustum(double fLeft = -1.0, double fRight = 1.0,
- double fBottom = -1.0, double fTop = 1.0,
- double fNear = 0.001, double fFar = 1.0);
+ void ortho(double fLeft = -1.0, double fRight = 1.0,
+ double fBottom = -1.0, double fTop = 1.0,
+ double fNear = 0.0, double fFar = 1.0);
- void ortho(double fLeft = -1.0, double fRight = 1.0,
- double fBottom = -1.0, double fTop = 1.0,
- double fNear = 0.0, double fFar = 1.0);
+ // addition, subtraction
+ B3DHomMatrix& operator+=(const B3DHomMatrix& rMat);
+ B3DHomMatrix& operator-=(const B3DHomMatrix& rMat);
- // addition, subtraction
- B3DHomMatrix& operator+=(const B3DHomMatrix& rMat);
- B3DHomMatrix& operator-=(const B3DHomMatrix& rMat);
+ // comparison
+ sal_Bool operator==(const B3DHomMatrix& rMat) const;
+ sal_Bool operator!=(const B3DHomMatrix& rMat) const;
- // comparison
- sal_Bool operator==(const B3DHomMatrix& rMat) const;
- sal_Bool operator!=(const B3DHomMatrix& rMat) const;
+ // multiplication, division by constant value
+ B3DHomMatrix& operator*=(double fValue);
+ B3DHomMatrix& operator/=(double fValue);
- // multiplication, division by constant value
- B3DHomMatrix& operator*=(double fValue);
- B3DHomMatrix& operator/=(double fValue);
+ // matrix multiplication (from the left)
+ B3DHomMatrix& operator*=(const B3DHomMatrix& rMat);
- // matrix multiplication (from the left)
- B3DHomMatrix& operator*=(const B3DHomMatrix& rMat);
+ // assignment operator
+ B3DHomMatrix& operator=(const B3DHomMatrix& rMat);
- // assignment operator
- B3DHomMatrix& operator=(const B3DHomMatrix& rMat);
+ // decomposition
+ sal_Bool decompose(B3DTuple& rScale, B3DTuple& rTranslate, B3DTuple& rRotate, B3DTuple& rShear) const;
+ };
- // decomposition
- sal_Bool decompose(tuple::B3DTuple& rScale, tuple::B3DTuple& rTranslate, tuple::B3DTuple& rRotate, tuple::B3DTuple& rShear) const;
- };
+ // addition, subtraction
+ inline B3DHomMatrix operator+(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
+ {
+ B3DHomMatrix aSum(rMatA);
+ aSum += rMatB;
+ return aSum;
+ }
- // addition, subtraction
- inline B3DHomMatrix operator+(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
- {
- B3DHomMatrix aSum(rMatA);
- aSum += rMatB;
- return aSum;
- }
-
- inline B3DHomMatrix operator-(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
- {
- B3DHomMatrix aDiv(rMatA);
- aDiv -= rMatB;
- return aDiv;
- }
+ inline B3DHomMatrix operator-(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
+ {
+ B3DHomMatrix aDiv(rMatA);
+ aDiv -= rMatB;
+ return aDiv;
+ }
- // multiplication, division by constant value
- inline B3DHomMatrix operator*(const B3DHomMatrix& rMat, double fValue)
- {
- B3DHomMatrix aNew(rMat);
- aNew *= fValue;
- return aNew;
- }
-
- inline B3DHomMatrix operator/(const B3DHomMatrix& rMat, double fValue)
- {
- B3DHomMatrix aNew(rMat);
- aNew *= 1.0 / fValue;
- return aNew;
- }
-
- inline B3DHomMatrix operator*(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
- {
- B3DHomMatrix aMul(rMatB);
- aMul *= rMatA;
- return aMul;
- }
- } // end of namespace matrix
+ // multiplication, division by constant value
+ inline B3DHomMatrix operator*(const B3DHomMatrix& rMat, double fValue)
+ {
+ B3DHomMatrix aNew(rMat);
+ aNew *= fValue;
+ return aNew;
+ }
+
+ inline B3DHomMatrix operator/(const B3DHomMatrix& rMat, double fValue)
+ {
+ B3DHomMatrix aNew(rMat);
+ aNew *= 1.0 / fValue;
+ return aNew;
+ }
+
+ inline B3DHomMatrix operator*(const B3DHomMatrix& rMatA, const B3DHomMatrix& rMatB)
+ {
+ B3DHomMatrix aMul(rMatB);
+ aMul *= rMatA;
+ return aMul;
+ }
} // end of namespace basegfx
#endif // _BGFX_MATRIX_B3DHOMMATRIX_HXX
diff --git a/basegfx/inc/basegfx/numeric/ftools.hxx b/basegfx/inc/basegfx/numeric/ftools.hxx
index 4a8287ff164c..9ae52843cfe0 100644
--- a/basegfx/inc/basegfx/numeric/ftools.hxx
+++ b/basegfx/inc/basegfx/numeric/ftools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: ftools.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:52 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:50 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -100,80 +100,77 @@
namespace basegfx
{
- namespace numeric
+ class fTools
{
- class fTools
+ static double mfSmallValue;
+
+ public:
+ static double getSmallValue() { return mfSmallValue; }
+ static void setSmallValue(const double& rfNew) { mfSmallValue = rfNew; }
+
+
+ static sal_Bool equalZero(const double& rfVal)
+ {
+ return (fabs(rfVal) <= getSmallValue());
+ }
+
+ static sal_Bool equalZero(const double& rfVal, const double& rfSmallValue)
+ {
+ return (fabs(rfVal) <= rfSmallValue);
+ }
+
+
+ static sal_Bool equal(const double& rfValA, const double& rfValB)
+ {
+ return (fabs(rfValB - rfValA) <= getSmallValue());
+ }
+
+ static sal_Bool less(const double& rfValA, const double& rfValB)
+ {
+ return (rfValA < rfValB && !equal(rfValA, rfValB));
+ }
+
+ static sal_Bool lessOrEqual(const double& rfValA, const double& rfValB)
+ {
+ return (rfValA < rfValB || equal(rfValA, rfValB));
+ }
+
+ static sal_Bool more(const double& rfValA, const double& rfValB)
+ {
+ return (rfValA > rfValB && !equal(rfValA, rfValB));
+ }
+
+ static sal_Bool moreOrEqual(const double& rfValA, const double& rfValB)
+ {
+ return (rfValA > rfValB || equal(rfValA, rfValB));
+ }
+
+
+ static sal_Bool equal(const double& rfValA, const double& rfValB, const double& rfSmallValue)
+ {
+ return (fabs(rfValB - rfValA) <= rfSmallValue);
+ }
+
+ static sal_Bool less(const double& rfValA, const double& rfValB, const double& rfSmallValue)
+ {
+ return (rfValA < rfValB && !equal(rfValA, rfValB, rfSmallValue));
+ }
+
+ static sal_Bool lessOrEqual(const double& rfValA, const double& rfValB, const double& rfSmallValue)
+ {
+ return (rfValA < rfValB || equal(rfValA, rfValB, rfSmallValue));
+ }
+
+ static sal_Bool more(const double& rfValA, const double& rfValB, const double& rfSmallValue)
+ {
+ return (rfValA > rfValB && !equal(rfValA, rfValB, rfSmallValue));
+ }
+
+ static sal_Bool moreOrEqual(const double& rfValA, const double& rfValB, const double& rfSmallValue)
{
- static double mfSmallValue;
-
- public:
- static double getSmallValue() { return mfSmallValue; }
- static void setSmallValue(const double& rfNew) { mfSmallValue = rfNew; }
-
-
- static sal_Bool equalZero(const double& rfVal)
- {
- return (fabs(rfVal) <= getSmallValue());
- }
-
- static sal_Bool equalZero(const double& rfVal, const double& rfSmallValue)
- {
- return (fabs(rfVal) <= rfSmallValue);
- }
-
-
- static sal_Bool equal(const double& rfValA, const double& rfValB)
- {
- return (fabs(rfValB - rfValA) <= getSmallValue());
- }
-
- static sal_Bool less(const double& rfValA, const double& rfValB)
- {
- return (rfValA < rfValB && !equal(rfValA, rfValB));
- }
-
- static sal_Bool lessOrEqual(const double& rfValA, const double& rfValB)
- {
- return (rfValA < rfValB || equal(rfValA, rfValB));
- }
-
- static sal_Bool more(const double& rfValA, const double& rfValB)
- {
- return (rfValA > rfValB && !equal(rfValA, rfValB));
- }
-
- static sal_Bool moreOrEqual(const double& rfValA, const double& rfValB)
- {
- return (rfValA > rfValB || equal(rfValA, rfValB));
- }
-
-
- static sal_Bool equal(const double& rfValA, const double& rfValB, const double& rfSmallValue)
- {
- return (fabs(rfValB - rfValA) <= rfSmallValue);
- }
-
- static sal_Bool less(const double& rfValA, const double& rfValB, const double& rfSmallValue)
- {
- return (rfValA < rfValB && !equal(rfValA, rfValB, rfSmallValue));
- }
-
- static sal_Bool lessOrEqual(const double& rfValA, const double& rfValB, const double& rfSmallValue)
- {
- return (rfValA < rfValB || equal(rfValA, rfValB, rfSmallValue));
- }
-
- static sal_Bool more(const double& rfValA, const double& rfValB, const double& rfSmallValue)
- {
- return (rfValA > rfValB && !equal(rfValA, rfValB, rfSmallValue));
- }
-
- static sal_Bool moreOrEqual(const double& rfValA, const double& rfValB, const double& rfSmallValue)
- {
- return (rfValA > rfValB || equal(rfValA, rfValB, rfSmallValue));
- }
- };
- } // end of namespace numeric
+ return (rfValA > rfValB || equal(rfValA, rfValB, rfSmallValue));
+ }
+ };
} // end of namespace basegfx
#endif _BGFX_NUMERIC_FTOOLS_HXX
diff --git a/basegfx/inc/basegfx/point/b2dhompoint.hxx b/basegfx/inc/basegfx/point/b2dhompoint.hxx
index 3b145bf4e444..911e61a884fd 100644
--- a/basegfx/inc/basegfx/point/b2dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dhompoint.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dhompoint.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-06 16:30:23 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,209 +68,206 @@
namespace basegfx
{
- namespace point
+ /** Basic homogen Point class with two double values and one homogen factor
+
+ This class provides access to homogen coordinates in 2D.
+ For this purpose all the operators which need to do specific
+ action due to their homogenity are implemented here.
+ The only caveat are member methods which are declared as const
+ but do change the content. These are documented for that reason.
+ The class is designed to provide homogenous coordinates without
+ direct access to the homogen part (mfW). This is also the reason
+ for leaving out the [] operators which return references to members.
+
+ @see B2DTuple
+ */
+ class B2DHomPoint
{
- /** Basic homogen Point class with two double values and one homogen factor
-
- This class provides access to homogen coordinates in 2D.
- For this purpose all the operators which need to do specific
- action due to their homogenity are implemented here.
- The only caveat are member methods which are declared as const
- but do change the content. These are documented for that reason.
- The class is designed to provide homogenous coordinates without
- direct access to the homogen part (mfW). This is also the reason
- for leaving out the [] operators which return references to members.
-
- @see B2DTuple
+ protected:
+ /// This member contains the coordinate part of the point
+ ::basegfx::B2DTuple maTuple;
+
+ /// This Member holds the homogenous part of the point
+ double mfW;
+
+ /** Test if this homogen point does have a homogenous part
+
+ @return Returns sal_True if this point has no homogenous part
*/
- class B2DHomPoint
- {
- protected:
- /// This member contains the coordinate part of the point
- ::basegfx::tuple::B2DTuple maTuple;
-
- /// This Member holds the homogenous part of the point
- double mfW;
-
- /** Test if this homogen point does have a homogenous part
-
- @return Returns sal_True if this point has no homogenous part
- */
- sal_Bool implIsHomogenized() const;
-
- /** Remove homogenous part of this Point
-
- This method does necessary calculations to remove
- the evtl. homogenous part of this Point. This may
- change all members.
- */
- void implHomogenize();
+ sal_Bool implIsHomogenized() const;
- /** Test and on demand remove homogenous part
-
- This method tests if this Point does have a homogenous part
- and then evtl. takes actions to remove that part.
-
- @attention Even when this method is const it may change all
- members of this instance. This is due to the fact that changing
- the homogenous part of a homogenous point does from a mathematical
- point of view not change the point at all.
- */
- void implTestAndHomogenize() const;
+ /** Remove homogenous part of this Point
+
+ This method does necessary calculations to remove
+ the evtl. homogenous part of this Point. This may
+ change all members.
+ */
+ void implHomogenize();
+
+ /** Test and on demand remove homogenous part
+
+ This method tests if this Point does have a homogenous part
+ and then evtl. takes actions to remove that part.
+
+ @attention Even when this method is const it may change all
+ members of this instance. This is due to the fact that changing
+ the homogenous part of a homogenous point does from a mathematical
+ point of view not change the point at all.
+ */
+ void implTestAndHomogenize() const;
- public:
- /** Create a homogen point
+ public:
+ /** Create a homogen point
- @param fVal
- This parameter is used to initialize the coordinate
- part of the Point. The homogenous part is initialized to 1.0.
- */
- B2DHomPoint(double fVal = 0.0)
- : maTuple(fVal),
- mfW(1.0)
- {}
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the Point. The homogenous part is initialized to 1.0.
+ */
+ B2DHomPoint(double fVal = 0.0)
+ : maTuple(fVal),
+ mfW(1.0)
+ {}
- /** Create a homogen point
+ /** Create a homogen point
- @param fX
- This parameter is used to initialize the X-coordinate
- of the Point. The homogenous part is initialized to 1.0.
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the Point. The homogenous part is initialized to 1.0.
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the Point. The homogenous part is initialized to 1.0.
- */
- B2DHomPoint(double fX, double fY)
- : maTuple(fX, fY),
- mfW(1.0)
- {}
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the Point. The homogenous part is initialized to 1.0.
+ */
+ B2DHomPoint(double fX, double fY)
+ : maTuple(fX, fY),
+ mfW(1.0)
+ {}
- /** Create a copy of a 2D Point
+ /** Create a copy of a 2D Point
- @param rVec
- The 2D point which will be copied. The homogenous part
- is initialized to 1.0.
- */
- B2DHomPoint(const B2DPoint& rVec)
- : maTuple(rVec),
- mfW(1.0)
- {}
+ @param rVec
+ The 2D point which will be copied. The homogenous part
+ is initialized to 1.0.
+ */
+ B2DHomPoint(const B2DPoint& rVec)
+ : maTuple(rVec),
+ mfW(1.0)
+ {}
- /** Create a copy of a homogen point
+ /** Create a copy of a homogen point
- @param rVec
- The homogen point which will be copied. The homogenous part
- is copied, too.
- */
- B2DHomPoint(const B2DHomPoint& rVec)
- : maTuple(rVec.maTuple.getX(), rVec.maTuple.getY()),
- mfW(rVec.mfW)
- {}
+ @param rVec
+ The homogen point which will be copied. The homogenous part
+ is copied, too.
+ */
+ B2DHomPoint(const B2DHomPoint& rVec)
+ : maTuple(rVec.maTuple.getX(), rVec.maTuple.getY()),
+ mfW(rVec.mfW)
+ {}
- ~B2DHomPoint()
- {}
+ ~B2DHomPoint()
+ {}
- /** Get a 2D point from this homogenous point
+ /** Get a 2D point from this homogenous point
- This method normalizes this homogen point if necessary and
- returns the corresponding 2D point for this homogen point.
+ This method normalizes this homogen point if necessary and
+ returns the corresponding 2D point for this homogen point.
- @attention Even when this method is const it may change all
- members of this instance.
- */
- B2DPoint getB2DPoint() const;
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ B2DPoint getB2DPoint() const;
- /** Get X-coordinate
+ /** Get X-coordinate
- This method normalizes this homogen point if necessary and
- returns the corresponding X-coordinate for this homogen point.
+ This method normalizes this homogen point if necessary and
+ returns the corresponding X-coordinate for this homogen point.
- @attention Even when this method is const it may change all
- members of this instance.
- */
- double getX() const;
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ double getX() const;
- /** Get Y-coordinate
+ /** Get Y-coordinate
- This method normalizes this homogen point if necessary and
- returns the corresponding Y-coordinate for this homogen point.
+ This method normalizes this homogen point if necessary and
+ returns the corresponding Y-coordinate for this homogen point.
- @attention Even when this method is const it may change all
- members of this instance.
- */
- double getY() const;
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ double getY() const;
- /** Set X-coordinate of the homogen point.
+ /** Set X-coordinate of the homogen point.
- This method sets the X-coordinate of the homogen point. If
- the point does have a homogenous part this is taken into account.
+ This method sets the X-coordinate of the homogen point. If
+ the point does have a homogenous part this is taken into account.
- @param fX
- The to-be-set X-coordinate without homogenous part.
- */
- void setX(double fX);
+ @param fX
+ The to-be-set X-coordinate without homogenous part.
+ */
+ void setX(double fX);
- /** Set Y-coordinate of the homogen point.
+ /** Set Y-coordinate of the homogen point.
- This method sets the Y-coordinate of the homogen point. If
- the point does have a homogenous part this is taken into account.
+ This method sets the Y-coordinate of the homogen point. If
+ the point does have a homogenous part this is taken into account.
- @param fY
- The to-be-set Y-coordinate without homogenous part.
- */
- void setY(double fY);
+ @param fY
+ The to-be-set Y-coordinate without homogenous part.
+ */
+ void setY(double fY);
- // operators
- //////////////////////////////////////////////////////////////////////
+ // operators
+ //////////////////////////////////////////////////////////////////////
- B2DHomPoint& operator+=( const B2DHomPoint& rPnt );
+ B2DHomPoint& operator+=( const B2DHomPoint& rPnt );
- B2DHomPoint& operator-=( const B2DHomPoint& rPnt );
+ B2DHomPoint& operator-=( const B2DHomPoint& rPnt );
- B2DHomPoint& operator*=(double t);
+ B2DHomPoint& operator*=(double t);
- B2DHomPoint& operator*=( const matrix::B2DHomMatrix& rMat );
+ B2DHomPoint& operator*=( const B2DHomMatrix& rMat );
- B2DHomPoint& operator/=(double t);
+ B2DHomPoint& operator/=(double t);
- B2DHomPoint& operator-(void);
+ B2DHomPoint& operator-(void);
- sal_Bool operator==( const B2DHomPoint& rPnt ) const;
+ sal_Bool operator==( const B2DHomPoint& rPnt ) const;
- sal_Bool operator!=( const B2DHomPoint& rPnt ) const;
+ sal_Bool operator!=( const B2DHomPoint& rPnt ) const;
- B2DHomPoint& operator=( const B2DHomPoint& rPnt );
- };
+ B2DHomPoint& operator=( const B2DHomPoint& rPnt );
+ };
- // external operators
- //////////////////////////////////////////////////////////////////////////
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
- B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+ B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
- B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+ B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
- B2DHomPoint abs(const B2DHomPoint& rVec);
+ B2DHomPoint abs(const B2DHomPoint& rVec);
- B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
+ B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
- B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
+ B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
- B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
+ B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
- B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+ B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
- B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+ B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
- B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
+ B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
- B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
+ B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
- B2DHomPoint operator*( const matrix::B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
+ B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
- B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
+ B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
- B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
- } // end of namespace point
+ B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
} // end of namespace basegfx
#endif // _BGFX_POINT_B2DHOMPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b2dpoint.hxx b/basegfx/inc/basegfx/point/b2dpoint.hxx
index eb5f042f69e8..ed07229f4e59 100644
--- a/basegfx/inc/basegfx/point/b2dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dpoint.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpoint.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:54 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,104 +68,98 @@
namespace basegfx
{
- namespace matrix
- {
- // predeclaration
- class B2DHomMatrix;
- } // end of namespace matrix;
+ // predeclaration
+ class B2DHomMatrix;
+
+ /** Base Point class with two double values
+
+ This class derives all operators and common handling for
+ a 2D data class from B2DTuple. All necessary extensions
+ which are special for points will be added here.
- namespace point
+ @see B2DTuple
+ */
+ class B2DPoint : public ::basegfx::B2DTuple
{
- /** Base Point class with two double values
+ public:
+ /** Create a 2D Point
+
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 2D Point.
+ */
+ B2DPoint(double fVal = 0.0)
+ : B2DTuple(fVal)
+ {}
+
+ /** Create a 2D Point
+
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 2D Point.
+
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 2D Point.
+ */
+ B2DPoint(double fX, double fY)
+ : B2DTuple(fX, fY)
+ {}
+
+ /** Create a copy of a 2D Point
+
+ @param rPoint
+ The 2D Point which will be copied.
+ */
+ B2DPoint(const B2DPoint& rPoint)
+ : B2DTuple(rPoint)
+ {}
- This class derives all operators and common handling for
- a 2D data class from B2DTuple. All necessary extensions
- which are special for points will be added here.
+ /** constructor with tuple to allow copy-constructing
+ from B2DTuple-based classes
+ */
+ B2DPoint(const ::basegfx::B2DTuple& rTuple)
+ : B2DTuple(rTuple)
+ {}
+
+ ~B2DPoint()
+ {}
+
+ /** *=operator to allow usage from B2DPoint, too
+ */
+ B2DPoint& operator*=( const B2DPoint& rPnt )
+ {
+ mfX *= rPnt.mfX;
+ mfY *= rPnt.mfY;
+ return *this;
+ }
+
+ /** *=operator to allow usage from B2DPoint, too
+ */
+ B2DPoint& operator*=(double t)
+ {
+ mfX *= t;
+ mfY *= t;
+ return *this;
+ }
+
+ /** assignment operator to allow assigning the results
+ of B2DTuple calculations
+ */
+ B2DPoint& operator=( const ::basegfx::B2DTuple& rPoint );
+
+ /** Transform point by given transformation matrix.
- @see B2DTuple
+ The translational components of the matrix are, in
+ contrast to B2DVector, applied.
*/
- class B2DPoint : public ::basegfx::tuple::B2DTuple
+ B2DPoint& operator*=( const ::basegfx::B2DHomMatrix& rMat );
+
+ static const B2DPoint& getEmptyPoint()
{
- public:
- /** Create a 2D Point
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 2D Point.
- */
- B2DPoint(double fVal = 0.0)
- : B2DTuple(fVal)
- {}
-
- /** Create a 2D Point
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 2D Point.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 2D Point.
- */
- B2DPoint(double fX, double fY)
- : B2DTuple(fX, fY)
- {}
-
- /** Create a copy of a 2D Point
-
- @param rPoint
- The 2D Point which will be copied.
- */
- B2DPoint(const B2DPoint& rPoint)
- : B2DTuple(rPoint)
- {}
-
- /** constructor with tuple to allow copy-constructing
- from B2DTuple-based classes
- */
- B2DPoint(const ::basegfx::tuple::B2DTuple& rTuple)
- : B2DTuple(rTuple)
- {}
-
- ~B2DPoint()
- {}
-
- /** *=operator to allow usage from B2DPoint, too
- */
- B2DPoint& operator*=( const B2DPoint& rPnt )
- {
- mfX *= rPnt.mfX;
- mfY *= rPnt.mfY;
- return *this;
- }
-
- /** *=operator to allow usage from B2DPoint, too
- */
- B2DPoint& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- return *this;
- }
-
- /** assignment operator to allow assigning the results
- of B2DTuple calculations
- */
- B2DPoint& operator=( const ::basegfx::tuple::B2DTuple& rPoint );
-
- /** Transform point by given transformation matrix.
-
- The translational components of the matrix are, in
- contrast to B2DVector, applied.
- */
- B2DPoint& operator*=( const ::basegfx::matrix::B2DHomMatrix& rMat );
-
- static const B2DPoint& getEmptyPoint()
- {
- return (const B2DPoint&) ::basegfx::tuple::B2DTuple::getEmptyTuple();
- }
- };
- } // end of namespace point
+ return (const B2DPoint&) ::basegfx::B2DTuple::getEmptyTuple();
+ }
+ };
} // end of namespace basegfx
#endif // _BGFX_POINT_B2DPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b3dhompoint.hxx b/basegfx/inc/basegfx/point/b3dhompoint.hxx
index 7cd82c364a7f..08079b90a983 100644
--- a/basegfx/inc/basegfx/point/b3dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dhompoint.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dhompoint.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-10 11:45:47 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,379 +68,376 @@
namespace basegfx
{
- namespace point
+ /** Basic homogen Point class with three double values and one homogen factor
+
+ This class provides access to homogen coordinates in 3D.
+ For this purpose all the operators which need to do specific
+ action due to their homogenity are implemented here.
+ The only caveat are member methods which are declared as const
+ but do change the content. These are documented for that reason.
+ The class is designed to provide homogenous coordinates without
+ direct access to the homogen part (mfW). This is also the reason
+ for leaving out the [] operators which return references to members.
+
+ @see B3DTuple
+ */
+ class B3DHomPoint
{
- /** Basic homogen Point class with three double values and one homogen factor
-
- This class provides access to homogen coordinates in 3D.
- For this purpose all the operators which need to do specific
- action due to their homogenity are implemented here.
- The only caveat are member methods which are declared as const
- but do change the content. These are documented for that reason.
- The class is designed to provide homogenous coordinates without
- direct access to the homogen part (mfW). This is also the reason
- for leaving out the [] operators which return references to members.
-
- @see B3DTuple
- */
- class B3DHomPoint
- {
- protected:
- /// This member contains the coordinate part of the point
- ::basegfx::tuple::B3DTuple maTuple;
+ protected:
+ /// This member contains the coordinate part of the point
+ ::basegfx::B3DTuple maTuple;
- /// This Member holds the homogenous part of the point
- double mfW;
+ /// This Member holds the homogenous part of the point
+ double mfW;
- /** Test if this homogen point does have a homogenous part
+ /** Test if this homogen point does have a homogenous part
- @return Returns sal_True if this point has no homogenous part
- */
- sal_Bool implIsHomogenized() const
- {
- const double fOne(1.0);
- return ::basegfx::numeric::fTools::equal(mfW, fOne);
- }
+ @return Returns sal_True if this point has no homogenous part
+ */
+ sal_Bool implIsHomogenized() const
+ {
+ const double fOne(1.0);
+ return ::basegfx::fTools::equal(mfW, fOne);
+ }
- /** Remove homogenous part of this Point
+ /** Remove homogenous part of this Point
- This method does necessary calculations to remove
- the evtl. homogenous part of this Point. This may
- change all members.
- */
- void implHomogenize();
+ This method does necessary calculations to remove
+ the evtl. homogenous part of this Point. This may
+ change all members.
+ */
+ void implHomogenize();
- /** Test and on demand remove homogenous part
+ /** Test and on demand remove homogenous part
- This method tests if this Point does have a homogenous part
- and then evtl. takes actions to remove that part.
+ This method tests if this Point does have a homogenous part
+ and then evtl. takes actions to remove that part.
- @attention Even when this method is const it may change all
- members of this instance. This is due to the fact that changing
- the homogenous part of a homogenous point does from a mathematical
- point of view not change the point at all.
- */
- void implTestAndHomogenize() const
- {
- if(!implIsHomogenized())
- ((B3DHomPoint*)this)->implHomogenize();
- }
+ @attention Even when this method is const it may change all
+ members of this instance. This is due to the fact that changing
+ the homogenous part of a homogenous point does from a mathematical
+ point of view not change the point at all.
+ */
+ void implTestAndHomogenize() const
+ {
+ if(!implIsHomogenized())
+ ((B3DHomPoint*)this)->implHomogenize();
+ }
- public:
- /** Create a homogen point
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the Point. The homogenous part is initialized to 1.0.
- */
- B3DHomPoint(double fVal = 0.0)
- : maTuple(fVal),
- mfW(1.0)
- {}
-
- /** Create a homogen point
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the Point. The homogenous part is initialized to 1.0.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the Point. The homogenous part is initialized to 1.0.
-
- @param fZ
- This parameter is used to initialize the Z-coordinate
- of the Point. The homogenous part is initialized to 1.0.
- */
- B3DHomPoint(double fX, double fY, double fZ)
- : maTuple(fX, fY, fZ),
- mfW(1.0)
- {}
-
- /** Create a copy of a 3D Point
-
- @param rVec
- The 3D point which will be copied. The homogenous part
- is initialized to 1.0.
- */
- B3DHomPoint(const B3DPoint& rVec)
- : maTuple(rVec),
- mfW(1.0)
- {}
-
- /** Create a copy of a homogen point
-
- @param rVec
- The homogen point which will be copied. The homogenous part
- is copied, too.
- */
- B3DHomPoint(const B3DHomPoint& rVec)
- : maTuple(rVec.maTuple.getX(), rVec.maTuple.getY(), rVec.maTuple.getZ()),
- mfW(rVec.mfW)
- {}
-
- ~B3DHomPoint()
- {}
-
- /** get a 3D point from this homogenous point
-
- This method normalizes this homogen point if necessary and
- returns the corresponding 3D point for this homogen point.
-
- @attention Even when this method is const it may change all
- members of this instance.
- */
- B3DPoint getB3DPoint() const
- {
- implTestAndHomogenize();
- return B3DPoint(maTuple.getX(), maTuple.getY(), maTuple.getZ());
- }
+ public:
+ /** Create a homogen point
- /** get X-coordinate
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the Point. The homogenous part is initialized to 1.0.
+ */
+ B3DHomPoint(double fVal = 0.0)
+ : maTuple(fVal),
+ mfW(1.0)
+ {}
- This method normalizes this homogen point if necessary and
- returns the corresponding X-coordinate for this homogen point.
+ /** Create a homogen point
- @attention Even when this method is const it may change all
- members of this instance.
- */
- double getX() const
- {
- implTestAndHomogenize();
- return maTuple.getX();
- }
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the Point. The homogenous part is initialized to 1.0.
- /** get Y-coordinate
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the Point. The homogenous part is initialized to 1.0.
- This method normalizes this homogen point if necessary and
- returns the corresponding Y-coordinate for this homogen point.
+ @param fZ
+ This parameter is used to initialize the Z-coordinate
+ of the Point. The homogenous part is initialized to 1.0.
+ */
+ B3DHomPoint(double fX, double fY, double fZ)
+ : maTuple(fX, fY, fZ),
+ mfW(1.0)
+ {}
- @attention Even when this method is const it may change all
- members of this instance.
- */
- double getY() const
- {
- implTestAndHomogenize();
- return maTuple.getY();
- }
+ /** Create a copy of a 3D Point
- /** get Z-coordinate
+ @param rVec
+ The 3D point which will be copied. The homogenous part
+ is initialized to 1.0.
+ */
+ B3DHomPoint(const B3DPoint& rVec)
+ : maTuple(rVec),
+ mfW(1.0)
+ {}
- This method normalizes this homogen point if necessary and
- returns the corresponding Z-coordinate for this homogen point.
+ /** Create a copy of a homogen point
- @attention Even when this method is const it may change all
- members of this instance.
- */
- double getZ() const
- {
- implTestAndHomogenize();
- return maTuple.getY();
- }
+ @param rVec
+ The homogen point which will be copied. The homogenous part
+ is copied, too.
+ */
+ B3DHomPoint(const B3DHomPoint& rVec)
+ : maTuple(rVec.maTuple.getX(), rVec.maTuple.getY(), rVec.maTuple.getZ()),
+ mfW(rVec.mfW)
+ {}
- /** Set X-coordinate of the homogen point.
+ ~B3DHomPoint()
+ {}
- This method sets the X-coordinate of the homogen point. If
- the point does have a homogenous part this is taken into account.
+ /** get a 3D point from this homogenous point
- @param fX
- The to-be-set X-coordinate without homogenous part.
- */
- void setX(double fX)
- {
- maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
- }
+ This method normalizes this homogen point if necessary and
+ returns the corresponding 3D point for this homogen point.
- /** Set Y-coordinate of the homogen point.
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ B3DPoint getB3DPoint() const
+ {
+ implTestAndHomogenize();
+ return B3DPoint(maTuple.getX(), maTuple.getY(), maTuple.getZ());
+ }
- This method sets the Y-coordinate of the homogen point. If
- the point does have a homogenous part this is taken into account.
+ /** get X-coordinate
- @param fY
- The to-be-set Y-coordinate without homogenous part.
- */
- void setY(double fY)
- {
- maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
- }
+ This method normalizes this homogen point if necessary and
+ returns the corresponding X-coordinate for this homogen point.
- /** Set Z-coordinate of the homogen point.
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ double getX() const
+ {
+ implTestAndHomogenize();
+ return maTuple.getX();
+ }
- This method sets the Z-coordinate of the homogen point. If
- the point does have a homogenous part this is taken into account.
+ /** get Y-coordinate
- @param fZ
- The to-be-set Z-coordinate without homogenous part.
- */
- void setZ(double fZ)
- {
- maTuple.setZ(implIsHomogenized() ? fZ : fZ * mfW );
- }
+ This method normalizes this homogen point if necessary and
+ returns the corresponding Y-coordinate for this homogen point.
- // operators
- //////////////////////////////////////////////////////////////////////
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ double getY() const
+ {
+ implTestAndHomogenize();
+ return maTuple.getY();
+ }
- B3DHomPoint& operator+=( const B3DHomPoint& rPnt )
- {
- maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
- maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
- maTuple.setZ(getZ() * rPnt.mfW + rPnt.getZ() * mfW);
- mfW = mfW * rPnt.mfW;
+ /** get Z-coordinate
- return *this;
- }
+ This method normalizes this homogen point if necessary and
+ returns the corresponding Z-coordinate for this homogen point.
- B3DHomPoint& operator-=( const B3DHomPoint& rPnt )
- {
- maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
- maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
- maTuple.setZ(getZ() * rPnt.mfW - rPnt.getZ() * mfW);
- mfW = mfW * rPnt.mfW;
+ @attention Even when this method is const it may change all
+ members of this instance.
+ */
+ double getZ() const
+ {
+ implTestAndHomogenize();
+ return maTuple.getY();
+ }
- return *this;
- }
+ /** Set X-coordinate of the homogen point.
- B3DHomPoint& operator*=(double t)
- {
- if(!::basegfx::numeric::fTools::equalZero(t))
- {
- mfW /= t;
- }
+ This method sets the X-coordinate of the homogen point. If
+ the point does have a homogenous part this is taken into account.
- return *this;
- }
-
- B3DHomPoint& operator/=(double t)
- {
- mfW *= t;
- return *this;
- }
+ @param fX
+ The to-be-set X-coordinate without homogenous part.
+ */
+ void setX(double fX)
+ {
+ maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
+ }
- B3DHomPoint& operator-(void)
- {
- mfW = -mfW;
- return *this;
- }
+ /** Set Y-coordinate of the homogen point.
- sal_Bool operator==( const B3DHomPoint& rPnt ) const
- {
- implTestAndHomogenize();
- return (maTuple == rPnt.maTuple);
- }
+ This method sets the Y-coordinate of the homogen point. If
+ the point does have a homogenous part this is taken into account.
- sal_Bool operator!=( const B3DHomPoint& rPnt ) const
- {
- implTestAndHomogenize();
- return (maTuple != rPnt.maTuple);
- }
+ @param fY
+ The to-be-set Y-coordinate without homogenous part.
+ */
+ void setY(double fY)
+ {
+ maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
+ }
- B3DHomPoint& operator=( const B3DHomPoint& rPnt )
- {
- maTuple = rPnt.maTuple;
- mfW = rPnt.mfW;
- return *this;
- }
- };
+ /** Set Z-coordinate of the homogen point.
- // external operators
- //////////////////////////////////////////////////////////////////////////
+ This method sets the Z-coordinate of the homogen point. If
+ the point does have a homogenous part this is taken into account.
- inline B3DHomPoint min(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ @param fZ
+ The to-be-set Z-coordinate without homogenous part.
+ */
+ void setZ(double fZ)
{
- B3DHomPoint aMin(
- (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
- (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
- (rVecB.getZ() < rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
- return aMin;
+ maTuple.setZ(implIsHomogenized() ? fZ : fZ * mfW );
}
- inline B3DHomPoint max(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
- {
- B3DHomPoint aMax(
- (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
- (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
- (rVecB.getZ() > rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
- return aMax;
- }
+ // operators
+ //////////////////////////////////////////////////////////////////////
- inline B3DHomPoint abs(const B3DHomPoint& rVec)
+ B3DHomPoint& operator+=( const B3DHomPoint& rPnt )
{
- B3DHomPoint aAbs(
- (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
- (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY(),
- (0.0 > rVec.getZ()) ? -rVec.getZ() : rVec.getZ());
- return aAbs;
- }
+ maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
+ maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
+ maTuple.setZ(getZ() * rPnt.mfW + rPnt.getZ() * mfW);
+ mfW = mfW * rPnt.mfW;
- inline B3DHomPoint interpolate(B3DHomPoint& rOld1, B3DHomPoint& rOld2, double t)
- {
- B3DHomPoint aInt(
- ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
- ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
- ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
- return aInt;
+ return *this;
}
- inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2)
+ B3DHomPoint& operator-=( const B3DHomPoint& rPnt )
{
- B3DHomPoint aAvg(
- (rOld1.getX() + rOld2.getX()) * 0.5,
- (rOld1.getY() + rOld2.getY()) * 0.5,
- (rOld1.getZ() + rOld2.getZ()) * 0.5);
- return aAvg;
- }
+ maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
+ maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
+ maTuple.setZ(getZ() * rPnt.mfW - rPnt.getZ() * mfW);
+ mfW = mfW * rPnt.mfW;
- inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2, B3DHomPoint& rOld3)
- {
- B3DHomPoint aAvg(
- (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
- (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
- (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
- return aAvg;
+ return *this;
}
- inline B3DHomPoint operator+(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ B3DHomPoint& operator*=(double t)
{
- B3DHomPoint aSum(rVecA);
- aSum += rVecB;
- return aSum;
+ if(!::basegfx::fTools::equalZero(t))
+ {
+ mfW /= t;
+ }
+
+ return *this;
}
- inline B3DHomPoint operator-(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ B3DHomPoint& operator/=(double t)
{
- B3DHomPoint aSub(rVecA);
- aSub -= rVecB;
- return aSub;
+ mfW *= t;
+ return *this;
}
- inline B3DHomPoint operator*(const B3DHomPoint& rVec, double t)
+ B3DHomPoint& operator-(void)
{
- B3DHomPoint aNew(rVec);
- aNew *= t;
- return aNew;
+ mfW = -mfW;
+ return *this;
}
- inline B3DHomPoint operator*(double t, const B3DHomPoint& rVec)
+ sal_Bool operator==( const B3DHomPoint& rPnt ) const
{
- B3DHomPoint aNew(rVec);
- aNew *= t;
- return aNew;
+ implTestAndHomogenize();
+ return (maTuple == rPnt.maTuple);
}
- inline B3DHomPoint operator/(const B3DHomPoint& rVec, double t)
+ sal_Bool operator!=( const B3DHomPoint& rPnt ) const
{
- B3DHomPoint aNew(rVec);
- aNew /= t;
- return aNew;
+ implTestAndHomogenize();
+ return (maTuple != rPnt.maTuple);
}
- inline B3DHomPoint operator/(double t, const B3DHomPoint& rVec)
+ B3DHomPoint& operator=( const B3DHomPoint& rPnt )
{
- B3DHomPoint aNew(rVec);
- aNew /= t;
- return aNew;
+ maTuple = rPnt.maTuple;
+ mfW = rPnt.mfW;
+ return *this;
}
- } // end of namespace point
+ };
+
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
+
+ inline B3DHomPoint min(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ {
+ B3DHomPoint aMin(
+ (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+ (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
+ (rVecB.getZ() < rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
+ return aMin;
+ }
+
+ inline B3DHomPoint max(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ {
+ B3DHomPoint aMax(
+ (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+ (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
+ (rVecB.getZ() > rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
+ return aMax;
+ }
+
+ inline B3DHomPoint abs(const B3DHomPoint& rVec)
+ {
+ B3DHomPoint aAbs(
+ (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
+ (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY(),
+ (0.0 > rVec.getZ()) ? -rVec.getZ() : rVec.getZ());
+ return aAbs;
+ }
+
+ inline B3DHomPoint interpolate(B3DHomPoint& rOld1, B3DHomPoint& rOld2, double t)
+ {
+ B3DHomPoint aInt(
+ ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
+ ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
+ ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
+ return aInt;
+ }
+
+ inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2)
+ {
+ B3DHomPoint aAvg(
+ (rOld1.getX() + rOld2.getX()) * 0.5,
+ (rOld1.getY() + rOld2.getY()) * 0.5,
+ (rOld1.getZ() + rOld2.getZ()) * 0.5);
+ return aAvg;
+ }
+
+ inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2, B3DHomPoint& rOld3)
+ {
+ B3DHomPoint aAvg(
+ (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
+ (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
+ (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
+ return aAvg;
+ }
+
+ inline B3DHomPoint operator+(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ {
+ B3DHomPoint aSum(rVecA);
+ aSum += rVecB;
+ return aSum;
+ }
+
+ inline B3DHomPoint operator-(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+ {
+ B3DHomPoint aSub(rVecA);
+ aSub -= rVecB;
+ return aSub;
+ }
+
+ inline B3DHomPoint operator*(const B3DHomPoint& rVec, double t)
+ {
+ B3DHomPoint aNew(rVec);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B3DHomPoint operator*(double t, const B3DHomPoint& rVec)
+ {
+ B3DHomPoint aNew(rVec);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B3DHomPoint operator/(const B3DHomPoint& rVec, double t)
+ {
+ B3DHomPoint aNew(rVec);
+ aNew /= t;
+ return aNew;
+ }
+
+ inline B3DHomPoint operator/(double t, const B3DHomPoint& rVec)
+ {
+ B3DHomPoint aNew(rVec);
+ aNew /= t;
+ return aNew;
+ }
} // end of namespace basegfx
#endif // _BGFX_POINT_B3DHOMPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b3dpoint.hxx b/basegfx/inc/basegfx/point/b3dpoint.hxx
index 7f444b850234..06a4b7e346e1 100644
--- a/basegfx/inc/basegfx/point/b3dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dpoint.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpoint.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:54 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,116 +68,110 @@
namespace basegfx
{
- namespace matrix
- {
- // predeclaration
- class B3DHomMatrix;
- } // end of namespace matrix;
+ // predeclaration
+ class B3DHomMatrix;
+
+ /** Base Point class with three double values
- namespace point
+ This class derives all operators and common handling for
+ a 3D data class from B3DTuple. All necessary extensions
+ which are special for points will be added here.
+
+ @see B3DTuple
+ */
+ class B3DPoint : public ::basegfx::B3DTuple
{
- /** Base Point class with three double values
+ public:
+ /** Create a 3D Point
+
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 3D Point.
+ */
+ B3DPoint(double fVal = 0.0)
+ : B3DTuple(fVal)
+ {}
+
+ /** Create a 3D Point
+
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 3D Point.
- This class derives all operators and common handling for
- a 3D data class from B3DTuple. All necessary extensions
- which are special for points will be added here.
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 3D Point.
- @see B3DTuple
+ @param fZ
+ This parameter is used to initialize the Z-coordinate
+ of the 3D Point.
*/
- class B3DPoint : public ::basegfx::tuple::B3DTuple
+ B3DPoint(double fX, double fY, double fZ)
+ : B3DTuple(fX, fY, fZ)
+ {}
+
+ /** Create a copy of a 3D Point
+
+ @param rVec
+ The 3D Point which will be copied.
+ */
+ B3DPoint(const B3DPoint& rVec)
+ : B3DTuple(rVec)
+ {}
+
+ /** constructor with tuple to allow copy-constructing
+ from B3DTuple-based classes
+ */
+ B3DPoint(const ::basegfx::B3DTuple& rTuple)
+ : B3DTuple(rTuple)
+ {}
+
+ ~B3DPoint()
+ {}
+
+ /** *=operator to allow usage from B3DPoint, too
+ */
+ B3DPoint& operator*=( const B3DPoint& rPnt )
+ {
+ mfX *= rPnt.mfX;
+ mfY *= rPnt.mfY;
+ mfZ *= rPnt.mfZ;
+ return *this;
+ }
+
+ /** *=operator to allow usage from B3DPoint, too
+ */
+ B3DPoint& operator*=(double t)
+ {
+ mfX *= t;
+ mfY *= t;
+ mfZ *= t;
+ return *this;
+ }
+
+ /** assignment operator to allow assigning the results
+ of B3DTuple calculations
+ */
+ B3DPoint& operator=( const ::basegfx::B3DTuple& rVec )
+ {
+ mfX = rVec.getX();
+ mfY = rVec.getY();
+ mfZ = rVec.getZ();
+ return *this;
+ }
+
+ /** Transform point by given transformation matrix.
+
+ The translational components of the matrix are, in
+ contrast to B3DVector, applied.
+ */
+ B3DPoint& operator*=( const ::basegfx::B3DHomMatrix& rMat );
+
+ static const B3DPoint& getEmptyPoint()
{
- public:
- /** Create a 3D Point
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 3D Point.
- */
- B3DPoint(double fVal = 0.0)
- : B3DTuple(fVal)
- {}
-
- /** Create a 3D Point
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 3D Point.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 3D Point.
-
- @param fZ
- This parameter is used to initialize the Z-coordinate
- of the 3D Point.
- */
- B3DPoint(double fX, double fY, double fZ)
- : B3DTuple(fX, fY, fZ)
- {}
-
- /** Create a copy of a 3D Point
-
- @param rVec
- The 3D Point which will be copied.
- */
- B3DPoint(const B3DPoint& rVec)
- : B3DTuple(rVec)
- {}
-
- /** constructor with tuple to allow copy-constructing
- from B3DTuple-based classes
- */
- B3DPoint(const ::basegfx::tuple::B3DTuple& rTuple)
- : B3DTuple(rTuple)
- {}
-
- ~B3DPoint()
- {}
-
- /** *=operator to allow usage from B3DPoint, too
- */
- B3DPoint& operator*=( const B3DPoint& rPnt )
- {
- mfX *= rPnt.mfX;
- mfY *= rPnt.mfY;
- mfZ *= rPnt.mfZ;
- return *this;
- }
-
- /** *=operator to allow usage from B3DPoint, too
- */
- B3DPoint& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- mfZ *= t;
- return *this;
- }
-
- /** assignment operator to allow assigning the results
- of B3DTuple calculations
- */
- B3DPoint& operator=( const ::basegfx::tuple::B3DTuple& rVec )
- {
- mfX = rVec.getX();
- mfY = rVec.getY();
- mfZ = rVec.getZ();
- return *this;
- }
-
- /** Transform point by given transformation matrix.
-
- The translational components of the matrix are, in
- contrast to B3DVector, applied.
- */
- B3DPoint& operator*=( const ::basegfx::matrix::B3DHomMatrix& rMat );
-
- static const B3DPoint& getEmptyPoint()
- {
- return (const B3DPoint&) ::basegfx::tuple::B3DTuple::getEmptyTuple();
- }
- };
- } // end of namespace point
+ return (const B3DPoint&) ::basegfx::B3DTuple::getEmptyTuple();
+ }
+ };
} // end of namespace basegfx
#endif // _BGFX_POINT_B3DPOINT_HXX
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
index c58be040d447..610ce5c75df6 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygon.hxx,v $
*
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:56 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:52 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -72,101 +72,83 @@ class ImplB2DPolygon;
namespace basegfx
{
- namespace polygon
- {
- class B2DPolygon;
- } // end of namespace polygon
-
- namespace point
- {
- class B2DPoint;
- } // end of namespace point
-
- namespace vector
- {
- class B2DVector;
- } // end of namespace vector
-
- namespace matrix
- {
- class B2DHomMatrix;
- } // end of namespace matrix
+ class B2DPolygon;
+ class B2DPoint;
+ class B2DVector;
+ class B2DHomMatrix;
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
- namespace polygon
+ class B2DPolygon
{
- class B2DPolygon
- {
- private:
- // internal data.
- ImplB2DPolygon* mpPolygon;
-
- // internal method to force a ref-counted instance to be copied
- // to a modifyable unique copy.
- void implForceUniqueCopy();
-
- public:
- B2DPolygon();
- B2DPolygon(const B2DPolygon& rPolygon);
- B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount);
- ~B2DPolygon();
-
- // assignment operator
- B2DPolygon& operator=(const B2DPolygon& rPolygon);
-
- // compare operators
- sal_Bool operator==(const B2DPolygon& rPolygon) const;
- sal_Bool operator!=(const B2DPolygon& rPolygon) const;
-
- // member count
- sal_uInt32 count() const;
-
- // Coordinate interface
- ::basegfx::point::B2DPoint getB2DPoint(sal_uInt32 nIndex) const;
- void setB2DPoint(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue);
-
- // Coordinate insert/append
- void insert(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount = 1);
- void append(const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount = 1);
-
- // ControlVector interface
- ::basegfx::vector::B2DVector getControlVectorA(sal_uInt32 nIndex) const;
- void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue);
- ::basegfx::vector::B2DVector getControlVectorB(sal_uInt32 nIndex) const;
- void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue);
- sal_Bool areControlPointsUsed() const;
-
- // insert/append other 2D polygons
- void insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2 = 0, sal_uInt32 nCount = 0);
- void append(const B2DPolygon& rPoly, sal_uInt32 nIndex = 0, sal_uInt32 nCount = 0);
-
- // remove
- void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
-
- // clear all points
- void clear();
-
- // closed state
- sal_Bool isClosed() const;
- void setClosed(sal_Bool bNew);
-
- // flip polygon direction
- void flip();
-
- // test if Polygon has double points
- sal_Bool hasDoublePoints() const;
-
- // remove double points, at the begin/end and follow-ups, too
- void removeDoublePoints();
-
- // apply transformation given in matrix form to the polygon
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix);
- };
- } // end of namespace polygon
+ private:
+ // internal data.
+ ImplB2DPolygon* mpPolygon;
+
+ // internal method to force a ref-counted instance to be copied
+ // to a modifyable unique copy.
+ void implForceUniqueCopy();
+
+ public:
+ B2DPolygon();
+ B2DPolygon(const B2DPolygon& rPolygon);
+ B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount);
+ ~B2DPolygon();
+
+ // assignment operator
+ B2DPolygon& operator=(const B2DPolygon& rPolygon);
+
+ // compare operators
+ sal_Bool operator==(const B2DPolygon& rPolygon) const;
+ sal_Bool operator!=(const B2DPolygon& rPolygon) const;
+
+ // member count
+ sal_uInt32 count() const;
+
+ // Coordinate interface
+ ::basegfx::B2DPoint getB2DPoint(sal_uInt32 nIndex) const;
+ void setB2DPoint(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue);
+
+ // Coordinate insert/append
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount = 1);
+ void append(const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount = 1);
+
+ // ControlVector interface
+ ::basegfx::B2DVector getControlVectorA(sal_uInt32 nIndex) const;
+ void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue);
+ ::basegfx::B2DVector getControlVectorB(sal_uInt32 nIndex) const;
+ void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue);
+ sal_Bool areControlPointsUsed() const;
+
+ // insert/append other 2D polygons
+ void insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2 = 0, sal_uInt32 nCount = 0);
+ void append(const B2DPolygon& rPoly, sal_uInt32 nIndex = 0, sal_uInt32 nCount = 0);
+
+ // remove
+ void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
+
+ // clear all points
+ void clear();
+
+ // closed state
+ sal_Bool isClosed() const;
+ void setClosed(sal_Bool bNew);
+
+ // flip polygon direction
+ void flip();
+
+ // test if Polygon has double points
+ sal_Bool hasDoublePoints() const;
+
+ // remove double points, at the begin/end and follow-ups, too
+ void removeDoublePoints();
+
+ // apply transformation given in matrix form to the polygon
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix);
+ };
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
index b2fc5f9c16e5..4da9f650a526 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygontools.hxx,v $
*
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:56 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,148 +70,137 @@
#include <basegfx/vector/b2dvector.hxx>
#endif
+#include <vector>
+
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
// predefinitions
- namespace polygon
- {
- class B2DPolygon;
- } // end of namespace polygon
-
- // predefinitions
- namespace range
- {
- class B2DRange;
- } // end of namespace range
+ class B2DPolygon;
+ class B2DRange;
- namespace polygon
+ namespace tools
{
- namespace tools
- {
- // B2DPolygon tools
-
- /** Check if given polygon is closed. This is kind of a
- 'classic' method to support old polygon definitions.
- Those old polygon definitions define the closed state
- of the polygon using identical start and endpoints. This
- method corrects this (removes double start/end points)
- and sets the Closed()-state of the polygon correctly.
- */
- void checkClosed(::basegfx::polygon::B2DPolygon& rCandidate);
-
- // Get index of outmost point (e.g. biggest X and biggest Y)
- sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // Get successor and predecessor indices. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate);
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // Get index of first different predecessor. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate);
- sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // Get orientation of Polygon
- ::basegfx::vector::B2DVectorOrientation getOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // isInside tests for B2dPoint and other B2dPolygon. On border is not inside as long as
- // not sal_True is given in bWithBorder flag.
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::point::B2DPoint& rPoint, sal_Bool bWithBorder = sal_False);
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::polygon::B2DPolygon& rPolygon, sal_Bool bWithBorder = sal_False);
-
- // get size of polygon. Control vectors are included in that ranges.
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // get area of polygon
- double getArea(const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // get length of polygon edge from point nIndex to nIndex + 1
- double getEdgeLength(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex);
-
- // get length of polygon
- double getLength(const ::basegfx::polygon::B2DPolygon& rCandidate);
-
- // get position on polygon for absolute given distance. If
- // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
- // using getLength(...)
- ::basegfx::point::B2DPoint getPositionAbsolute(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
-
- // get position on polygon for relative given distance in range [0.0 .. 1.0]. If
- // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
- // using getLength(...)
- ::basegfx::point::B2DPoint getPositionRelative(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
-
- // get orientation at given polygon point
- ::basegfx::vector::B2DVectorOrientation getPointOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex);
-
- // Continuity check for point with given index
- ::basegfx::vector::B2DVectorContinuity getContinuityInPoint(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex);
-
- // Subdivide all contained curves. Use distanceBound value if given.
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistanceBound = 0.0);
-
- // Subdivide all contained curves. Use distanceBound value if given.
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolygon& rCandidate, double fAngleBound = 5.0);
-
- // Definitions for the cut flags used from the findCut methods
- typedef sal_uInt16 CutFlagValue;
-
- #define CUTFLAG_NONE (0x0000)
- #define CUTFLAG_LINE (0x0001)
- #define CUTFLAG_START1 (0x0002)
- #define CUTFLAG_START2 (0x0004)
- #define CUTFLAG_END1 (0x0008)
- #define CUTFLAG_END2 (0x0010)
- #define CUTFLAG_ALL (CUTFLAG_LINE|CUTFLAG_START1|CUTFLAG_START2|CUTFLAG_END1|CUTFLAG_END2)
- #define CUTFLAG_DEFAULT (CUTFLAG_LINE|CUTFLAG_START2|CUTFLAG_END2)
-
- // Calculate cut between the points given by the two indices. pCut1
- // and pCut2 will contain the cut coordinate on each edge in ]0.0, 1.0]
- // (if given) and the return value will contain a cut description.
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate,
- sal_uInt32 nIndex1, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
- double* pCut1 = 0L, double* pCut2 = 0L);
-
- // This version is working with two indexed edges from different
- // polygons.
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
- const ::basegfx::polygon::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
- double* pCut1 = 0L, double* pCut2 = 0L);
-
- // This version works with two points and vectors to define the
- // edges for the cut test.
- CutFlagValue findCut(
- const ::basegfx::point::B2DPoint& rEdge1Start, const ::basegfx::vector::B2DVector& rEdge1Delta,
- const ::basegfx::point::B2DPoint& rEdge2Start, const ::basegfx::vector::B2DVector& rEdge2Delta,
- CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
- double* pCut1 = 0L, double* pCut2 = 0L);
-
- // test if point is on the given edge in range ]0.0..1.0[ without
- // the start/end points. If so, return sal_True and put the parameter
- // value in pCut (if provided)
- sal_Bool isPointOnEdge(
- const ::basegfx::point::B2DPoint& rPoint,
- const ::basegfx::point::B2DPoint& rEdgeStart,
- const ::basegfx::vector::B2DVector& rEdgeDelta,
- double* pCut = 0L);
-
-
-
- /* Still missing:
- void transform(const Matrix4D& rTfMatrix);
- Polygon3D getExpandedPolygon(sal_uInt32 nNum);
- */
-
-
- } // end of namespace tools
- } // end of namespace polygon
+ // B2DPolygon tools
+
+ /** Check if given polygon is closed. This is kind of a
+ 'classic' method to support old polygon definitions.
+ Those old polygon definitions define the closed state
+ of the polygon using identical start and endpoints. This
+ method corrects this (removes double start/end points)
+ and sets the Closed()-state of the polygon correctly.
+ */
+ void checkClosed(::basegfx::B2DPolygon& rCandidate);
+
+ // Get index of outmost point (e.g. biggest X and biggest Y)
+ sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::B2DPolygon& rCandidate);
+
+ // Get successor and predecessor indices. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate);
+ sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate);
+
+ // Get index of first different predecessor. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate);
+ sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate);
+
+ // Get orientation of Polygon
+ ::basegfx::B2DVectorOrientation getOrientation(const ::basegfx::B2DPolygon& rCandidate);
+
+ // isInside tests for B2dPoint and other B2dPolygon. On border is not inside as long as
+ // not sal_True is given in bWithBorder flag.
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPoint& rPoint, sal_Bool bWithBorder = sal_False);
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPolygon& rPolygon, sal_Bool bWithBorder = sal_False);
+
+ // get size of polygon. Control vectors are included in that ranges.
+ ::basegfx::B2DRange getRange(const ::basegfx::B2DPolygon& rCandidate);
+
+ // get area of polygon
+ double getArea(const ::basegfx::B2DPolygon& rCandidate);
+
+ // get length of polygon edge from point nIndex to nIndex + 1
+ double getEdgeLength(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex);
+
+ // get length of polygon
+ double getLength(const ::basegfx::B2DPolygon& rCandidate);
+
+ // get position on polygon for absolute given distance. If
+ // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
+ // using getLength(...)
+ ::basegfx::B2DPoint getPositionAbsolute(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+
+ // get position on polygon for relative given distance in range [0.0 .. 1.0]. If
+ // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
+ // using getLength(...)
+ ::basegfx::B2DPoint getPositionRelative(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+
+ // get orientation at given polygon point
+ ::basegfx::B2DVectorOrientation getPointOrientation(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex);
+
+ // Continuity check for point with given index
+ ::basegfx::B2DVectorContinuity getContinuityInPoint(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex);
+
+ // Subdivide all contained curves. Use distanceBound value if given.
+ ::basegfx::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolygon& rCandidate, double fDistanceBound = 0.0);
+
+ // Subdivide all contained curves. Use distanceBound value if given.
+ ::basegfx::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolygon& rCandidate, double fAngleBound = 5.0);
+
+ // Definitions for the cut flags used from the findCut methods
+ typedef sal_uInt16 CutFlagValue;
+
+ #define CUTFLAG_NONE (0x0000)
+ #define CUTFLAG_LINE (0x0001)
+ #define CUTFLAG_START1 (0x0002)
+ #define CUTFLAG_START2 (0x0004)
+ #define CUTFLAG_END1 (0x0008)
+ #define CUTFLAG_END2 (0x0010)
+ #define CUTFLAG_ALL (CUTFLAG_LINE|CUTFLAG_START1|CUTFLAG_START2|CUTFLAG_END1|CUTFLAG_END2)
+ #define CUTFLAG_DEFAULT (CUTFLAG_LINE|CUTFLAG_START2|CUTFLAG_END2)
+
+ // Calculate cut between the points given by the two indices. pCut1
+ // and pCut2 will contain the cut coordinate on each edge in ]0.0, 1.0]
+ // (if given) and the return value will contain a cut description.
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate,
+ sal_uInt32 nIndex1, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
+ double* pCut1 = 0L, double* pCut2 = 0L);
+
+ // This version is working with two indexed edges from different
+ // polygons.
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
+ const ::basegfx::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
+ double* pCut1 = 0L, double* pCut2 = 0L);
+
+ // This version works with two points and vectors to define the
+ // edges for the cut test.
+ CutFlagValue findCut(
+ const ::basegfx::B2DPoint& rEdge1Start, const ::basegfx::B2DVector& rEdge1Delta,
+ const ::basegfx::B2DPoint& rEdge2Start, const ::basegfx::B2DVector& rEdge2Delta,
+ CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
+ double* pCut1 = 0L, double* pCut2 = 0L);
+
+ // test if point is on the given edge in range ]0.0..1.0[ without
+ // the start/end points. If so, return sal_True and put the parameter
+ // value in pCut (if provided)
+ sal_Bool isPointOnEdge(
+ const ::basegfx::B2DPoint& rPoint,
+ const ::basegfx::B2DPoint& rEdgeStart,
+ const ::basegfx::B2DVector& rEdgeDelta,
+ double* pCut = 0L);
+
+
+
+ /* Still missing:
+ void transform(const Matrix4D& rTfMatrix);
+ Polygon3D getExpandedPolygon(sal_uInt32 nNum);
+ */
+ } // end of namespace tools
} // end of namespace basegfx
#endif // _BGFX_POLYGON_B2DPOLYGONTOOLS_HXX
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
index 89e6b68b4072..1bffaee504f4 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygon.hxx,v $
*
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:57 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,84 +71,74 @@ class ImplB2DPolyPolygon;
namespace basegfx
{
- namespace polygon
- {
- class B2DPolygon;
- } // end of namespace polygon
-
- namespace matrix
- {
- class B2DHomMatrix;
- } // end of namespace matrix
+ class B2DPolygon;
+ class B2DHomMatrix;
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
- namespace polygon
+ class B2DPolyPolygon
{
- class B2DPolyPolygon
- {
- private:
- ImplB2DPolyPolygon* mpPolyPolygon;
+ private:
+ ImplB2DPolyPolygon* mpPolyPolygon;
- // internal method to force a ref-counted instance to be copied
- // to a modifyable unique copy.
- void implForceUniqueCopy();
+ // internal method to force a ref-counted instance to be copied
+ // to a modifyable unique copy.
+ void implForceUniqueCopy();
- public:
- B2DPolyPolygon();
- B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon);
- ~B2DPolyPolygon();
+ public:
+ B2DPolyPolygon();
+ B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon);
+ ~B2DPolyPolygon();
- // assignment operator
- B2DPolyPolygon& operator=(const B2DPolyPolygon& rPolyPolygon);
+ // assignment operator
+ B2DPolyPolygon& operator=(const B2DPolyPolygon& rPolyPolygon);
- // compare operators
- sal_Bool operator==(const B2DPolyPolygon& rPolyPolygon) const;
- sal_Bool operator!=(const B2DPolyPolygon& rPolyPolygon) const;
+ // compare operators
+ sal_Bool operator==(const B2DPolyPolygon& rPolyPolygon) const;
+ sal_Bool operator!=(const B2DPolyPolygon& rPolyPolygon) const;
- // polygon interface
- sal_uInt32 count() const;
+ // polygon interface
+ sal_uInt32 count() const;
- B2DPolygon getB2DPolygon(sal_uInt32 nIndex) const;
- void setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon);
+ B2DPolygon getB2DPolygon(sal_uInt32 nIndex) const;
+ void setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon);
- // test for curve
- sal_Bool areControlPointsUsed() const;
+ // test for curve
+ sal_Bool areControlPointsUsed() const;
- // insert/append single polygon
- void insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount = 1);
- void append(const B2DPolygon& rPolygon, sal_uInt32 nCount = 1);
+ // insert/append single polygon
+ void insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount = 1);
+ void append(const B2DPolygon& rPolygon, sal_uInt32 nCount = 1);
- // insert/append multiple polygons
- void insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon);
- void append(const B2DPolyPolygon& rPolyPolygon);
+ // insert/append multiple polygons
+ void insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon);
+ void append(const B2DPolyPolygon& rPolyPolygon);
- // remove
- void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
+ // remove
+ void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
- // reset to empty state
- void clear();
+ // reset to empty state
+ void clear();
- // closed state
- sal_Bool isClosed() const;
- void setClosed(sal_Bool bNew);
+ // closed state
+ sal_Bool isClosed() const;
+ void setClosed(sal_Bool bNew);
- // flip polygon direction
- void flip();
+ // flip polygon direction
+ void flip();
- // test if PolyPolygon has double points
- sal_Bool hasDoublePoints() const;
+ // test if PolyPolygon has double points
+ sal_Bool hasDoublePoints() const;
- // remove double points, at the begin/end and follow-ups, too
- void removeDoublePoints();
+ // remove double points, at the begin/end and follow-ups, too
+ void removeDoublePoints();
- // apply transformation given in matrix form to the polygon
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix);
- };
- } // end of namespace polygon
+ // apply transformation given in matrix form to the polygon
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix);
+ };
} // end of namespace basegfx
#endif // _BGFX_POLYGON_B2DPOLYPOLYGON_HXX
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
index c118076d82fe..641045afa14e 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygoncutter.hxx,v $
*
- * $Revision: 1.2 $
+ * $Revision: 1.3 $
*
- * last change: $Author: aw $ $Date: 2003-11-10 11:45:48 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -93,48 +93,45 @@
namespace basegfx
{
- namespace polygon
+ class B2DPolygonNode
{
- class B2DPolygonNode
- {
- ::basegfx::point::B2DPoint maPosition;
- B2DPolygonNode* mpPrevious;
- B2DPolygonNode* mpNext;
+ ::basegfx::B2DPoint maPosition;
+ B2DPolygonNode* mpPrevious;
+ B2DPolygonNode* mpNext;
- B2DPolygonNode* mpListPrevious;
- B2DPolygonNode* mpListNext;
+ B2DPolygonNode* mpListPrevious;
+ B2DPolygonNode* mpListNext;
- public:
- B2DPolygonNode(const ::basegfx::point::B2DPoint& rPosition, B2DPolygonNode* pPrevious);
- ~B2DPolygonNode();
+ public:
+ B2DPolygonNode(const ::basegfx::B2DPoint& rPosition, B2DPolygonNode* pPrevious);
+ ~B2DPolygonNode();
- B2DPolygonNode* getPrevious() const { return mpPrevious; }
- B2DPolygonNode* getNext() const { return mpNext; }
- const ::basegfx::point::B2DPoint& getPosition() const { return maPosition; }
+ B2DPolygonNode* getPrevious() const { return mpPrevious; }
+ B2DPolygonNode* getNext() const { return mpNext; }
+ const ::basegfx::B2DPoint& getPosition() const { return maPosition; }
- void calcMinMaxX(double& fMaxAX, double& fMinAX) const;
- void calcMinMaxY(double& fMaxAY, double& fMinAY) const;
+ void calcMinMaxX(double& fMaxAX, double& fMinAX) const;
+ void calcMinMaxY(double& fMaxAY, double& fMinAY) const;
- void swapPreviousNext() { B2DPolygonNode* pZwi = mpPrevious; mpPrevious = mpNext; mpNext = pZwi; }
- void swapNextPointers(B2DPolygonNode* pCand);
+ void swapPreviousNext() { B2DPolygonNode* pZwi = mpPrevious; mpPrevious = mpNext; mpNext = pZwi; }
+ void swapNextPointers(B2DPolygonNode* pCand);
- void addToList(B2DPolygonNode*& rpList);
- void remFromList(B2DPolygonNode*& rpList);
+ void addToList(B2DPolygonNode*& rpList);
+ void remFromList(B2DPolygonNode*& rpList);
- sal_Bool getOrientation() const;
- void swapOrientation();
- ::basegfx::range::B2DRange getRange() const;
+ sal_Bool getOrientation() const;
+ void swapOrientation();
+ ::basegfx::B2DRange getRange() const;
- // isInside tests for B2dPoint and other B2DPolygonNode Polygon. On border is not inside as long as
- // not sal_True is given in bWithBorder flag.
- sal_Bool isInside(const ::basegfx::point::B2DPoint& rPnt, sal_Bool bWithBorder = sal_False) const;
- sal_Bool isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder = sal_False) const;
- };
+ // isInside tests for B2dPoint and other B2DPolygonNode Polygon. On border is not inside as long as
+ // not sal_True is given in bWithBorder flag.
+ sal_Bool isInside(const ::basegfx::B2DPoint& rPnt, sal_Bool bWithBorder = sal_False) const;
+ sal_Bool isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder = sal_False) const;
+ };
- // a type definition to have a vector of pointers to B2DPolygonNodes
- typedef ::std::vector< B2DPolygonNode* > B2DPolygonNodeVector;
+ // a type definition to have a vector of pointers to B2DPolygonNodes
+ typedef ::std::vector< B2DPolygonNode* > B2DPolygonNodeVector;
- } // end of namespace polygon
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -142,40 +139,37 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ class B2DSimpleCut
{
- class B2DSimpleCut
+ B2DPolygonNode* mpLeft;
+ B2DPolygonNode* mpRight;
+
+ // bitfield
+ unsigned mbCorrectOrientation : 1;
+ unsigned mbOrientation : 1;
+
+ public:
+ B2DSimpleCut(B2DPolygonNode* pL, B2DPolygonNode* pR, sal_Bool bCoOr = sal_False, sal_Bool bOr = sal_True)
+ : mpLeft(pL),
+ mpRight(pR),
+ mbCorrectOrientation(bCoOr),
+ mbOrientation(bOr)
+ {
+ }
+
+ void solve();
+ B2DPolygonNode* getLeft() const { return mpLeft; }
+ B2DPolygonNode* getRight() const { return mpRight; }
+
+ sal_Bool isSameCut(B2DPolygonNode* pA, B2DPolygonNode* pB) const
{
- B2DPolygonNode* mpLeft;
- B2DPolygonNode* mpRight;
-
- // bitfield
- unsigned mbCorrectOrientation : 1;
- unsigned mbOrientation : 1;
-
- public:
- B2DSimpleCut(B2DPolygonNode* pL, B2DPolygonNode* pR, sal_Bool bCoOr = sal_False, sal_Bool bOr = sal_True)
- : mpLeft(pL),
- mpRight(pR),
- mbCorrectOrientation(bCoOr),
- mbOrientation(bOr)
- {
- }
-
- void solve();
- B2DPolygonNode* getLeft() const { return mpLeft; }
- B2DPolygonNode* getRight() const { return mpRight; }
-
- sal_Bool isSameCut(B2DPolygonNode* pA, B2DPolygonNode* pB) const
- {
- return ((pA == mpLeft && pB == mpRight) || (pB == mpLeft && pA == mpRight));
- }
- };
-
- // a type definition to have a vector of pointers to B2DSimpleCuts
- typedef ::std::vector< B2DSimpleCut* > B2DSimpleCutVector;
-
- } // end of namespace polygon
+ return ((pA == mpLeft && pB == mpRight) || (pB == mpLeft && pA == mpRight));
+ }
+ };
+
+ // a type definition to have a vector of pointers to B2DSimpleCuts
+ typedef ::std::vector< B2DSimpleCut* > B2DSimpleCutVector;
+
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -183,27 +177,24 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ class B2DClipExtraPolygonInfo
{
- class B2DClipExtraPolygonInfo
- {
- ::basegfx::range::B2DRange maRange;
- sal_Int32 mnDepth;
+ ::basegfx::B2DRange maRange;
+ sal_Int32 mnDepth;
- // bitfield
- unsigned mbOrientation : 1;
+ // bitfield
+ unsigned mbOrientation : 1;
- public:
- B2DClipExtraPolygonInfo() {}
+ public:
+ B2DClipExtraPolygonInfo() {}
- void init(B2DPolygonNode* pNew);
- const ::basegfx::range::B2DRange& getRange() const { return maRange; }
- sal_Bool getOrientation() const { return mbOrientation; }
+ void init(B2DPolygonNode* pNew);
+ const ::basegfx::B2DRange& getRange() const { return maRange; }
+ sal_Bool getOrientation() const { return mbOrientation; }
- sal_Int32 getDepth() const { return mnDepth; }
- void changeDepth(sal_Bool bOrientation);
- };
- } // end of namespace polygon
+ sal_Int32 getDepth() const { return mnDepth; }
+ void changeDepth(sal_Bool bOrientation);
+ };
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -211,69 +202,66 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ class B2DPolyPolygonCutter
{
- class B2DPolyPolygonCutter
+ // list of polys
+ B2DPolygonNodeVector maPolygonList;
+ B2DPolyPolygon maNotClosedPolygons;
+
+ // help routines
+ sal_Bool isSamePos(const ::basegfx::B2DPoint& rPntA, const ::basegfx::B2DPoint& rPntB)
+ {
+ return rPntA.equal(rPntB);
+ }
+
+ B2DSimpleCut* getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB);
+ B2DPolygonNode* extractNextPolygon(B2DPolygonNode*& rpList);
+ sal_Bool isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB);
+ sal_Bool isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave);
+
+ sal_Bool isNextSamePos(B2DPolygonNode* pA, B2DPolygonNode* pB)
{
- // list of polys
- B2DPolygonNodeVector maPolygonList;
- B2DPolyPolygon maNotClosedPolygons;
-
- // help routines
- sal_Bool isSamePos(const ::basegfx::point::B2DPoint& rPntA, const ::basegfx::point::B2DPoint& rPntB)
- {
- return rPntA.equal(rPntB);
- }
-
- B2DSimpleCut* getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB);
- B2DPolygonNode* extractNextPolygon(B2DPolygonNode*& rpList);
- sal_Bool isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB);
- sal_Bool isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave);
-
- sal_Bool isNextSamePos(B2DPolygonNode* pA, B2DPolygonNode* pB)
- {
- return isSamePos(pA->getNext()->getPosition(), pB->getNext()->getPosition());
- }
-
- sal_Bool isPrevSamePos(B2DPolygonNode* pA, B2DPolygonNode* pB)
- {
- return isSamePos(pA->getPrevious()->getPosition(), pB->getPrevious()->getPosition());
- }
-
- void addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList);
- B2DPolygonNode* createNewPolygon(const B2DPolygon& rPolygon);
- void deletePolygon(B2DPolygonNode* pCand);
- void polysToList(B2DPolygonNode*& rpList);
- void listToPolys(B2DPolygonNode*& rpList);
-
- sal_Bool doRangesIntersect(const ::basegfx::range::B2DRange& rRange1, const ::basegfx::range::B2DRange& rRange2) const
- {
- return rRange1.overlaps(rRange2);
- }
-
- sal_Bool doRangesInclude(const ::basegfx::range::B2DRange& rRange1, const ::basegfx::range::B2DRange& rRange2) const
- {
- return rRange1.isInside(rRange2);
- }
-
- void solveAllCuts(B2DSimpleCutVector& rCuts);
-
- public:
- B2DPolyPolygonCutter() {}
- ~B2DPolyPolygonCutter();
-
- // put/get poly
- void addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation = sal_False);
- void getPolyPolygon(B2DPolyPolygon& rPolyPolygon);
-
- // transformations
- void removeSelfIntersections();
- void removeDoubleIntersections();
-
- // remove included
- void removeIncludedPolygons(sal_Bool bUseOr = sal_True);
- };
- } // end of namespace polygon
+ return isSamePos(pA->getNext()->getPosition(), pB->getNext()->getPosition());
+ }
+
+ sal_Bool isPrevSamePos(B2DPolygonNode* pA, B2DPolygonNode* pB)
+ {
+ return isSamePos(pA->getPrevious()->getPosition(), pB->getPrevious()->getPosition());
+ }
+
+ void addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList);
+ B2DPolygonNode* createNewPolygon(const B2DPolygon& rPolygon);
+ void deletePolygon(B2DPolygonNode* pCand);
+ void polysToList(B2DPolygonNode*& rpList);
+ void listToPolys(B2DPolygonNode*& rpList);
+
+ sal_Bool doRangesIntersect(const ::basegfx::B2DRange& rRange1, const ::basegfx::B2DRange& rRange2) const
+ {
+ return rRange1.overlaps(rRange2);
+ }
+
+ sal_Bool doRangesInclude(const ::basegfx::B2DRange& rRange1, const ::basegfx::B2DRange& rRange2) const
+ {
+ return rRange1.isInside(rRange2);
+ }
+
+ void solveAllCuts(B2DSimpleCutVector& rCuts);
+
+ public:
+ B2DPolyPolygonCutter() {}
+ ~B2DPolyPolygonCutter();
+
+ // put/get poly
+ void addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation = sal_False);
+ void getPolyPolygon(B2DPolyPolygon& rPolyPolygon);
+
+ // transformations
+ void removeSelfIntersections();
+ void removeDoubleIntersections();
+
+ // remove included
+ void removeIncludedPolygons(sal_Bool bUseOr = sal_True);
+ };
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
index 5165ef6a37ed..f51f64e9ec23 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygontools.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:39:57 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,56 +70,59 @@
#include <basegfx/vector/b2dvector.hxx>
#endif
+#ifndef _BGFX_POLYGON_B2DPOLYGON_HXX
+#include <basegfx/polygon/b2dpolygon.hxx>
+#endif
+
+#include <vector>
+
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
// predefinitions
- namespace polygon
- {
- class B2DPolyPolygon;
- } // end of namespace polygon
+ class B2DPolyPolygon;
+ class B2DRange;
- // predefinitions
- namespace range
+ namespace tools
{
- class B2DRange;
- } // end of namespace range
+ // B2DPolyPolygon tools
- namespace polygon
- {
- namespace tools
- {
- // B2DPolyPolygon tools
-
- // Check and evtl. correct orientations of all contained Polygons so that
- // the orientations of contained polygons will variate to express areas and
- // holes
- void correctOrientations(::basegfx::polygon::B2DPolyPolygon& rCandidate);
-
- // Remove all intersections, the self intersections and the in-between
- // polygon intersections. After this operation there are no more intersections
- // in the given PolyPolygon. Only closed polygons are handled. The non-closed
- // polygons or the ones with less than 3 points are preserved, but not
- // computed.
- // bForceOrientation: If sal_True, the orientations of all contained polygons
- // is changed to ORIENTATION_POSITIVE before computing.
- // bInvertRemove: if sal_True, created polygons which are inside others and
- // have the same orientation are removed (cleanup).
- void removeIntersections(::basegfx::polygon::B2DPolyPolygon& rCandidate,
- sal_Bool bForceOrientation = sal_True, sal_Bool bInvertRemove = sal_False);
-
- // Subdivide all contained curves. Use distanceBound value if given.
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0);
-
- // Subdivide all contained curves. Use distanceBound value if given.
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fAngleBound = 5.0);
-
- // get size of PolyPolygon. Control vectors are included in that ranges.
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolyPolygon& rCandidate);
-
- } // end of namespace tools
- } // end of namespace polygon
+ // Check and evtl. correct orientations of all contained Polygons so that
+ // the orientations of contained polygons will variate to express areas and
+ // holes
+ void correctOrientations(::basegfx::B2DPolyPolygon& rCandidate);
+
+ // Remove all intersections, the self intersections and the in-between
+ // polygon intersections. After this operation there are no more intersections
+ // in the given PolyPolygon. Only closed polygons are handled. The non-closed
+ // polygons or the ones with less than 3 points are preserved, but not
+ // computed.
+ // bForceOrientation: If sal_True, the orientations of all contained polygons
+ // is changed to ORIENTATION_POSITIVE before computing.
+ // bInvertRemove: if sal_True, created polygons which are inside others and
+ // have the same orientation are removed (cleanup).
+ void removeIntersections(::basegfx::B2DPolyPolygon& rCandidate,
+ sal_Bool bForceOrientation = sal_True, sal_Bool bInvertRemove = sal_False);
+
+ // Subdivide all contained curves. Use distanceBound value if given.
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0);
+
+ // Subdivide all contained curves. Use distanceBound value if given.
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolyPolygon& rCandidate, double fAngleBound = 5.0);
+
+ // get size of PolyPolygon. Control vectors are included in that ranges.
+ ::basegfx::B2DRange getRange(const ::basegfx::B2DPolyPolygon& rCandidate);
+
+ // Apply Line Dashing. This cuts every contained PolyPolygon into line pieces
+ // which are inserted as single polygons into the result.
+ ::basegfx::B2DPolyPolygon applyLineDashing(const ::basegfx::B2DPolyPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen);
+
+ // Apply Line Dashing. This cuts the Polygon into line pieces
+ // which are inserted as single polygons into the result.
+ ::basegfx::B2DPolyPolygon applyLineDashing(const ::basegfx::B2DPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen);
+
+ } // end of namespace tools
} // end of namespace basegfx
#endif // _BGFX_POLYPOLYGON_B2DPOLYGONTOOLS_HXX
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
index 4df95083ee57..ef18da4035f9 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolygon.hxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:29:18 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -72,89 +72,75 @@ class ImplB3DPolygon;
namespace basegfx
{
- namespace polygon
- {
- class B3DPolygon;
- } // end of namespace polygon
-
- namespace point
- {
- class B3DPoint;
- } // end of namespace point
-
- namespace matrix
- {
- class B3DHomMatrix;
- } // end of namespace matrix
+ class B3DPolygon;
+ class B3DPoint;
+ class B3DHomMatrix;
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
- namespace polygon
+ class B3DPolygon
{
- class B3DPolygon
- {
- private:
- // internal data.
- ImplB3DPolygon* mpPolygon;
+ private:
+ // internal data.
+ ImplB3DPolygon* mpPolygon;
- // internal method to force a ref-counted instance to be copied
- // to a modifyable unique copy.
- void implForceUniqueCopy();
+ // internal method to force a ref-counted instance to be copied
+ // to a modifyable unique copy.
+ void implForceUniqueCopy();
- public:
- B3DPolygon();
- B3DPolygon(const B3DPolygon& rPolygon);
- B3DPolygon(const B3DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount);
- ~B3DPolygon();
+ public:
+ B3DPolygon();
+ B3DPolygon(const B3DPolygon& rPolygon);
+ B3DPolygon(const B3DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount);
+ ~B3DPolygon();
- // assignment operator
- B3DPolygon& operator=(const B3DPolygon& rPolygon);
+ // assignment operator
+ B3DPolygon& operator=(const B3DPolygon& rPolygon);
- // compare operators
- sal_Bool operator==(const B3DPolygon& rPolygon) const;
- sal_Bool operator!=(const B3DPolygon& rPolygon) const;
+ // compare operators
+ sal_Bool operator==(const B3DPolygon& rPolygon) const;
+ sal_Bool operator!=(const B3DPolygon& rPolygon) const;
- // member count
- sal_uInt32 count() const;
+ // member count
+ sal_uInt32 count() const;
- // Coordinate interface
- ::basegfx::point::B3DPoint getB3DPoint(sal_uInt32 nIndex) const;
- void setB3DPoint(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rValue);
+ // Coordinate interface
+ ::basegfx::B3DPoint getB3DPoint(sal_uInt32 nIndex) const;
+ void setB3DPoint(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue);
- // Coordinate insert/append
- void insert(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rPoint, sal_uInt32 nCount = 1);
- void append(const ::basegfx::point::B3DPoint& rPoint, sal_uInt32 nCount = 1);
+ // Coordinate insert/append
+ void insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount = 1);
+ void append(const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount = 1);
- // insert/append other 2D polygons
- void insert(sal_uInt32 nIndex, const B3DPolygon& rPoly, sal_uInt32 nIndex2 = 0, sal_uInt32 nCount = 0);
- void append(const B3DPolygon& rPoly, sal_uInt32 nIndex = 0, sal_uInt32 nCount = 0);
+ // insert/append other 2D polygons
+ void insert(sal_uInt32 nIndex, const B3DPolygon& rPoly, sal_uInt32 nIndex2 = 0, sal_uInt32 nCount = 0);
+ void append(const B3DPolygon& rPoly, sal_uInt32 nIndex = 0, sal_uInt32 nCount = 0);
- // remove
- void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
+ // remove
+ void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
- // clear all points
- void clear();
+ // clear all points
+ void clear();
- // closed state
- sal_Bool isClosed() const;
- void setClosed(sal_Bool bNew);
+ // closed state
+ sal_Bool isClosed() const;
+ void setClosed(sal_Bool bNew);
- // flip polygon direction
- void flip();
+ // flip polygon direction
+ void flip();
- // test if Polygon has double points
- sal_Bool hasDoublePoints() const;
+ // test if Polygon has double points
+ sal_Bool hasDoublePoints() const;
- // remove double points, at the begin/end and follow-ups, too
- void removeDoublePoints();
+ // remove double points, at the begin/end and follow-ups, too
+ void removeDoublePoints();
- // apply transformation given in matrix form to the polygon
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix);
- };
- } // end of namespace polygon
+ // apply transformation given in matrix form to the polygon
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix);
+ };
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
index 7536de67bb21..e8d71b52197d 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolygontools.hxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:29:20 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:54 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,68 +70,67 @@
#include <basegfx/vector/b3dvector.hxx>
#endif
+#ifndef _BGFX_POLYGON_B3DPOLYPOLYGON_HXX
+#include <basegfx/polygon/b3dpolypolygon.hxx>
+#endif
+
+#include <vector>
+
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
// predefinitions
- namespace polygon
- {
- class B3DPolygon;
- } // end of namespace polygon
-
- // predefinitions
- namespace range
- {
- class B3DRange;
- } // end of namespace range
+ class B3DPolygon;
+ class B3DRange;
- namespace polygon
+ namespace tools
{
- namespace tools
- {
- // B3DPolygon tools
-
- /** Check if given polygon is closed. This is kind of a
- 'classic' method to support old polygon definitions.
- Those old polygon definitions define the closed state
- of the polygon using identical start and endpoints. This
- method corrects this (removes double start/end points)
- and sets the Closed()-state of the polygon correctly.
- */
- void checkClosed(::basegfx::polygon::B3DPolygon& rCandidate);
-
- // Get successor and predecessor indices. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate);
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate);
-
- // Get index of first different predecessor. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate);
- sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate);
-
- // get size of polygon. Control vectors are included in that ranges.
- ::basegfx::range::B3DRange getRange(const ::basegfx::polygon::B3DPolygon& rCandidate);
-
- // get length of polygon edge from point nIndex to nIndex + 1
- double getEdgeLength(const ::basegfx::polygon::B3DPolygon& rCandidate, sal_uInt32 nIndex);
-
- // get length of polygon
- double getLength(const ::basegfx::polygon::B3DPolygon& rCandidate);
-
- // get position on polygon for absolute given distance. If
- // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
- // using getLength(...)
- ::basegfx::point::B3DPoint getPositionAbsolute(const ::basegfx::polygon::B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
-
- // get position on polygon for relative given distance in range [0.0 .. 1.0]. If
- // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
- // using getLength(...)
- ::basegfx::point::B3DPoint getPositionRelative(const ::basegfx::polygon::B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
-
- } // end of namespace tools
- } // end of namespace polygon
+ // B3DPolygon tools
+
+ /** Check if given polygon is closed. This is kind of a
+ 'classic' method to support old polygon definitions.
+ Those old polygon definitions define the closed state
+ of the polygon using identical start and endpoints. This
+ method corrects this (removes double start/end points)
+ and sets the Closed()-state of the polygon correctly.
+ */
+ void checkClosed(::basegfx::B3DPolygon& rCandidate);
+
+ // Get successor and predecessor indices. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate);
+ sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate);
+
+ // Get index of first different predecessor. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate);
+ sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate);
+
+ // get size of polygon. Control vectors are included in that ranges.
+ ::basegfx::B3DRange getRange(const ::basegfx::B3DPolygon& rCandidate);
+
+ // get length of polygon edge from point nIndex to nIndex + 1
+ double getEdgeLength(const ::basegfx::B3DPolygon& rCandidate, sal_uInt32 nIndex);
+
+ // get length of polygon
+ double getLength(const ::basegfx::B3DPolygon& rCandidate);
+
+ // get position on polygon for absolute given distance. If
+ // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
+ // using getLength(...)
+ ::basegfx::B3DPoint getPositionAbsolute(const ::basegfx::B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+
+ // get position on polygon for relative given distance in range [0.0 .. 1.0]. If
+ // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
+ // using getLength(...)
+ ::basegfx::B3DPoint getPositionRelative(const ::basegfx::B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+
+ // Apply Line Dashing. This cuts the Polygon into line pieces
+ // which are inserted as single polygons into the result.
+ ::basegfx::B3DPolyPolygon applyLineDashing(const ::basegfx::B3DPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen);
+
+ } // end of namespace tools
} // end of namespace basegfx
#endif // _BGFX_POLYGON_B3DPOLYGONTOOLS_HXX
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
index 1fcd5634d15c..c3a84e3e8750 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolypolygon.hxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:29:18 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:54 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,81 +71,71 @@ class ImplB3DPolyPolygon;
namespace basegfx
{
- namespace polygon
- {
- class B3DPolygon;
- } // end of namespace polygon
-
- namespace matrix
- {
- class B3DHomMatrix;
- } // end of namespace matrix
+ class B3DPolygon;
+ class B3DHomMatrix;
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
- namespace polygon
+ class B3DPolyPolygon
{
- class B3DPolyPolygon
- {
- private:
- ImplB3DPolyPolygon* mpPolyPolygon;
+ private:
+ ImplB3DPolyPolygon* mpPolyPolygon;
- // internal method to force a ref-counted instance to be copied
- // to a modifyable unique copy.
- void implForceUniqueCopy();
+ // internal method to force a ref-counted instance to be copied
+ // to a modifyable unique copy.
+ void implForceUniqueCopy();
- public:
- B3DPolyPolygon();
- B3DPolyPolygon(const B3DPolyPolygon& rPolyPolygon);
- ~B3DPolyPolygon();
+ public:
+ B3DPolyPolygon();
+ B3DPolyPolygon(const B3DPolyPolygon& rPolyPolygon);
+ ~B3DPolyPolygon();
- // assignment operator
- B3DPolyPolygon& operator=(const B3DPolyPolygon& rPolyPolygon);
+ // assignment operator
+ B3DPolyPolygon& operator=(const B3DPolyPolygon& rPolyPolygon);
- // compare operators
- sal_Bool operator==(const B3DPolyPolygon& rPolyPolygon) const;
- sal_Bool operator!=(const B3DPolyPolygon& rPolyPolygon) const;
+ // compare operators
+ sal_Bool operator==(const B3DPolyPolygon& rPolyPolygon) const;
+ sal_Bool operator!=(const B3DPolyPolygon& rPolyPolygon) const;
- // polygon interface
- sal_uInt32 count() const;
+ // polygon interface
+ sal_uInt32 count() const;
- B3DPolygon getB3DPolygon(sal_uInt32 nIndex) const;
- void setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon);
+ B3DPolygon getB3DPolygon(sal_uInt32 nIndex) const;
+ void setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon);
- // insert/append single polygon
- void insert(sal_uInt32 nIndex, const B3DPolygon& rPolygon, sal_uInt32 nCount = 1);
- void append(const B3DPolygon& rPolygon, sal_uInt32 nCount = 1);
+ // insert/append single polygon
+ void insert(sal_uInt32 nIndex, const B3DPolygon& rPolygon, sal_uInt32 nCount = 1);
+ void append(const B3DPolygon& rPolygon, sal_uInt32 nCount = 1);
- // insert/append multiple polygons
- void insert(sal_uInt32 nIndex, const B3DPolyPolygon& rPolyPolygon);
- void append(const B3DPolyPolygon& rPolyPolygon);
+ // insert/append multiple polygons
+ void insert(sal_uInt32 nIndex, const B3DPolyPolygon& rPolyPolygon);
+ void append(const B3DPolyPolygon& rPolyPolygon);
- // remove
- void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
+ // remove
+ void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
- // reset to empty state
- void clear();
+ // reset to empty state
+ void clear();
- // closed state
- sal_Bool isClosed() const;
- void setClosed(sal_Bool bNew);
+ // closed state
+ sal_Bool isClosed() const;
+ void setClosed(sal_Bool bNew);
- // flip polygon direction
- void flip();
+ // flip polygon direction
+ void flip();
- // test if PolyPolygon has double points
- sal_Bool hasDoublePoints() const;
+ // test if PolyPolygon has double points
+ sal_Bool hasDoublePoints() const;
- // remove double points, at the begin/end and follow-ups, too
- void removeDoublePoints();
+ // remove double points, at the begin/end and follow-ups, too
+ void removeDoublePoints();
- // apply transformation given in matrix form to the polygon
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix);
- };
- } // end of namespace polygon
+ // apply transformation given in matrix form to the polygon
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix);
+ };
} // end of namespace basegfx
#endif // _BGFX_POLYGON_B3DPOLYPOLYGON_HXX
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
index c731930fa69a..aa056975971e 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolypolygontools.hxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:29:22 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:54 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -70,33 +70,28 @@
#include <basegfx/vector/b2dvector.hxx>
#endif
+#include <vector>
+
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
// predefinitions
- namespace polygon
- {
- class B3DPolyPolygon;
- } // end of namespace polygon
+ class B3DPolyPolygon;
+ class B3DRange;
- // predefinitions
- namespace range
+ namespace tools
{
- class B3DRange;
- } // end of namespace range
+ // B3DPolyPolygon tools
- namespace polygon
- {
- namespace tools
- {
- // B3DPolyPolygon tools
+ // get size of PolyPolygon. Control vectors are included in that ranges.
+ ::basegfx::B3DRange getRange(const ::basegfx::B3DPolyPolygon& rCandidate);
- // get size of PolyPolygon. Control vectors are included in that ranges.
- ::basegfx::range::B3DRange getRange(const ::basegfx::polygon::B3DPolyPolygon& rCandidate);
+ // Apply Line Dashing. This cuts every contained PolyPolygon into line pieces
+ // which are inserted as single polygons into the result.
+ ::basegfx::B3DPolyPolygon applyLineDashing(const ::basegfx::B3DPolyPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen);
- } // end of namespace tools
- } // end of namespace polygon
+ } // end of namespace tools
} // end of namespace basegfx
#endif // _BGFX_POLYPOLYGON_B3DPOLYGONTOOLS_HXX
diff --git a/basegfx/inc/basegfx/range/b1drange.hxx b/basegfx/inc/basegfx/range/b1drange.hxx
index e2fd154b5e11..4bb457b28d35 100644
--- a/basegfx/inc/basegfx/range/b1drange.hxx
+++ b/basegfx/inc/basegfx/range/b1drange.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b1drange.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:00 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:56 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,88 +68,85 @@
namespace basegfx
{
- namespace range
+ class B1DRange
{
- class B1DRange
+ ::basegfx::BasicRange maRange;
+
+ public:
+ B1DRange()
+ {
+ }
+
+ B1DRange(double fStartValue)
+ : maRange(fStartValue)
+ {
+ }
+
+ B1DRange(const B1DRange& rRange)
+ : maRange(rRange.maRange)
+ {
+ }
+
+ sal_Bool isEmpty() const
+ {
+ return maRange.isEmpty();
+ }
+
+ void reset()
+ {
+ maRange.reset();
+ }
+
+ void operator=(const B1DRange& rRange)
+ {
+ maRange = rRange.maRange;
+ }
+
+ double getMinimum() const
+ {
+ return maRange.getMinimum();
+ }
+
+ double getMaximum() const
+ {
+ return maRange.getMaximum();
+ }
+
+ double getRange() const
+ {
+ return maRange.getRange();
+ }
+
+ double getCenter() const
+ {
+ return maRange.getCenter();
+ }
+
+ sal_Bool isInside(double fValue) const
+ {
+ return maRange.isInside(fValue);
+ }
+
+ sal_Bool isInside(const B1DRange& rRange) const
+ {
+ return maRange.isInside(rRange.maRange);
+ }
+
+ sal_Bool overlaps(const B1DRange& rRange) const
+ {
+ return maRange.overlaps(rRange.maRange);
+ }
+
+ void expand(double fValue)
+ {
+ maRange.expand(fValue);
+ }
+
+ void expand(const B1DRange& rRange)
{
- ::basegfx::range::BasicRange maRange;
-
- public:
- B1DRange()
- {
- }
-
- B1DRange(double fStartValue)
- : maRange(fStartValue)
- {
- }
-
- B1DRange(const B1DRange& rRange)
- : maRange(rRange.maRange)
- {
- }
-
- sal_Bool isEmpty() const
- {
- return maRange.isEmpty();
- }
-
- void reset()
- {
- maRange.reset();
- }
-
- void operator=(const B1DRange& rRange)
- {
- maRange = rRange.maRange;
- }
-
- double getMinimum() const
- {
- return maRange.getMinimum();
- }
-
- double getMaximum() const
- {
- return maRange.getMaximum();
- }
-
- double getRange() const
- {
- return maRange.getRange();
- }
-
- double getCenter() const
- {
- return maRange.getCenter();
- }
-
- sal_Bool isInside(double fValue) const
- {
- return maRange.isInside(fValue);
- }
-
- sal_Bool isInside(const B1DRange& rRange) const
- {
- return maRange.isInside(rRange.maRange);
- }
-
- sal_Bool overlaps(const B1DRange& rRange) const
- {
- return maRange.overlaps(rRange.maRange);
- }
-
- void expand(double fValue)
- {
- maRange.expand(fValue);
- }
-
- void expand(const B1DRange& rRange)
- {
- maRange.expand(rRange.maRange);
- }
- };
- } // end of namespace range
+ maRange.expand(rRange.maRange);
+ }
+ };
} // end of namespace basegfx
#endif // _BGFX_RANGE_B1DRANGE_HXX
diff --git a/basegfx/inc/basegfx/range/b2drange.hxx b/basegfx/inc/basegfx/range/b2drange.hxx
index 10f14abe9fd7..c30d461f259a 100644
--- a/basegfx/inc/basegfx/range/b2drange.hxx
+++ b/basegfx/inc/basegfx/range/b2drange.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2drange.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:01 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:56 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -72,119 +72,116 @@
namespace basegfx
{
- namespace range
+ class B2DRange
{
- class B2DRange
+ ::basegfx::BasicRange maRangeX;
+ ::basegfx::BasicRange maRangeY;
+
+ public:
+ B2DRange()
+ {
+ }
+
+ B2DRange(const B2DTuple& rTuple)
+ : maRangeX(rTuple.getX()),
+ maRangeY(rTuple.getY())
+ {
+ }
+
+ B2DRange(const B2DRange& rRange)
+ : maRangeX(rRange.maRangeX),
+ maRangeY(rRange.maRangeY)
+ {
+ }
+
+ sal_Bool isEmpty() const
+ {
+ return (
+ maRangeX.isEmpty()
+ || maRangeY.isEmpty()
+ );
+ }
+
+ void reset()
+ {
+ maRangeX.reset();
+ maRangeY.reset();
+ }
+
+ void operator=(const B2DRange& rRange)
+ {
+ maRangeX = rRange.maRangeX;
+ maRangeY = rRange.maRangeY;
+ }
+
+ B2DTuple getMinimum() const
+ {
+ return B2DTuple(
+ maRangeX.getMinimum(),
+ maRangeY.getMinimum()
+ );
+ }
+
+ B2DTuple getMaximum() const
+ {
+ return B2DTuple(
+ maRangeX.getMaximum(),
+ maRangeY.getMaximum()
+ );
+ }
+
+ B2DTuple getRange() const
+ {
+ return B2DTuple(
+ maRangeX.getRange(),
+ maRangeY.getRange()
+ );
+ }
+
+ B2DTuple getCenter() const
+ {
+ return B2DTuple(
+ maRangeX.getCenter(),
+ maRangeY.getCenter()
+ );
+ }
+
+ sal_Bool isInside(const B2DTuple& rTuple) const
+ {
+ return (
+ maRangeX.isInside(rTuple.getX())
+ && maRangeY.isInside(rTuple.getY())
+ );
+ }
+
+ sal_Bool isInside(const B2DRange& rRange) const
+ {
+ return (
+ maRangeX.isInside(rRange.maRangeX)
+ && maRangeY.isInside(rRange.maRangeY)
+ );
+ }
+
+ sal_Bool overlaps(const B2DRange& rRange) const
+ {
+ return (
+ maRangeX.overlaps(rRange.maRangeX)
+ && maRangeY.overlaps(rRange.maRangeY)
+ );
+ }
+
+ void expand(const B2DTuple& rTuple)
+ {
+ maRangeX.expand(rTuple.getX());
+ maRangeY.expand(rTuple.getY());
+ }
+
+ void expand(const B2DRange& rRange)
{
- ::basegfx::range::BasicRange maRangeX;
- ::basegfx::range::BasicRange maRangeY;
-
- public:
- B2DRange()
- {
- }
-
- B2DRange(const tuple::B2DTuple& rTuple)
- : maRangeX(rTuple.getX()),
- maRangeY(rTuple.getY())
- {
- }
-
- B2DRange(const B2DRange& rRange)
- : maRangeX(rRange.maRangeX),
- maRangeY(rRange.maRangeY)
- {
- }
-
- sal_Bool isEmpty() const
- {
- return (
- maRangeX.isEmpty()
- || maRangeY.isEmpty()
- );
- }
-
- void reset()
- {
- maRangeX.reset();
- maRangeY.reset();
- }
-
- void operator=(const B2DRange& rRange)
- {
- maRangeX = rRange.maRangeX;
- maRangeY = rRange.maRangeY;
- }
-
- tuple::B2DTuple getMinimum() const
- {
- return tuple::B2DTuple(
- maRangeX.getMinimum(),
- maRangeY.getMinimum()
- );
- }
-
- tuple::B2DTuple getMaximum() const
- {
- return tuple::B2DTuple(
- maRangeX.getMaximum(),
- maRangeY.getMaximum()
- );
- }
-
- tuple::B2DTuple getRange() const
- {
- return tuple::B2DTuple(
- maRangeX.getRange(),
- maRangeY.getRange()
- );
- }
-
- tuple::B2DTuple getCenter() const
- {
- return tuple::B2DTuple(
- maRangeX.getCenter(),
- maRangeY.getCenter()
- );
- }
-
- sal_Bool isInside(const tuple::B2DTuple& rTuple) const
- {
- return (
- maRangeX.isInside(rTuple.getX())
- && maRangeY.isInside(rTuple.getY())
- );
- }
-
- sal_Bool isInside(const B2DRange& rRange) const
- {
- return (
- maRangeX.isInside(rRange.maRangeX)
- && maRangeY.isInside(rRange.maRangeY)
- );
- }
-
- sal_Bool overlaps(const B2DRange& rRange) const
- {
- return (
- maRangeX.overlaps(rRange.maRangeX)
- && maRangeY.overlaps(rRange.maRangeY)
- );
- }
-
- void expand(const tuple::B2DTuple& rTuple)
- {
- maRangeX.expand(rTuple.getX());
- maRangeY.expand(rTuple.getY());
- }
-
- void expand(const B2DRange& rRange)
- {
- maRangeX.expand(rRange.maRangeX);
- maRangeY.expand(rRange.maRangeY);
- }
- };
- } // end of namespace range
+ maRangeX.expand(rRange.maRangeX);
+ maRangeY.expand(rRange.maRangeY);
+ }
+ };
} // end of namespace basegfx
#endif // _BGFX_RANGE_B2DRANGE_HXX
diff --git a/basegfx/inc/basegfx/range/b3drange.hxx b/basegfx/inc/basegfx/range/b3drange.hxx
index 3d6c3c958d1a..a4d5be99f6ec 100644
--- a/basegfx/inc/basegfx/range/b3drange.hxx
+++ b/basegfx/inc/basegfx/range/b3drange.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3drange.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:02 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:56 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -72,134 +72,131 @@
namespace basegfx
{
- namespace range
+ class B3DRange
{
- class B3DRange
+ ::basegfx::BasicRange maRangeX;
+ ::basegfx::BasicRange maRangeY;
+ ::basegfx::BasicRange maRangeZ;
+
+ public:
+ B3DRange()
+ {
+ }
+
+ B3DRange(const B3DTuple& rTuple)
+ : maRangeX(rTuple.getX()),
+ maRangeY(rTuple.getY()),
+ maRangeZ(rTuple.getZ())
+ {
+ }
+
+ B3DRange(const B3DRange& rRange)
+ : maRangeX(rRange.maRangeX),
+ maRangeY(rRange.maRangeY),
+ maRangeZ(rRange.maRangeZ)
+ {
+ }
+
+ sal_Bool isEmpty() const
+ {
+ return (
+ maRangeX.isEmpty()
+ || maRangeY.isEmpty()
+ || maRangeZ.isEmpty()
+ );
+ }
+
+ void reset()
+ {
+ maRangeX.reset();
+ maRangeY.reset();
+ maRangeZ.reset();
+ }
+
+ void operator=(const B3DRange& rRange)
+ {
+ maRangeX = rRange.maRangeX;
+ maRangeY = rRange.maRangeY;
+ maRangeZ = rRange.maRangeZ;
+ }
+
+ B3DTuple getMinimum() const
+ {
+ return B3DTuple(
+ maRangeX.getMinimum(),
+ maRangeY.getMinimum(),
+ maRangeZ.getMinimum()
+ );
+ }
+
+ B3DTuple getMaximum() const
+ {
+ return B3DTuple(
+ maRangeX.getMaximum(),
+ maRangeY.getMaximum(),
+ maRangeZ.getMaximum()
+ );
+ }
+
+ B3DTuple getRange() const
+ {
+ return B3DTuple(
+ maRangeX.getRange(),
+ maRangeY.getRange(),
+ maRangeZ.getRange()
+ );
+ }
+
+ B3DTuple getCenter() const
+ {
+ return B3DTuple(
+ maRangeX.getCenter(),
+ maRangeY.getCenter(),
+ maRangeZ.getCenter()
+ );
+ }
+
+ sal_Bool isInside(const B3DTuple& rTuple) const
+ {
+ return (
+ maRangeX.isInside(rTuple.getX())
+ && maRangeY.isInside(rTuple.getY())
+ && maRangeZ.isInside(rTuple.getZ())
+ );
+ }
+
+ sal_Bool isInside(const B3DRange& rRange) const
+ {
+ return (
+ maRangeX.isInside(rRange.maRangeX)
+ && maRangeY.isInside(rRange.maRangeY)
+ && maRangeZ.isInside(rRange.maRangeZ)
+ );
+ }
+
+ sal_Bool overlaps(const B3DRange& rRange) const
+ {
+ return (
+ maRangeX.overlaps(rRange.maRangeX)
+ && maRangeY.overlaps(rRange.maRangeY)
+ && maRangeZ.overlaps(rRange.maRangeZ)
+ );
+ }
+
+ void expand(const B3DTuple& rTuple)
+ {
+ maRangeX.expand(rTuple.getX());
+ maRangeY.expand(rTuple.getY());
+ maRangeZ.expand(rTuple.getZ());
+ }
+
+ void expand(const B3DRange& rRange)
{
- ::basegfx::range::BasicRange maRangeX;
- ::basegfx::range::BasicRange maRangeY;
- ::basegfx::range::BasicRange maRangeZ;
-
- public:
- B3DRange()
- {
- }
-
- B3DRange(const tuple::B3DTuple& rTuple)
- : maRangeX(rTuple.getX()),
- maRangeY(rTuple.getY()),
- maRangeZ(rTuple.getZ())
- {
- }
-
- B3DRange(const B3DRange& rRange)
- : maRangeX(rRange.maRangeX),
- maRangeY(rRange.maRangeY),
- maRangeZ(rRange.maRangeZ)
- {
- }
-
- sal_Bool isEmpty() const
- {
- return (
- maRangeX.isEmpty()
- || maRangeY.isEmpty()
- || maRangeZ.isEmpty()
- );
- }
-
- void reset()
- {
- maRangeX.reset();
- maRangeY.reset();
- maRangeZ.reset();
- }
-
- void operator=(const B3DRange& rRange)
- {
- maRangeX = rRange.maRangeX;
- maRangeY = rRange.maRangeY;
- maRangeZ = rRange.maRangeZ;
- }
-
- tuple::B3DTuple getMinimum() const
- {
- return tuple::B3DTuple(
- maRangeX.getMinimum(),
- maRangeY.getMinimum(),
- maRangeZ.getMinimum()
- );
- }
-
- tuple::B3DTuple getMaximum() const
- {
- return tuple::B3DTuple(
- maRangeX.getMaximum(),
- maRangeY.getMaximum(),
- maRangeZ.getMaximum()
- );
- }
-
- tuple::B3DTuple getRange() const
- {
- return tuple::B3DTuple(
- maRangeX.getRange(),
- maRangeY.getRange(),
- maRangeZ.getRange()
- );
- }
-
- tuple::B3DTuple getCenter() const
- {
- return tuple::B3DTuple(
- maRangeX.getCenter(),
- maRangeY.getCenter(),
- maRangeZ.getCenter()
- );
- }
-
- sal_Bool isInside(const tuple::B3DTuple& rTuple) const
- {
- return (
- maRangeX.isInside(rTuple.getX())
- && maRangeY.isInside(rTuple.getY())
- && maRangeZ.isInside(rTuple.getZ())
- );
- }
-
- sal_Bool isInside(const B3DRange& rRange) const
- {
- return (
- maRangeX.isInside(rRange.maRangeX)
- && maRangeY.isInside(rRange.maRangeY)
- && maRangeZ.isInside(rRange.maRangeZ)
- );
- }
-
- sal_Bool overlaps(const B3DRange& rRange) const
- {
- return (
- maRangeX.overlaps(rRange.maRangeX)
- && maRangeY.overlaps(rRange.maRangeY)
- && maRangeZ.overlaps(rRange.maRangeZ)
- );
- }
-
- void expand(const tuple::B3DTuple& rTuple)
- {
- maRangeX.expand(rTuple.getX());
- maRangeY.expand(rTuple.getY());
- maRangeZ.expand(rTuple.getZ());
- }
-
- void expand(const B3DRange& rRange)
- {
- maRangeX.expand(rRange.maRangeX);
- maRangeY.expand(rRange.maRangeY);
- maRangeZ.expand(rRange.maRangeZ);
- }
- };
- } // end of namespace range
+ maRangeX.expand(rRange.maRangeX);
+ maRangeY.expand(rRange.maRangeY);
+ maRangeZ.expand(rRange.maRangeZ);
+ }
+ };
} // end of namespace basegfx
#endif // _BGFX_RANGE_B3DRANGE_HXX
diff --git a/basegfx/inc/basegfx/range/basicrange.hxx b/basegfx/inc/basegfx/range/basicrange.hxx
index 700f2b17add4..732a95abcf70 100644
--- a/basegfx/inc/basegfx/range/basicrange.hxx
+++ b/basegfx/inc/basegfx/range/basicrange.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: basicrange.hxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:30:28 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:56 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -75,103 +75,100 @@
namespace basegfx
{
- namespace range
+ class BasicRange
{
- class BasicRange
+ protected:
+ double mfMinimum;
+ double mfMaximum;
+
+ public:
+ void reset()
{
- protected:
- double mfMinimum;
- double mfMaximum;
+ mfMinimum = START_MINIMUM_VALUE;
+ mfMaximum = START_MAXIMUM_VALUE;
+ }
- public:
- void reset()
- {
- mfMinimum = START_MINIMUM_VALUE;
- mfMaximum = START_MAXIMUM_VALUE;
- }
+ sal_Bool isEmpty() const
+ {
+ return sal_Bool(START_MINIMUM_VALUE == mfMinimum && START_MAXIMUM_VALUE == mfMaximum);
+ }
- sal_Bool isEmpty() const
- {
- return sal_Bool(START_MINIMUM_VALUE == mfMinimum && START_MAXIMUM_VALUE == mfMaximum);
- }
+ double getMinimum() const { return mfMinimum; }
+ double getMaximum() const { return mfMaximum; }
- double getMinimum() const { return mfMinimum; }
- double getMaximum() const { return mfMaximum; }
+ double getRange() const
+ {
+ return (mfMaximum - mfMinimum);
+ }
- double getRange() const
- {
- return (mfMaximum - mfMinimum);
- }
+ double getCenter() const
+ {
+ return ((mfMaximum + mfMinimum) / 2.0);
+ }
- double getCenter() const
- {
- return ((mfMaximum + mfMinimum) / 2.0);
- }
+ sal_Bool isInside(double fValue) const
+ {
+ return sal_Bool((fValue >= mfMinimum) && (fValue <= mfMaximum));
+ }
- sal_Bool isInside(double fValue) const
- {
- return sal_Bool((fValue >= mfMinimum) && (fValue <= mfMaximum));
- }
+ sal_Bool isInside(const BasicRange& rRange) const
+ {
+ return sal_Bool((rRange.getMinimum() >= mfMinimum) && (rRange.getMaximum() <= mfMaximum));
+ }
- sal_Bool isInside(const BasicRange& rRange) const
- {
- return sal_Bool((rRange.getMinimum() >= mfMinimum) && (rRange.getMaximum() <= mfMaximum));
- }
+ sal_Bool overlaps(const BasicRange& rRange) const
+ {
+ return !sal_Bool((rRange.getMaximum() < mfMinimum) || (rRange.getMinimum() > mfMaximum));
+ }
- sal_Bool overlaps(const BasicRange& rRange) const
- {
- return !sal_Bool((rRange.getMaximum() < mfMinimum) || (rRange.getMinimum() > mfMaximum));
- }
+ BasicRange()
+ : mfMinimum(START_MINIMUM_VALUE),
+ mfMaximum(START_MAXIMUM_VALUE)
+ {
+ }
+ BasicRange(double fStartValue)
+ : mfMinimum(fStartValue),
+ mfMaximum(fStartValue)
+ {
+ }
+ BasicRange(const BasicRange& rRange)
+ : mfMinimum(rRange.getMinimum()),
+ mfMaximum(rRange.getMaximum())
+ {
+ }
- BasicRange()
- : mfMinimum(START_MINIMUM_VALUE),
- mfMaximum(START_MAXIMUM_VALUE)
- {
- }
- BasicRange(double fStartValue)
- : mfMinimum(fStartValue),
- mfMaximum(fStartValue)
- {
- }
- BasicRange(const BasicRange& rRange)
- : mfMinimum(rRange.getMinimum()),
- mfMaximum(rRange.getMaximum())
+ void operator=(const BasicRange& rRange)
+ {
+ mfMinimum = rRange.getMinimum();
+ mfMaximum = rRange.getMaximum();
+ }
+
+ void expand(double fValue)
+ {
+ if(fValue < mfMinimum)
{
+ mfMinimum = fValue;
}
- void operator=(const BasicRange& rRange)
+ if(fValue > mfMaximum)
{
- mfMinimum = rRange.getMinimum();
- mfMaximum = rRange.getMaximum();
+ mfMaximum = fValue;
}
+ }
- void expand(double fValue)
+ void expand(const BasicRange& rRange)
+ {
+ if(rRange.getMinimum() < mfMinimum)
{
- if(fValue < mfMinimum)
- {
- mfMinimum = fValue;
- }
-
- if(fValue > mfMaximum)
- {
- mfMaximum = fValue;
- }
+ mfMinimum = rRange.getMinimum();
}
- void expand(const BasicRange& rRange)
+ if(rRange.getMaximum() > mfMaximum)
{
- if(rRange.getMinimum() < mfMinimum)
- {
- mfMinimum = rRange.getMinimum();
- }
-
- if(rRange.getMaximum() > mfMaximum)
- {
- mfMaximum = rRange.getMaximum();
- }
+ mfMaximum = rRange.getMaximum();
}
- };
- } // end of namespace range
+ }
+ };
} // end of namespace basegfx
#endif _BGFX_RANGE_BASICRANGE_HXX
diff --git a/basegfx/inc/basegfx/tuple/b2dtuple.hxx b/basegfx/inc/basegfx/tuple/b2dtuple.hxx
index dd775d8c399e..4f555481c2c2 100644
--- a/basegfx/inc/basegfx/tuple/b2dtuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2dtuple.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dtuple.hxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-10 11:45:48 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:57 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -72,301 +72,298 @@
namespace basegfx
{
- namespace tuple
+ /** Base class for all Points/Vectors with two double values
+
+ This class provides all methods common to Point
+ avd Vector classes which are derived from here.
+
+ @derive Use this class to implement Points or Vectors
+ which are based on two double values
+ */
+ class B2DTuple
{
- /** Base class for all Points/Vectors with two double values
+ private:
+ static B2DTuple maEmptyTuple;
+
+ protected:
+ double mfX;
+ double mfY;
+
+ public:
+ /** Create a 2D Tuple
+
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 2D Tuple.
+ */
+ B2DTuple(double fVal = 0.0)
+ : mfX(fVal),
+ mfY(fVal)
+ {}
+
+ /** Create a 2D Tuple
- This class provides all methods common to Point
- avd Vector classes which are derived from here.
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 2D Tuple.
- @derive Use this class to implement Points or Vectors
- which are based on two double values
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 2D Tuple.
*/
- class B2DTuple
+ B2DTuple(double fX, double fY)
+ : mfX( fX ),
+ mfY( fY )
+ {}
+
+ /** Create a copy of a 2D Tuple
+
+ @param rTup
+ The 2D Tuple which will be copied.
+ */
+ B2DTuple(const B2DTuple& rTup)
+ : mfX( rTup.mfX ),
+ mfY( rTup.mfY )
+ {}
+
+ ~B2DTuple()
+ {}
+
+ /// Get X-Coordinate of 2D Tuple
+ double getX() const
+ {
+ return mfX;
+ }
+
+ /// Get Y-Coordinate of 2D Tuple
+ double getY() const
{
- private:
- static B2DTuple maEmptyTuple;
-
- protected:
- double mfX;
- double mfY;
-
- public:
- /** Create a 2D Tuple
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 2D Tuple.
- */
- B2DTuple(double fVal = 0.0)
- : mfX(fVal),
- mfY(fVal)
- {}
-
- /** Create a 2D Tuple
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 2D Tuple.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 2D Tuple.
- */
- B2DTuple(double fX, double fY)
- : mfX( fX ),
- mfY( fY )
- {}
-
- /** Create a copy of a 2D Tuple
-
- @param rTup
- The 2D Tuple which will be copied.
- */
- B2DTuple(const B2DTuple& rTup)
- : mfX( rTup.mfX ),
- mfY( rTup.mfY )
- {}
-
- ~B2DTuple()
- {}
-
- /// Get X-Coordinate of 2D Tuple
- double getX() const
- {
- return mfX;
- }
-
- /// Get Y-Coordinate of 2D Tuple
- double getY() const
- {
- return mfY;
- }
-
- /// Set X-Coordinate of 2D Tuple
- void setX(double fX)
- {
- mfX = fX;
- }
-
- /// Set Y-Coordinate of 2D Tuple
- void setY(double fY)
- {
- mfY = fY;
- }
-
- /// Array-access to 2D Tuple
- const double& operator[] (int nPos) const
- {
- // Here, normally one if(...) should be used. In the assumption that
- // both double members can be accessed as an array a shortcut is used here.
- // if(0 == nPos) return mfX; return mfY;
- return *((&mfX) + nPos);
- }
-
- /// Array-access to 2D Tuple
- double& operator[] (int nPos)
- {
- // Here, normally one if(...) should be used. In the assumption that
- // both double members can be accessed as an array a shortcut is used here.
- // if(0 == nPos) return mfX; return mfY;
- return *((&mfX) + nPos);
- }
-
- // comparators with tolerance
- //////////////////////////////////////////////////////////////////////
-
- sal_Bool equalZero() const;
-
- sal_Bool equalZero(const double& rfSmallValue) const;
-
- sal_Bool equal(const B2DTuple& rTup) const;
-
- sal_Bool equal(const B2DTuple& rTup, const double& rfSmallValue) const;
-
- // operators
- //////////////////////////////////////////////////////////////////////
-
- B2DTuple& operator+=( const B2DTuple& rTup )
- {
- mfX += rTup.mfX;
- mfY += rTup.mfY;
- return *this;
- }
-
- B2DTuple& operator-=( const B2DTuple& rTup )
- {
- mfX -= rTup.mfX;
- mfY -= rTup.mfY;
- return *this;
- }
-
- B2DTuple& operator/=( const B2DTuple& rTup )
- {
- mfX /= rTup.mfX;
- mfY /= rTup.mfY;
- return *this;
- }
-
- B2DTuple& operator*=( const B2DTuple& rTup )
- {
- mfX *= rTup.mfX;
- mfY *= rTup.mfY;
- return *this;
- }
-
- B2DTuple& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- return *this;
- }
-
- B2DTuple& operator/=(double t)
- {
- const double fVal(1.0 / t);
- mfX *= fVal;
- mfY *= fVal;
- return *this;
- }
-
- B2DTuple operator-(void) const
- {
- return B2DTuple(-mfX, -mfY);
- }
-
- sal_Bool operator==( const B2DTuple& rTup ) const
- {
- return equal(rTup);
- }
-
- sal_Bool operator!=( const B2DTuple& rTup ) const
- {
- return !equal(rTup);
- }
-
- B2DTuple& operator=( const B2DTuple& rTup )
- {
- mfX = rTup.mfX;
- mfY = rTup.mfY;
- return *this;
- }
-
- void correctValues(const double fCompareValue = 0.0);
-
- static const B2DTuple& getEmptyTuple()
- {
- return maEmptyTuple;
- }
- };
-
- // external operators
- //////////////////////////////////////////////////////////////////////////
-
- inline B2DTuple min(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ return mfY;
+ }
+
+ /// Set X-Coordinate of 2D Tuple
+ void setX(double fX)
{
- B2DTuple aMin(
- (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
- (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY());
- return aMin;
+ mfX = fX;
}
- inline B2DTuple max(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ /// Set Y-Coordinate of 2D Tuple
+ void setY(double fY)
{
- B2DTuple aMax(
- (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
- (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY());
- return aMax;
+ mfY = fY;
}
- inline B2DTuple abs(const B2DTuple& rTup)
+ /// Array-access to 2D Tuple
+ const double& operator[] (int nPos) const
{
- B2DTuple aAbs(
- (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
- (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY());
- return aAbs;
+ // Here, normally one if(...) should be used. In the assumption that
+ // both double members can be accessed as an array a shortcut is used here.
+ // if(0 == nPos) return mfX; return mfY;
+ return *((&mfX) + nPos);
}
- inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t)
+ /// Array-access to 2D Tuple
+ double& operator[] (int nPos)
+ {
+ // Here, normally one if(...) should be used. In the assumption that
+ // both double members can be accessed as an array a shortcut is used here.
+ // if(0 == nPos) return mfX; return mfY;
+ return *((&mfX) + nPos);
+ }
+
+ // comparators with tolerance
+ //////////////////////////////////////////////////////////////////////
+
+ sal_Bool equalZero() const;
+
+ sal_Bool equalZero(const double& rfSmallValue) const;
+
+ sal_Bool equal(const B2DTuple& rTup) const;
+
+ sal_Bool equal(const B2DTuple& rTup, const double& rfSmallValue) const;
+
+ // operators
+ //////////////////////////////////////////////////////////////////////
+
+ B2DTuple& operator+=( const B2DTuple& rTup )
{
- B2DTuple aInt(
- ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
- ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
- return aInt;
+ mfX += rTup.mfX;
+ mfY += rTup.mfY;
+ return *this;
}
- inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2)
+ B2DTuple& operator-=( const B2DTuple& rTup )
{
- B2DTuple aAvg(
- (rOld1.getX() + rOld2.getX()) * 0.5,
- (rOld1.getY() + rOld2.getY()) * 0.5);
- return aAvg;
+ mfX -= rTup.mfX;
+ mfY -= rTup.mfY;
+ return *this;
}
- inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2, const B2DTuple& rOld3)
+ B2DTuple& operator/=( const B2DTuple& rTup )
{
- B2DTuple aAvg(
- (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
- (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
- return aAvg;
+ mfX /= rTup.mfX;
+ mfY /= rTup.mfY;
+ return *this;
}
- inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ B2DTuple& operator*=( const B2DTuple& rTup )
{
- B2DTuple aSum(rTupA);
- aSum += rTupB;
- return aSum;
+ mfX *= rTup.mfX;
+ mfY *= rTup.mfY;
+ return *this;
}
- inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ B2DTuple& operator*=(double t)
{
- B2DTuple aSub(rTupA);
- aSub -= rTupB;
- return aSub;
+ mfX *= t;
+ mfY *= t;
+ return *this;
}
- inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ B2DTuple& operator/=(double t)
{
- B2DTuple aDiv(rTupA);
- aDiv /= rTupB;
- return aDiv;
+ const double fVal(1.0 / t);
+ mfX *= fVal;
+ mfY *= fVal;
+ return *this;
}
- inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ B2DTuple operator-(void) const
{
- B2DTuple aMul(rTupA);
- aMul *= rTupB;
- return aMul;
+ return B2DTuple(-mfX, -mfY);
}
- inline B2DTuple operator*(const B2DTuple& rTup, double t)
+ sal_Bool operator==( const B2DTuple& rTup ) const
{
- B2DTuple aNew(rTup);
- aNew *= t;
- return aNew;
+ return equal(rTup);
}
- inline B2DTuple operator*(double t, const B2DTuple& rTup)
+ sal_Bool operator!=( const B2DTuple& rTup ) const
{
- B2DTuple aNew(rTup);
- aNew *= t;
- return aNew;
+ return !equal(rTup);
}
- inline B2DTuple operator/(const B2DTuple& rTup, double t)
+ B2DTuple& operator=( const B2DTuple& rTup )
{
- B2DTuple aNew(rTup);
- aNew /= t;
- return aNew;
+ mfX = rTup.mfX;
+ mfY = rTup.mfY;
+ return *this;
}
- inline B2DTuple operator/(double t, const B2DTuple& rTup)
+ void correctValues(const double fCompareValue = 0.0);
+
+ static const B2DTuple& getEmptyTuple()
{
- B2DTuple aNew(rTup);
- aNew /= t;
- return aNew;
+ return maEmptyTuple;
}
- } // end of namespace tuple
+ };
+
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
+
+ inline B2DTuple min(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aMin(
+ (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
+ (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY());
+ return aMin;
+ }
+
+ inline B2DTuple max(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aMax(
+ (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
+ (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY());
+ return aMax;
+ }
+
+ inline B2DTuple abs(const B2DTuple& rTup)
+ {
+ B2DTuple aAbs(
+ (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
+ (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY());
+ return aAbs;
+ }
+
+ inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t)
+ {
+ B2DTuple aInt(
+ ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
+ ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
+ return aInt;
+ }
+
+ inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2)
+ {
+ B2DTuple aAvg(
+ (rOld1.getX() + rOld2.getX()) * 0.5,
+ (rOld1.getY() + rOld2.getY()) * 0.5);
+ return aAvg;
+ }
+
+ inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2, const B2DTuple& rOld3)
+ {
+ B2DTuple aAvg(
+ (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
+ (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
+ return aAvg;
+ }
+
+ inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aSum(rTupA);
+ aSum += rTupB;
+ return aSum;
+ }
+
+ inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aSub(rTupA);
+ aSub -= rTupB;
+ return aSub;
+ }
+
+ inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aDiv(rTupA);
+ aDiv /= rTupB;
+ return aDiv;
+ }
+
+ inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB)
+ {
+ B2DTuple aMul(rTupA);
+ aMul *= rTupB;
+ return aMul;
+ }
+
+ inline B2DTuple operator*(const B2DTuple& rTup, double t)
+ {
+ B2DTuple aNew(rTup);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B2DTuple operator*(double t, const B2DTuple& rTup)
+ {
+ B2DTuple aNew(rTup);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B2DTuple operator/(const B2DTuple& rTup, double t)
+ {
+ B2DTuple aNew(rTup);
+ aNew /= t;
+ return aNew;
+ }
+
+ inline B2DTuple operator/(double t, const B2DTuple& rTup)
+ {
+ B2DTuple aNew(rTup);
+ aNew /= t;
+ return aNew;
+ }
} // end of namespace basegfx
#endif // _BGFX_TUPLE_B2DTUPLE_HXX
diff --git a/basegfx/inc/basegfx/tuple/b3dtuple.hxx b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
index 48f1fde48a24..928f1f081855 100644
--- a/basegfx/inc/basegfx/tuple/b3dtuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dtuple.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:04 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:57 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,394 +68,391 @@
namespace basegfx
{
- namespace tuple
- {
- /** Base class for all Points/Vectors with three double values
-
- This class provides all methods common to Point
- avd Vector classes which are derived from here.
-
- @derive Use this class to implement Points or Vectors
- which are based on three double values
- */
- class B3DTuple
- {
- private:
- static B3DTuple maEmptyTuple;
-
- protected:
- double mfX;
- double mfY;
- double mfZ;
-
- public:
- /** Create a 3D Tuple
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 3D Tuple.
- */
- B3DTuple(double fVal = 0.0)
- : mfX(fVal),
- mfY(fVal),
- mfZ(fVal)
- {}
-
- /** Create a 3D Tuple
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 3D Tuple.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 3D Tuple.
-
- @param fZ
- This parameter is used to initialize the Z-coordinate
- of the 3D Tuple.
- */
- B3DTuple(double fX, double fY, double fZ)
- : mfX(fX),
- mfY(fY),
- mfZ(fZ)
- {}
-
- /** Create a copy of a 3D Tuple
-
- @param rTup
- The 3D Tuple which will be copied.
- */
- B3DTuple(const B3DTuple& rTup)
- : mfX( rTup.mfX ),
- mfY( rTup.mfY ),
- mfZ( rTup.mfZ )
- {}
-
- ~B3DTuple()
- {}
-
- /// get X-Coordinate of 3D Tuple
- double getX() const
- {
- return mfX;
- }
-
- /// get Y-Coordinate of 3D Tuple
- double getY() const
- {
- return mfY;
- }
-
- /// get Z-Coordinate of 3D Tuple
- double getZ() const
- {
- return mfZ;
- }
-
- /// set X-Coordinate of 3D Tuple
- void setX(double fX)
- {
- mfX = fX;
- }
+ /** Base class for all Points/Vectors with three double values
- /// set Y-Coordinate of 3D Tuple
- void setY(double fY)
- {
- mfY = fY;
- }
+ This class provides all methods common to Point
+ avd Vector classes which are derived from here.
- /// set Z-Coordinate of 3D Tuple
- void setZ(double fZ)
- {
- mfZ = fZ;
- }
+ @derive Use this class to implement Points or Vectors
+ which are based on three double values
+ */
+ class B3DTuple
+ {
+ private:
+ static B3DTuple maEmptyTuple;
- /// Array-access to 3D Tuple
- const double& operator[] (int nPos) const
- {
- // Here, normally two if(...)'s should be used. In the assumption that
- // both double members can be accessed as an array a shortcut is used here.
- // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
- return *((&mfX) + nPos);
- }
+ protected:
+ double mfX;
+ double mfY;
+ double mfZ;
- /// Array-access to 3D Tuple
- double& operator[] (int nPos)
- {
- // Here, normally two if(...)'s should be used. In the assumption that
- // both double members can be accessed as an array a shortcut is used here.
- // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
- return *((&mfX) + nPos);
- }
+ public:
+ /** Create a 3D Tuple
- // comparators with tolerance
- //////////////////////////////////////////////////////////////////////
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 3D Tuple.
+ */
+ B3DTuple(double fVal = 0.0)
+ : mfX(fVal),
+ mfY(fVal),
+ mfZ(fVal)
+ {}
- sal_Bool equalZero() const
- {
- return (this == &maEmptyTuple ||
- (::basegfx::numeric::fTools::equalZero(mfX)
- && ::basegfx::numeric::fTools::equalZero(mfY)
- && ::basegfx::numeric::fTools::equalZero(mfZ)));
- }
+ /** Create a 3D Tuple
- sal_Bool equalZero(const double& rfSmallValue) const
- {
- return (this == &maEmptyTuple ||
- (::basegfx::numeric::fTools::equalZero(mfX, rfSmallValue)
- && ::basegfx::numeric::fTools::equalZero(mfY, rfSmallValue)
- && ::basegfx::numeric::fTools::equalZero(mfZ, rfSmallValue)));
- }
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 3D Tuple.
- sal_Bool equal(const B3DTuple& rTup) const
- {
- return (
- ::basegfx::numeric::fTools::equal(mfX, rTup.mfX) &&
- ::basegfx::numeric::fTools::equal(mfY, rTup.mfY) &&
- ::basegfx::numeric::fTools::equal(mfZ, rTup.mfZ));
- }
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 3D Tuple.
- sal_Bool equal(const B3DTuple& rTup, const double& rfSmallValue) const
- {
- return (
- ::basegfx::numeric::fTools::equal(mfX, rTup.mfX, rfSmallValue) &&
- ::basegfx::numeric::fTools::equal(mfY, rTup.mfY, rfSmallValue) &&
- ::basegfx::numeric::fTools::equal(mfZ, rTup.mfZ, rfSmallValue));
- }
+ @param fZ
+ This parameter is used to initialize the Z-coordinate
+ of the 3D Tuple.
+ */
+ B3DTuple(double fX, double fY, double fZ)
+ : mfX(fX),
+ mfY(fY),
+ mfZ(fZ)
+ {}
- // operators
- //////////////////////////////////////////////////////////////////////
+ /** Create a copy of a 3D Tuple
- B3DTuple& operator+=( const B3DTuple& rTup )
- {
- mfX += rTup.mfX;
- mfY += rTup.mfY;
- mfZ += rTup.mfZ;
- return *this;
- }
+ @param rTup
+ The 3D Tuple which will be copied.
+ */
+ B3DTuple(const B3DTuple& rTup)
+ : mfX( rTup.mfX ),
+ mfY( rTup.mfY ),
+ mfZ( rTup.mfZ )
+ {}
- B3DTuple& operator-=( const B3DTuple& rTup )
- {
- mfX -= rTup.mfX;
- mfY -= rTup.mfY;
- mfZ -= rTup.mfZ;
- return *this;
- }
+ ~B3DTuple()
+ {}
- B3DTuple& operator/=( const B3DTuple& rTup )
- {
- mfX /= rTup.mfX;
- mfY /= rTup.mfY;
- mfZ /= rTup.mfZ;
- return *this;
- }
+ /// get X-Coordinate of 3D Tuple
+ double getX() const
+ {
+ return mfX;
+ }
- B3DTuple& operator*=( const B3DTuple& rTup )
- {
- mfX *= rTup.mfX;
- mfY *= rTup.mfY;
- mfZ *= rTup.mfZ;
- return *this;
- }
+ /// get Y-Coordinate of 3D Tuple
+ double getY() const
+ {
+ return mfY;
+ }
- B3DTuple& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- mfZ *= t;
- return *this;
- }
+ /// get Z-Coordinate of 3D Tuple
+ double getZ() const
+ {
+ return mfZ;
+ }
- B3DTuple& operator/=(double t)
- {
- const double fVal(1.0 / t);
- mfX *= t;
- mfY *= t;
- mfZ *= t;
- return *this;
- }
+ /// set X-Coordinate of 3D Tuple
+ void setX(double fX)
+ {
+ mfX = fX;
+ }
- B3DTuple operator-(void) const
- {
- return B3DTuple(-mfX, -mfY, -mfZ);
- }
+ /// set Y-Coordinate of 3D Tuple
+ void setY(double fY)
+ {
+ mfY = fY;
+ }
- sal_Bool operator==( const B3DTuple& rTup ) const
- {
- return equal(rTup);
- }
+ /// set Z-Coordinate of 3D Tuple
+ void setZ(double fZ)
+ {
+ mfZ = fZ;
+ }
- sal_Bool operator!=( const B3DTuple& rTup ) const
- {
- return !equal(rTup);
- }
+ /// Array-access to 3D Tuple
+ const double& operator[] (int nPos) const
+ {
+ // Here, normally two if(...)'s should be used. In the assumption that
+ // both double members can be accessed as an array a shortcut is used here.
+ // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
+ return *((&mfX) + nPos);
+ }
- B3DTuple& operator=( const B3DTuple& rTup )
- {
- mfX = rTup.mfX;
- mfY = rTup.mfY;
- mfZ = rTup.mfZ;
- return *this;
- }
+ /// Array-access to 3D Tuple
+ double& operator[] (int nPos)
+ {
+ // Here, normally two if(...)'s should be used. In the assumption that
+ // both double members can be accessed as an array a shortcut is used here.
+ // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ;
+ return *((&mfX) + nPos);
+ }
- void correctValues(const double fCompareValue = 0.0)
- {
- if(0.0 == fCompareValue)
- {
- if(::basegfx::numeric::fTools::equalZero(mfX))
- {
- mfX = 0.0;
- }
-
- if(::basegfx::numeric::fTools::equalZero(mfY))
- {
- mfY = 0.0;
- }
-
- if(::basegfx::numeric::fTools::equalZero(mfZ))
- {
- mfZ = 0.0;
- }
- }
- else
- {
- if(::basegfx::numeric::fTools::equal(mfX, fCompareValue))
- {
- mfX = fCompareValue;
- }
-
- if(::basegfx::numeric::fTools::equal(mfY, fCompareValue))
- {
- mfY = fCompareValue;
- }
-
- if(::basegfx::numeric::fTools::equal(mfZ, fCompareValue))
- {
- mfZ = fCompareValue;
- }
- }
- }
+ // comparators with tolerance
+ //////////////////////////////////////////////////////////////////////
- static const B3DTuple& getEmptyTuple()
- {
- return maEmptyTuple;
- }
- };
+ sal_Bool equalZero() const
+ {
+ return (this == &maEmptyTuple ||
+ (::basegfx::fTools::equalZero(mfX)
+ && ::basegfx::fTools::equalZero(mfY)
+ && ::basegfx::fTools::equalZero(mfZ)));
+ }
- // external operators
- //////////////////////////////////////////////////////////////////////////
+ sal_Bool equalZero(const double& rfSmallValue) const
+ {
+ return (this == &maEmptyTuple ||
+ (::basegfx::fTools::equalZero(mfX, rfSmallValue)
+ && ::basegfx::fTools::equalZero(mfY, rfSmallValue)
+ && ::basegfx::fTools::equalZero(mfZ, rfSmallValue)));
+ }
- inline B3DTuple min(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ sal_Bool equal(const B3DTuple& rTup) const
{
- B3DTuple aMin(
- (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
- (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
- (rTupB.getZ() < rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
- return aMin;
+ return (
+ ::basegfx::fTools::equal(mfX, rTup.mfX) &&
+ ::basegfx::fTools::equal(mfY, rTup.mfY) &&
+ ::basegfx::fTools::equal(mfZ, rTup.mfZ));
}
- inline B3DTuple max(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ sal_Bool equal(const B3DTuple& rTup, const double& rfSmallValue) const
{
- B3DTuple aMax(
- (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
- (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
- (rTupB.getZ() > rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
- return aMax;
+ return (
+ ::basegfx::fTools::equal(mfX, rTup.mfX, rfSmallValue) &&
+ ::basegfx::fTools::equal(mfY, rTup.mfY, rfSmallValue) &&
+ ::basegfx::fTools::equal(mfZ, rTup.mfZ, rfSmallValue));
}
- inline B3DTuple abs(const B3DTuple& rTup)
+ // operators
+ //////////////////////////////////////////////////////////////////////
+
+ B3DTuple& operator+=( const B3DTuple& rTup )
{
- B3DTuple aAbs(
- (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
- (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY(),
- (0.0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ());
- return aAbs;
+ mfX += rTup.mfX;
+ mfY += rTup.mfY;
+ mfZ += rTup.mfZ;
+ return *this;
}
- inline B3DTuple interpolate(const B3DTuple& rOld1, const B3DTuple& rOld2, double t)
+ B3DTuple& operator-=( const B3DTuple& rTup )
{
- B3DTuple aInt(
- ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
- ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
- ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
- return aInt;
+ mfX -= rTup.mfX;
+ mfY -= rTup.mfY;
+ mfZ -= rTup.mfZ;
+ return *this;
}
- inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2)
+ B3DTuple& operator/=( const B3DTuple& rTup )
{
- B3DTuple aAvg(
- (rOld1.getX() + rOld2.getX()) * 0.5,
- (rOld1.getY() + rOld2.getY()) * 0.5,
- (rOld1.getZ() + rOld2.getZ()) * 0.5);
- return aAvg;
+ mfX /= rTup.mfX;
+ mfY /= rTup.mfY;
+ mfZ /= rTup.mfZ;
+ return *this;
}
- inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2, const B3DTuple& rOld3)
+ B3DTuple& operator*=( const B3DTuple& rTup )
{
- B3DTuple aAvg(
- (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
- (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
- (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
- return aAvg;
+ mfX *= rTup.mfX;
+ mfY *= rTup.mfY;
+ mfZ *= rTup.mfZ;
+ return *this;
}
- inline B3DTuple operator+(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ B3DTuple& operator*=(double t)
{
- B3DTuple aSum(rTupA);
- aSum += rTupB;
- return aSum;
+ mfX *= t;
+ mfY *= t;
+ mfZ *= t;
+ return *this;
}
- inline B3DTuple operator-(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ B3DTuple& operator/=(double t)
{
- B3DTuple aSub(rTupA);
- aSub -= rTupB;
- return aSub;
+ const double fVal(1.0 / t);
+ mfX *= t;
+ mfY *= t;
+ mfZ *= t;
+ return *this;
}
- inline B3DTuple operator/(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ B3DTuple operator-(void) const
{
- B3DTuple aDiv(rTupA);
- aDiv /= rTupB;
- return aDiv;
+ return B3DTuple(-mfX, -mfY, -mfZ);
}
- inline B3DTuple operator*(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ sal_Bool operator==( const B3DTuple& rTup ) const
{
- B3DTuple aMul(rTupA);
- aMul *= rTupB;
- return aMul;
+ return equal(rTup);
}
- inline B3DTuple operator*(const B3DTuple& rTup, double t)
+ sal_Bool operator!=( const B3DTuple& rTup ) const
{
- B3DTuple aNew(rTup);
- aNew *= t;
- return aNew;
+ return !equal(rTup);
}
- inline B3DTuple operator*(double t, const B3DTuple& rTup)
+ B3DTuple& operator=( const B3DTuple& rTup )
{
- B3DTuple aNew(rTup);
- aNew *= t;
- return aNew;
+ mfX = rTup.mfX;
+ mfY = rTup.mfY;
+ mfZ = rTup.mfZ;
+ return *this;
}
- inline B3DTuple operator/(const B3DTuple& rTup, double t)
+ void correctValues(const double fCompareValue = 0.0)
{
- B3DTuple aNew(rTup);
- aNew /= t;
- return aNew;
+ if(0.0 == fCompareValue)
+ {
+ if(::basegfx::fTools::equalZero(mfX))
+ {
+ mfX = 0.0;
+ }
+
+ if(::basegfx::fTools::equalZero(mfY))
+ {
+ mfY = 0.0;
+ }
+
+ if(::basegfx::fTools::equalZero(mfZ))
+ {
+ mfZ = 0.0;
+ }
+ }
+ else
+ {
+ if(::basegfx::fTools::equal(mfX, fCompareValue))
+ {
+ mfX = fCompareValue;
+ }
+
+ if(::basegfx::fTools::equal(mfY, fCompareValue))
+ {
+ mfY = fCompareValue;
+ }
+
+ if(::basegfx::fTools::equal(mfZ, fCompareValue))
+ {
+ mfZ = fCompareValue;
+ }
+ }
}
- inline B3DTuple operator/(double t, const B3DTuple& rTup)
+ static const B3DTuple& getEmptyTuple()
{
- B3DTuple aNew(rTup);
- aNew /= t;
- return aNew;
+ return maEmptyTuple;
}
- } // end of namespace tuple
+ };
+
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
+
+ inline B3DTuple min(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aMin(
+ (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
+ (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
+ (rTupB.getZ() < rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
+ return aMin;
+ }
+
+ inline B3DTuple max(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aMax(
+ (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
+ (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY(),
+ (rTupB.getZ() > rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ());
+ return aMax;
+ }
+
+ inline B3DTuple abs(const B3DTuple& rTup)
+ {
+ B3DTuple aAbs(
+ (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
+ (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY(),
+ (0.0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ());
+ return aAbs;
+ }
+
+ inline B3DTuple interpolate(const B3DTuple& rOld1, const B3DTuple& rOld2, double t)
+ {
+ B3DTuple aInt(
+ ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
+ ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
+ ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
+ return aInt;
+ }
+
+ inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2)
+ {
+ B3DTuple aAvg(
+ (rOld1.getX() + rOld2.getX()) * 0.5,
+ (rOld1.getY() + rOld2.getY()) * 0.5,
+ (rOld1.getZ() + rOld2.getZ()) * 0.5);
+ return aAvg;
+ }
+
+ inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2, const B3DTuple& rOld3)
+ {
+ B3DTuple aAvg(
+ (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
+ (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
+ (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
+ return aAvg;
+ }
+
+ inline B3DTuple operator+(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aSum(rTupA);
+ aSum += rTupB;
+ return aSum;
+ }
+
+ inline B3DTuple operator-(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aSub(rTupA);
+ aSub -= rTupB;
+ return aSub;
+ }
+
+ inline B3DTuple operator/(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aDiv(rTupA);
+ aDiv /= rTupB;
+ return aDiv;
+ }
+
+ inline B3DTuple operator*(const B3DTuple& rTupA, const B3DTuple& rTupB)
+ {
+ B3DTuple aMul(rTupA);
+ aMul *= rTupB;
+ return aMul;
+ }
+
+ inline B3DTuple operator*(const B3DTuple& rTup, double t)
+ {
+ B3DTuple aNew(rTup);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B3DTuple operator*(double t, const B3DTuple& rTup)
+ {
+ B3DTuple aNew(rTup);
+ aNew *= t;
+ return aNew;
+ }
+
+ inline B3DTuple operator/(const B3DTuple& rTup, double t)
+ {
+ B3DTuple aNew(rTup);
+ aNew /= t;
+ return aNew;
+ }
+
+ inline B3DTuple operator/(double t, const B3DTuple& rTup)
+ {
+ B3DTuple aNew(rTup);
+ aNew /= t;
+ return aNew;
+ }
} // end of namespace basegfx
#endif // _BGFX_TUPLE_B3DTUPLE_HXX
diff --git a/basegfx/inc/basegfx/vector/b2dvector.hxx b/basegfx/inc/basegfx/vector/b2dvector.hxx
index f35c38bb3236..6b5fe724b3e9 100644
--- a/basegfx/inc/basegfx/vector/b2dvector.hxx
+++ b/basegfx/inc/basegfx/vector/b2dvector.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dvector.hxx,v $
*
- * $Revision: 1.7 $
+ * $Revision: 1.8 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:05 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:58 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,250 +68,244 @@
namespace basegfx
{
- namespace matrix
+ // predeclaration
+ class B2DHomMatrix;
+
+ /** Descriptor for the mathematical orientations of two 2D Vectors
+ */
+ enum B2DVectorOrientation
+ {
+ /// mathematically positive oriented
+ ORIENTATION_POSITIVE = 0,
+
+ /// mathematically negative oriented
+ ORIENTATION_NEGATIVE,
+
+ /// mathematically neutral, thus parallel
+ ORIENTATION_NEUTRAL
+ };
+
+ /** Descriptor for the mathematical continuity of two 2D Vectors
+ */
+ enum B2DVectorContinuity
{
- // predeclaration
- class B2DHomMatrix;
- } // end of namespace matrix;
+ /// none
+ CONTINUITY_NONE = 0,
+
+ /// mathematically negative oriented
+ CONTINUITY_C1,
- namespace vector
+ /// mathematically neutral, thus parallel
+ CONTINUITY_C2
+ };
+
+ /** Base Point class with two double values
+
+ This class derives all operators and common handling for
+ a 2D data class from B2DTuple. All necessary extensions
+ which are special for 2D Vectors are added here.
+
+ @see B2DTuple
+ */
+ class B2DVector : public ::basegfx::B2DTuple
{
- /** Descriptor for the mathematical orientations of two 2D Vectors
+ public:
+ /** Create a 2D Vector
+
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 2D Vector.
*/
- enum B2DVectorOrientation
- {
- /// mathematically positive oriented
- ORIENTATION_POSITIVE = 0,
+ B2DVector(double fVal = 0.0)
+ : B2DTuple(fVal)
+ {}
- /// mathematically negative oriented
- ORIENTATION_NEGATIVE,
+ /** Create a 2D Vector
- /// mathematically neutral, thus parallel
- ORIENTATION_NEUTRAL
- };
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 2D Vector.
- /** Descriptor for the mathematical continuity of two 2D Vectors
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 2D Vector.
*/
- enum B2DVectorContinuity
- {
- /// none
- CONTINUITY_NONE = 0,
+ B2DVector(double fX, double fY)
+ : B2DTuple(fX, fY)
+ {}
- /// mathematically negative oriented
- CONTINUITY_C1,
+ /** Create a copy of a 2D Vector
- /// mathematically neutral, thus parallel
- CONTINUITY_C2
- };
+ @param rVec
+ The 2D Vector which will be copied.
+ */
+ B2DVector(const B2DVector& rVec)
+ : B2DTuple(rVec)
+ {}
- /** Base Point class with two double values
+ /** constructor with tuple to allow copy-constructing
+ from B2DTuple-based classes
+ */
+ B2DVector(const ::basegfx::B2DTuple& rTuple)
+ : B2DTuple(rTuple)
+ {}
- This class derives all operators and common handling for
- a 2D data class from B2DTuple. All necessary extensions
- which are special for 2D Vectors are added here.
+ ~B2DVector()
+ {}
- @see B2DTuple
+ /** *=operator to allow usage from B2DVector, too
*/
- class B2DVector : public ::basegfx::tuple::B2DTuple
+ B2DVector& operator*=( const B2DVector& rPnt )
{
- public:
- /** Create a 2D Vector
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 2D Vector.
- */
- B2DVector(double fVal = 0.0)
- : B2DTuple(fVal)
- {}
-
- /** Create a 2D Vector
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 2D Vector.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 2D Vector.
- */
- B2DVector(double fX, double fY)
- : B2DTuple(fX, fY)
- {}
-
- /** Create a copy of a 2D Vector
-
- @param rVec
- The 2D Vector which will be copied.
- */
- B2DVector(const B2DVector& rVec)
- : B2DTuple(rVec)
- {}
-
- /** constructor with tuple to allow copy-constructing
- from B2DTuple-based classes
- */
- B2DVector(const ::basegfx::tuple::B2DTuple& rTuple)
- : B2DTuple(rTuple)
- {}
-
- ~B2DVector()
- {}
-
- /** *=operator to allow usage from B2DVector, too
- */
- B2DVector& operator*=( const B2DVector& rPnt )
- {
- mfX *= rPnt.mfX;
- mfY *= rPnt.mfY;
- return *this;
- }
-
- /** *=operator to allow usage from B2DVector, too
- */
- B2DVector& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- return *this;
- }
-
- /** assignment operator to allow assigning the results
- of B2DTuple calculations
- */
- B2DVector& operator=( const ::basegfx::tuple::B2DTuple& rVec );
-
- /** Calculate the length of this 2D Vector
-
- @return The Length of the 2D Vector
- */
- double getLength() const;
-
- /** Set the length of this 2D Vector
-
- @param fLen
- The to be achieved length of the 2D Vector
- */
- B2DVector& setLength(double fLen);
-
- /** Normalize this 2D Vector
-
- The length of the 2D Vector is set to 1.0
- */
- B2DVector& normalize();
-
- /** Test if this 2D Vector is normalized
-
- @return
- sal_True if lenth of vector is equal to 1.0
- sal_False else
- */
- sal_Bool isNormalized() const;
-
- /** Calculate the Scalar with another 2D Vector
-
- @param rVec
- The second 2D Vector
-
- @return
- The Scalar value of the two involved 2D Vectors
- */
- double scalar( const B2DVector& rVec ) const;
-
- /** Calculate the length of the cross product with another 2D Vector
-
- In 2D, returning an actual vector does not make much
- sense here. The magnitude, although, can be readily
- used for tasks such as angle calculations, since for
- the returned value, the following equation holds:
- retVal = getLength(this)*getLength(rVec)*sin(theta),
- with theta being the angle between the two vectors.
+ mfX *= rPnt.mfX;
+ mfY *= rPnt.mfY;
+ return *this;
+ }
- @param rVec
- The second 2D Vector
+ /** *=operator to allow usage from B2DVector, too
+ */
+ B2DVector& operator*=(double t)
+ {
+ mfX *= t;
+ mfY *= t;
+ return *this;
+ }
- @return
- The length of the cross product of the two involved 2D Vectors
- */
- double cross( const B2DVector& rVec ) const;
+ /** assignment operator to allow assigning the results
+ of B2DTuple calculations
+ */
+ B2DVector& operator=( const ::basegfx::B2DTuple& rVec );
- /** Calculate the Angle with another 2D Vector
+ /** Calculate the length of this 2D Vector
- @param rVec
- The second 2D Vector
+ @return The Length of the 2D Vector
+ */
+ double getLength() const;
- @return
- The Angle value of the two involved 2D Vectors in -pi/2 < return < pi/2
- */
- double angle( const B2DVector& rVec ) const;
+ /** Set the length of this 2D Vector
- /** Transform vector by given transformation matrix.
+ @param fLen
+ The to be achieved length of the 2D Vector
+ */
+ B2DVector& setLength(double fLen);
- Since this is a vector, translational components of the
- matrix are disregarded.
- */
- B2DVector& operator*=( const matrix::B2DHomMatrix& rMat );
+ /** Normalize this 2D Vector
- static const B2DVector& getEmptyVector();
- };
+ The length of the 2D Vector is set to 1.0
+ */
+ B2DVector& normalize();
- // external operators
- //////////////////////////////////////////////////////////////////////////
+ /** Test if this 2D Vector is normalized
- /** Calculate the orientation to another 2D Vector
+ @return
+ sal_True if lenth of vector is equal to 1.0
+ sal_False else
+ */
+ sal_Bool isNormalized() const;
- @param rVecA
- The first 2D Vector
+ /** Calculate the Scalar with another 2D Vector
- @param rVecB
+ @param rVec
The second 2D Vector
@return
- The mathematical Orientation of the two involved 2D Vectors
+ The Scalar value of the two involved 2D Vectors
*/
- B2DVectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB );
+ double scalar( const B2DVector& rVec ) const;
- /** Calculate a perpendicular 2D Vector to the given one
+ /** Calculate the length of the cross product with another 2D Vector
- @param rVec
- The source 2D Vector
+ In 2D, returning an actual vector does not make much
+ sense here. The magnitude, although, can be readily
+ used for tasks such as angle calculations, since for
+ the returned value, the following equation holds:
+ retVal = getLength(this)*getLength(rVec)*sin(theta),
+ with theta being the angle between the two vectors.
- @attention This only works if the given 2D Vector is normalized.
+ @param rVec
+ The second 2D Vector
@return
- A 2D Vector perpendicular to the one given in parameter rVec
+ The length of the cross product of the two involved 2D Vectors
*/
- B2DVector getPerpendicular( const B2DVector& rNormalizedVec );
-
- /** Test two vectors which need not to be normalized for parallelism
+ double cross( const B2DVector& rVec ) const;
- @param rVecA
- The first 2D Vector
+ /** Calculate the Angle with another 2D Vector
- @param rVecB
+ @param rVec
The second 2D Vector
@return
- sal_Bool if the two values are parallel. Also sal_True if
- one of the vectors is empty.
+ The Angle value of the two involved 2D Vectors in -pi/2 < return < pi/2
*/
- sal_Bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB );
+ double angle( const B2DVector& rVec ) const;
/** Transform vector by given transformation matrix.
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B2DVector operator*( const matrix::B2DHomMatrix& rMat, const B2DVector& rVec );
+ B2DVector& operator*=( const B2DHomMatrix& rMat );
- /** Test continuity between given vectors.
+ static const B2DVector& getEmptyVector();
+ };
- The two given vectors are assumed to describe control points on a
- common point. Calculate if there is a continuity between them.
- */
- ::basegfx::vector::B2DVectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector );
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
+
+ /** Calculate the orientation to another 2D Vector
+
+ @param rVecA
+ The first 2D Vector
+
+ @param rVecB
+ The second 2D Vector
+
+ @return
+ The mathematical Orientation of the two involved 2D Vectors
+ */
+ B2DVectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB );
+
+ /** Calculate a perpendicular 2D Vector to the given one
+
+ @param rVec
+ The source 2D Vector
+
+ @attention This only works if the given 2D Vector is normalized.
+
+ @return
+ A 2D Vector perpendicular to the one given in parameter rVec
+ */
+ B2DVector getPerpendicular( const B2DVector& rNormalizedVec );
+
+ /** Test two vectors which need not to be normalized for parallelism
+
+ @param rVecA
+ The first 2D Vector
+
+ @param rVecB
+ The second 2D Vector
+
+ @return
+ sal_Bool if the two values are parallel. Also sal_True if
+ one of the vectors is empty.
+ */
+ sal_Bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB );
+
+ /** Transform vector by given transformation matrix.
+
+ Since this is a vector, translational components of the
+ matrix are disregarded.
+ */
+ B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec );
+
+ /** Test continuity between given vectors.
+
+ The two given vectors are assumed to describe control points on a
+ common point. Calculate if there is a continuity between them.
+ */
+ ::basegfx::B2DVectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector );
- } // end of namespace vector
} // end of namespace basegfx
#endif // _BGFX_VECTOR_B2DVECTOR_HXX
diff --git a/basegfx/inc/basegfx/vector/b3dvector.hxx b/basegfx/inc/basegfx/vector/b3dvector.hxx
index 855abb7f71e8..094bacfb50a1 100644
--- a/basegfx/inc/basegfx/vector/b3dvector.hxx
+++ b/basegfx/inc/basegfx/vector/b3dvector.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dvector.hxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:05 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:17:58 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -68,270 +68,232 @@
namespace basegfx
{
- namespace matrix
- {
- // predeclaration
- class B3DHomMatrix;
- } // end of namespace matrix;
+ // predeclaration
+ class B3DHomMatrix;
- namespace vector
- {
- /** Base Point class with three double values
+ /** Base Point class with three double values
+
+ This class derives all operators and common handling for
+ a 3D data class from B3DTuple. All necessary extensions
+ which are special for 3D Vectors are added here.
- This class derives all operators and common handling for
- a 3D data class from B3DTuple. All necessary extensions
- which are special for 3D Vectors are added here.
+ @see B3DTuple
+ */
+ class B3DVector : public ::basegfx::B3DTuple
+ {
+ public:
+ /** Create a 3D Vector
- @see B3DTuple
+ @param fVal
+ This parameter is used to initialize the coordinate
+ part of the 3D Vector.
*/
- class B3DVector : public ::basegfx::tuple::B3DTuple
- {
- public:
- /** Create a 3D Vector
-
- @param fVal
- This parameter is used to initialize the coordinate
- part of the 3D Vector.
- */
- B3DVector(double fVal = 0.0)
- : B3DTuple(fVal)
- {}
-
- /** Create a 3D Vector
-
- @param fX
- This parameter is used to initialize the X-coordinate
- of the 3D Vector.
-
- @param fY
- This parameter is used to initialize the Y-coordinate
- of the 3D Vector.
-
- @param fZ
- This parameter is used to initialize the Z-coordinate
- of the 3D Vector.
- */
- B3DVector(double fX, double fY, double fZ)
- : B3DTuple(fX, fY, fZ)
- {}
-
- /** Create a copy of a 3D Vector
-
- @param rVec
- The 3D Vector which will be copied.
- */
- B3DVector(const B3DVector& rVec)
- : B3DTuple(rVec)
- {}
-
- /** constructor with tuple to allow copy-constructing
- from B3DTuple-based classes
- */
- B3DVector(const ::basegfx::tuple::B3DTuple& rTuple)
- : B3DTuple(rTuple)
- {}
-
- ~B3DVector()
- {}
-
- /** *=operator to allow usage from B3DVector, too
- */
- B3DVector& operator*=( const B3DVector& rPnt )
- {
- mfX *= rPnt.mfX;
- mfY *= rPnt.mfY;
- mfZ *= rPnt.mfZ;
- return *this;
- }
+ B3DVector(double fVal = 0.0)
+ : B3DTuple(fVal)
+ {}
- /** *=operator to allow usage from B3DVector, too
- */
- B3DVector& operator*=(double t)
- {
- mfX *= t;
- mfY *= t;
- mfZ *= t;
- return *this;
- }
+ /** Create a 3D Vector
- /** assignment operator to allow assigning the results
- of B3DTuple calculations
- */
- B3DVector& operator=( const ::basegfx::tuple::B3DTuple& rVec )
- {
- mfX = rVec.getX();
- mfY = rVec.getY();
- mfZ = rVec.getZ();
- return *this;
- }
+ @param fX
+ This parameter is used to initialize the X-coordinate
+ of the 3D Vector.
- /** Calculate the length of this 3D Vector
+ @param fY
+ This parameter is used to initialize the Y-coordinate
+ of the 3D Vector.
- @return The Length of the 3D Vector
- */
- double getLength(void) const
- {
- double fLen(scalar(*this));
- if((0.0 == fLen) || (1.0 == fLen))
- return fLen;
- return sqrt(fLen);
- }
+ @param fZ
+ This parameter is used to initialize the Z-coordinate
+ of the 3D Vector.
+ */
+ B3DVector(double fX, double fY, double fZ)
+ : B3DTuple(fX, fY, fZ)
+ {}
- /** Calculate the length in the XY-Plane for this 3D Vector
+ /** Create a copy of a 3D Vector
- @return The XY-Plane Length of the 3D Vector
- */
- double getXYLength(void) const
- {
- double fLen((mfX * mfX) + (mfY * mfY));
- if((0.0 == fLen) || (1.0 == fLen))
- return fLen;
- return sqrt(fLen);
- }
+ @param rVec
+ The 3D Vector which will be copied.
+ */
+ B3DVector(const B3DVector& rVec)
+ : B3DTuple(rVec)
+ {}
- /** Calculate the length in the XZ-Plane for this 3D Vector
+ /** constructor with tuple to allow copy-constructing
+ from B3DTuple-based classes
+ */
+ B3DVector(const ::basegfx::B3DTuple& rTuple)
+ : B3DTuple(rTuple)
+ {}
- @return The XZ-Plane Length of the 3D Vector
- */
- double getXZLength(void) const
- {
- double fLen((mfX * mfZ) + (mfY * mfZ));
- if((0.0 == fLen) || (1.0 == fLen))
- return fLen;
- return sqrt(fLen);
- }
+ ~B3DVector()
+ {}
+
+ /** *=operator to allow usage from B3DVector, too
+ */
+ B3DVector& operator*=( const B3DVector& rPnt )
+ {
+ mfX *= rPnt.mfX;
+ mfY *= rPnt.mfY;
+ mfZ *= rPnt.mfZ;
+ return *this;
+ }
- /** Calculate the length in the YZ-Plane for this 3D Vector
+ /** *=operator to allow usage from B3DVector, too
+ */
+ B3DVector& operator*=(double t)
+ {
+ mfX *= t;
+ mfY *= t;
+ mfZ *= t;
+ return *this;
+ }
- @return The YZ-Plane Length of the 3D Vector
- */
- double getYZLength(void) const
- {
- double fLen((mfY * mfY) + (mfZ * mfZ));
- if((0.0 == fLen) || (1.0 == fLen))
- return fLen;
- return sqrt(fLen);
- }
+ /** assignment operator to allow assigning the results
+ of B3DTuple calculations
+ */
+ B3DVector& operator=( const ::basegfx::B3DTuple& rVec )
+ {
+ mfX = rVec.getX();
+ mfY = rVec.getY();
+ mfZ = rVec.getZ();
+ return *this;
+ }
- /** Set the length of this 3D Vector
+ /** Calculate the length of this 3D Vector
- @param fLen
- The to be achieved length of the 3D Vector
- */
- B3DVector& setLength(double fLen)
- {
- double fLenNow(scalar(*this));
+ @return The Length of the 3D Vector
+ */
+ double getLength(void) const
+ {
+ double fLen(scalar(*this));
+ if((0.0 == fLen) || (1.0 == fLen))
+ return fLen;
+ return sqrt(fLen);
+ }
- if(!::basegfx::numeric::fTools::equalZero(fLenNow))
- {
- const double fOne(1.0);
+ /** Calculate the length in the XY-Plane for this 3D Vector
- if(!::basegfx::numeric::fTools::equal(fOne, fLenNow))
- {
- fLen /= sqrt(fLenNow);
- }
+ @return The XY-Plane Length of the 3D Vector
+ */
+ double getXYLength(void) const
+ {
+ double fLen((mfX * mfX) + (mfY * mfY));
+ if((0.0 == fLen) || (1.0 == fLen))
+ return fLen;
+ return sqrt(fLen);
+ }
- mfX *= fLen;
- mfY *= fLen;
- mfZ *= fLen;
- }
+ /** Calculate the length in the XZ-Plane for this 3D Vector
- return *this;
- }
+ @return The XZ-Plane Length of the 3D Vector
+ */
+ double getXZLength(void) const
+ {
+ double fLen((mfX * mfZ) + (mfY * mfZ));
+ if((0.0 == fLen) || (1.0 == fLen))
+ return fLen;
+ return sqrt(fLen);
+ }
+
+ /** Calculate the length in the YZ-Plane for this 3D Vector
- /** Normalize this 3D Vector
+ @return The YZ-Plane Length of the 3D Vector
+ */
+ double getYZLength(void) const
+ {
+ double fLen((mfY * mfY) + (mfZ * mfZ));
+ if((0.0 == fLen) || (1.0 == fLen))
+ return fLen;
+ return sqrt(fLen);
+ }
- The length of the 3D Vector is set to 1.0
- */
- B3DVector& normalize();
+ /** Set the length of this 3D Vector
- /** Test if this 3D Vector is normalized
+ @param fLen
+ The to be achieved length of the 3D Vector
+ */
+ B3DVector& setLength(double fLen)
+ {
+ double fLenNow(scalar(*this));
- @return
- sal_True if lenth of vector is equal to 1.0
- sal_False else
- */
- sal_Bool isNormalized() const
+ if(!::basegfx::fTools::equalZero(fLenNow))
{
const double fOne(1.0);
- const double fScalar(scalar(*this));
-
- return (::basegfx::numeric::fTools::equal(fOne, fScalar));
- }
- /** get a 3D Vector which is perpendicular to this and a given 3D Vector
+ if(!::basegfx::fTools::equal(fOne, fLenNow))
+ {
+ fLen /= sqrt(fLenNow);
+ }
- @attention This only works if this and the given 3D Vector are
- both normalized.
+ mfX *= fLen;
+ mfY *= fLen;
+ mfZ *= fLen;
+ }
- @param rNormalizedVec
- A normalized 3D Vector.
+ return *this;
+ }
- @return
- A 3D Vector perpendicular to this and the given one
- */
- B3DVector getPerpendicular(const B3DVector& rNormalizedVec) const;
+ /** Normalize this 3D Vector
- /** get the projection of this Vector on the given Plane
+ The length of the 3D Vector is set to 1.0
+ */
+ B3DVector& normalize();
- @attention This only works if the given 3D Vector defining
- the Plane is normalized.
+ /** Test if this 3D Vector is normalized
- @param rNormalizedPlane
- A normalized 3D Vector defining a Plane.
+ @return
+ sal_True if lenth of vector is equal to 1.0
+ sal_False else
+ */
+ sal_Bool isNormalized() const
+ {
+ const double fOne(1.0);
+ const double fScalar(scalar(*this));
- @return
- The projected 3D Vector
- */
- B3DVector getProjectionOnPlane(const B3DVector& rNormalizedPlane) const;
+ return (::basegfx::fTools::equal(fOne, fScalar));
+ }
- /** Calculate the Scalar product
+ /** get a 3D Vector which is perpendicular to this and a given 3D Vector
- This method calculates the Scalar product between this
- and the given 3D Vector.
+ @attention This only works if this and the given 3D Vector are
+ both normalized.
- @param rVec
- A second 3D Vector.
+ @param rNormalizedVec
+ A normalized 3D Vector.
- @return
- The Scalar Product of two 3D Vectors
- */
- double scalar(const B3DVector& rVec) const
- {
- return ((mfX * rVec.mfX) + (mfY * rVec.mfY) + (mfZ * rVec.mfZ));
- }
+ @return
+ A 3D Vector perpendicular to this and the given one
+ */
+ B3DVector getPerpendicular(const B3DVector& rNormalizedVec) const;
- /** Transform vector by given transformation matrix.
+ /** get the projection of this Vector on the given Plane
- Since this is a vector, translational components of the
- matrix are disregarded.
- */
- B3DVector& operator*=( const matrix::B3DHomMatrix& rMat );
+ @attention This only works if the given 3D Vector defining
+ the Plane is normalized.
- static const B3DVector& getEmptyVector()
- {
- return (const B3DVector&) ::basegfx::tuple::B3DTuple::getEmptyTuple();
- }
- };
+ @param rNormalizedPlane
+ A normalized 3D Vector defining a Plane.
- // external operators
- //////////////////////////////////////////////////////////////////////////
+ @return
+ The projected 3D Vector
+ */
+ B3DVector getProjectionOnPlane(const B3DVector& rNormalizedPlane) const;
- /** get a 3D Vector which is in 2D (ignoring
- the Z-Coordinate) perpendicular to a given 3D Vector
+ /** Calculate the Scalar product
- @attention This only works if the given 3D Vector is normalized.
+ This method calculates the Scalar product between this
+ and the given 3D Vector.
- @param rNormalizedVec
- A normalized 3D Vector.
+ @param rVec
+ A second 3D Vector.
@return
- A 3D Vector perpendicular to the given one in X,Y (2D).
+ The Scalar Product of two 3D Vectors
*/
- inline B3DVector getPerpendicular2D( const B3DVector& rNormalizedVec )
+ double scalar(const B3DVector& rVec) const
{
- B3DVector aPerpendicular(-rNormalizedVec.getY(), rNormalizedVec.getX(), rNormalizedVec.getZ());
- return aPerpendicular;
+ return ((mfX * rVec.mfX) + (mfY * rVec.mfY) + (mfZ * rVec.mfZ));
}
/** Transform vector by given transformation matrix.
@@ -339,28 +301,60 @@ namespace basegfx
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B3DVector operator*( const matrix::B3DHomMatrix& rMat, const B3DVector& rVec );
+ B3DVector& operator*=( const B3DHomMatrix& rMat );
- /** Calculate the Cross Product of two 3D Vectors
+ static const B3DVector& getEmptyVector()
+ {
+ return (const B3DVector&) ::basegfx::B3DTuple::getEmptyTuple();
+ }
+ };
- @param rVecA
- A first 3D Vector.
+ // external operators
+ //////////////////////////////////////////////////////////////////////////
- @param rVecB
- A second 3D Vector.
+ /** get a 3D Vector which is in 2D (ignoring
+ the Z-Coordinate) perpendicular to a given 3D Vector
- @return
- The Cross Product of both 3D Vectors
- */
- inline B3DVector cross(const B3DVector& rVecA, const B3DVector& rVecB)
- {
- B3DVector aVec(
- rVecA.getY() * rVecB.getZ() - rVecA.getZ() * rVecB.getY(),
- rVecA.getZ() * rVecB.getX() - rVecA.getX() * rVecB.getZ(),
- rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
- return aVec;
- }
- } // end of namespace vector
+ @attention This only works if the given 3D Vector is normalized.
+
+ @param rNormalizedVec
+ A normalized 3D Vector.
+
+ @return
+ A 3D Vector perpendicular to the given one in X,Y (2D).
+ */
+ inline B3DVector getPerpendicular2D( const B3DVector& rNormalizedVec )
+ {
+ B3DVector aPerpendicular(-rNormalizedVec.getY(), rNormalizedVec.getX(), rNormalizedVec.getZ());
+ return aPerpendicular;
+ }
+
+ /** Transform vector by given transformation matrix.
+
+ Since this is a vector, translational components of the
+ matrix are disregarded.
+ */
+ B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec );
+
+ /** Calculate the Cross Product of two 3D Vectors
+
+ @param rVecA
+ A first 3D Vector.
+
+ @param rVecB
+ A second 3D Vector.
+
+ @return
+ The Cross Product of both 3D Vectors
+ */
+ inline B3DVector cross(const B3DVector& rVecA, const B3DVector& rVecB)
+ {
+ B3DVector aVec(
+ rVecA.getY() * rVecB.getZ() - rVecA.getZ() * rVecB.getY(),
+ rVecA.getZ() * rVecB.getX() - rVecA.getX() * rVecB.getZ(),
+ rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
+ return aVec;
+ }
} // end of namespace basegfx
#endif // _BGFX_VECTOR_B3DVECTOR_HXX
diff --git a/basegfx/prj/d.lst b/basegfx/prj/d.lst
index ac3edb8a1314..bda0e26ceb42 100644
--- a/basegfx/prj/d.lst
+++ b/basegfx/prj/d.lst
@@ -32,7 +32,8 @@ mkdir: %_DEST%\inc%_EXT%\basegfx\curve
..\inc\basegfx\curve\b2dcubicbezier.hxx %_DEST%\inc%_EXT%\basegfx\curve\b2dcubicbezier.hxx
..\inc\basegfx\curve\b2dquadraticbezier.hxx %_DEST%\inc%_EXT%\basegfx\curve\b2dquadraticbezier.hxx
-#mkdir: %_DEST%\inc%_EXT%\basegfx\numeric
+mkdir: %_DEST%\inc%_EXT%\basegfx\numeric
+..\inc\basegfx\numeric\ftools.hxx %_DEST%\inc%_EXT%\basegfx\numeric\ftools.hxx
mkdir: %_DEST%\inc%_EXT%\basegfx\polygon
..\inc\basegfx\polygon\b2dpolygon.hxx %_DEST%\inc%_EXT%\basegfx\polygon\b2dpolygon.hxx
@@ -46,4 +47,4 @@ mkdir: %_DEST%\inc%_EXT%\basegfx\polygon
mkdir: %_DEST%\inc%_EXT%\basegfx\tuple
..\inc\basegfx\tuple\b2dtuple.hxx %_DEST%\inc%_EXT%\basegfx\tuple\b2dtuple.hxx
-..\inc\basegfx\tuple\b3dtuple.hxx %_DEST%\inc%_EXT%\basegfx\tuple\b3dpoint.hxx
+..\inc\basegfx\tuple\b3dtuple.hxx %_DEST%\inc%_EXT%\basegfx\tuple\b3dtuple.hxx
diff --git a/basegfx/source/curve/b2dbeziertools.cxx b/basegfx/source/curve/b2dbeziertools.cxx
index 3512b87ca992..67c25aacb17a 100644
--- a/basegfx/source/curve/b2dbeziertools.cxx
+++ b/basegfx/source/curve/b2dbeziertools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dbeziertools.cxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:07 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:00 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -95,441 +95,438 @@
namespace basegfx
{
- namespace curve
+ namespace
{
- namespace
+ class DistanceErrorFunctor
{
- class DistanceErrorFunctor
+ public:
+ DistanceErrorFunctor( const double& distance ) :
+ mfDistance2( distance*distance ),
+ mfLastDistanceError2( ::std::numeric_limits<double>::max() )
{
- public:
- DistanceErrorFunctor( const double& distance ) :
- mfDistance2( distance*distance ),
- mfLastDistanceError2( ::std::numeric_limits<double>::max() )
- {
- }
-
- bool subdivideFurther( const double& P1x, const double& P1y,
- const double& P2x, const double& P2y,
- const double& P3x, const double& P3y,
- const double& P4x, const double& P4y,
- const double&, const double& ) // last two values not used here
- {
- // Perform bezier flatness test (lecture notes from R. Schaback,
- // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
- //
- // ||P(t) - L(t)|| <= max ||b_j - b_0 - j/n(b_n - b_0)||
- // 0<=j<=n
- //
- // What is calculated here is an upper bound to the distance from
- // a line through b_0 and b_3 (P1 and P4 in our notation) and the
- // curve. We can drop 0 and n from the running indices, since the
- // argument of max becomes zero for those cases.
- const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
- const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
- const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
- const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
- const double distanceError2( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
- fJ2x*fJ2x + fJ2y*fJ2y) );
-
- // stop if error measure does not improve anymore. This is a
- // safety guard against floating point inaccuracies.
- // stop if distance from line is guaranteed to be bounded by d
- bool bRet( mfLastDistanceError2 > distanceError2 &&
- distanceError2 >= mfDistance2 );
-
- mfLastDistanceError2 = distanceError2;
+ }
- return bRet;
- }
+ bool subdivideFurther( const double& P1x, const double& P1y,
+ const double& P2x, const double& P2y,
+ const double& P3x, const double& P3y,
+ const double& P4x, const double& P4y,
+ const double&, const double& ) // last two values not used here
+ {
+ // Perform bezier flatness test (lecture notes from R. Schaback,
+ // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
+ //
+ // ||P(t) - L(t)|| <= max ||b_j - b_0 - j/n(b_n - b_0)||
+ // 0<=j<=n
+ //
+ // What is calculated here is an upper bound to the distance from
+ // a line through b_0 and b_3 (P1 and P4 in our notation) and the
+ // curve. We can drop 0 and n from the running indices, since the
+ // argument of max becomes zero for those cases.
+ const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
+ const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
+ const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
+ const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
+ const double distanceError2( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
+ fJ2x*fJ2x + fJ2y*fJ2y) );
+
+ // stop if error measure does not improve anymore. This is a
+ // safety guard against floating point inaccuracies.
+ // stop if distance from line is guaranteed to be bounded by d
+ bool bRet( mfLastDistanceError2 > distanceError2 &&
+ distanceError2 >= mfDistance2 );
+
+ mfLastDistanceError2 = distanceError2;
+
+ return bRet;
+ }
- private:
- double mfDistance2;
- double mfLastDistanceError2;
- };
+ private:
+ double mfDistance2;
+ double mfLastDistanceError2;
+ };
- class AngleErrorFunctor
+ class AngleErrorFunctor
+ {
+ public:
+ AngleErrorFunctor( const double& angleBounds ) :
+ mfTanAngle( angleBounds * F_PI180 ),
+ mfLastTanAngle( ::std::numeric_limits<double>::max() )
{
- public:
- AngleErrorFunctor( const double& angleBounds ) :
- mfTanAngle( angleBounds * F_PI180 ),
- mfLastTanAngle( ::std::numeric_limits<double>::max() )
- {
- }
+ }
- bool subdivideFurther( const double P1x, const double P1y,
- const double P2x, const double P2y,
- const double P3x, const double P3y,
- const double P4x, const double P4y,
- const double Pdx, const double Pdy )
+ bool subdivideFurther( const double P1x, const double P1y,
+ const double P2x, const double P2y,
+ const double P3x, const double P3y,
+ const double P4x, const double P4y,
+ const double Pdx, const double Pdy )
+ {
+ // Test angle differences between two lines (ad
+ // and bd), meeting in the t=0.5 division point
+ // (d), and the angle from the other ends of those
+ // lines (b and a, resp.) to the tangents to the
+ // curve at this points:
+ //
+ // *__________
+ // ......*b
+ // ...
+ // ..
+ // .
+ // * *d
+ // | .
+ // | .
+ // | .
+ // | .
+ // |.
+ // |.
+ // *
+ // a
+ //
+ // When using half of the angle bound for the
+ // difference to the tangents at a or b, resp.,
+ // this procedure guarantees that no angle in the
+ // resulting line polygon is larger than the
+ // specified angle bound. This is because during
+ // subdivision, adjacent curve segments will have
+ // collinear tangent vectors, thus, when each
+ // side's line segments differs by at most angle/2
+ // from that tangent, the summed difference will
+ // be at most angle (this was modeled after an
+ // idea from Armin Weiss).
+
+ // To stay within the notation above, a equals P1,
+ // the other end point of the tangent starting at
+ // a is P2, d is Pd, and so forth. The
+ const B2DVector vecAD( Pdx - P1x, Pdy - P1y );
+ const B2DVector vecDB( P4x - Pdx, P4y - Pdy );
+
+ const double scalarVecADDB( vecAD.scalar( vecDB ) );
+ const double crossVecADDB( vecAD.cross( vecDB ) );
+
+ const B2DVector vecStartTangent( P2x - P1x, P2y - P1y );
+ const B2DVector vecEndTangent( P4x - P3x, P4y - P3y );
+
+ const double scalarVecStartTangentAD( vecStartTangent.scalar( vecAD ) );
+ const double crossVecStartTangentAD( vecStartTangent.cross( vecAD ) );
+
+ const double scalarVecDBEndTangent( vecDB.scalar( vecEndTangent ) );
+ const double crossVecDBEndTangent( vecDB.cross( vecEndTangent ) );
+
+
+ double fCurrAngle( ::std::numeric_limits<double>::max() );
+
+ // anyone has zero denominator? then we're at
+ // +infinity, anyway
+ if( !fTools::equalZero( scalarVecADDB ) &&
+ !fTools::equalZero( scalarVecStartTangentAD ) &&
+ !fTools::equalZero( scalarVecDBEndTangent ) )
{
- // Test angle differences between two lines (ad
- // and bd), meeting in the t=0.5 division point
- // (d), and the angle from the other ends of those
- // lines (b and a, resp.) to the tangents to the
- // curve at this points:
- //
- // *__________
- // ......*b
- // ...
- // ..
- // .
- // * *d
- // | .
- // | .
- // | .
- // | .
- // |.
- // |.
- // *
- // a
- //
- // When using half of the angle bound for the
- // difference to the tangents at a or b, resp.,
- // this procedure guarantees that no angle in the
- // resulting line polygon is larger than the
- // specified angle bound. This is because during
- // subdivision, adjacent curve segments will have
- // collinear tangent vectors, thus, when each
- // side's line segments differs by at most angle/2
- // from that tangent, the summed difference will
- // be at most angle (this was modeled after an
- // idea from Armin Weiss).
-
- // To stay within the notation above, a equals P1,
- // the other end point of the tangent starting at
- // a is P2, d is Pd, and so forth. The
- const vector::B2DVector vecAD( Pdx - P1x, Pdy - P1y );
- const vector::B2DVector vecDB( P4x - Pdx, P4y - Pdy );
-
- const double scalarVecADDB( vecAD.scalar( vecDB ) );
- const double crossVecADDB( vecAD.cross( vecDB ) );
-
- const vector::B2DVector vecStartTangent( P2x - P1x, P2y - P1y );
- const vector::B2DVector vecEndTangent( P4x - P3x, P4y - P3y );
-
- const double scalarVecStartTangentAD( vecStartTangent.scalar( vecAD ) );
- const double crossVecStartTangentAD( vecStartTangent.cross( vecAD ) );
-
- const double scalarVecDBEndTangent( vecDB.scalar( vecEndTangent ) );
- const double crossVecDBEndTangent( vecDB.cross( vecEndTangent ) );
-
-
- double fCurrAngle( ::std::numeric_limits<double>::max() );
-
- // anyone has zero denominator? then we're at
- // +infinity, anyway
- if( !numeric::fTools::equalZero( scalarVecADDB ) &&
- !numeric::fTools::equalZero( scalarVecStartTangentAD ) &&
- !numeric::fTools::equalZero( scalarVecDBEndTangent ) )
+ if( scalarVecADDB > 0.0 &&
+ scalarVecStartTangentAD > 0.0 &&
+ scalarVecDBEndTangent > 0.0 )
{
- if( scalarVecADDB > 0.0 &&
- scalarVecStartTangentAD > 0.0 &&
- scalarVecDBEndTangent > 0.0 )
- {
- fCurrAngle = ::std::max( fabs( atan2( crossVecADDB, scalarVecADDB ) ),
- ::std::max( fabs( atan2( crossVecStartTangentAD, scalarVecStartTangentAD ) ),
- fabs( atan2( crossVecDBEndTangent, scalarVecDBEndTangent ) ) ) );
- }
+ fCurrAngle = ::std::max( fabs( atan2( crossVecADDB, scalarVecADDB ) ),
+ ::std::max( fabs( atan2( crossVecStartTangentAD, scalarVecStartTangentAD ) ),
+ fabs( atan2( crossVecDBEndTangent, scalarVecDBEndTangent ) ) ) );
}
+ }
- // stop if error measure does not improve anymore. This is a
- // safety guard against floating point inaccuracies.
- // stop if angle difference is guaranteed to be bounded by mfTanAngle
- bool bRet( mfLastTanAngle > fCurrAngle &&
- fCurrAngle >= mfTanAngle );
+ // stop if error measure does not improve anymore. This is a
+ // safety guard against floating point inaccuracies.
+ // stop if angle difference is guaranteed to be bounded by mfTanAngle
+ bool bRet( mfLastTanAngle > fCurrAngle &&
+ fCurrAngle >= mfTanAngle );
- mfLastTanAngle = fCurrAngle;
+ mfLastTanAngle = fCurrAngle;
- return bRet;
- }
+ return bRet;
+ }
- private:
- double mfTanAngle;
- double mfLastTanAngle;
- };
+ private:
+ double mfTanAngle;
+ double mfLastTanAngle;
+ };
- /* Recursively subdivide cubic bezier curve via deCasteljau.
+ /* Recursively subdivide cubic bezier curve via deCasteljau.
- @param rPoly
- Polygon to append generated points to
+ @param rPoly
+ Polygon to append generated points to
- @param d2
- Maximal squared difference of curve to a straight line
+ @param d2
+ Maximal squared difference of curve to a straight line
- @param P*
- Exactly four points, interpreted as support and control points of
- a cubic bezier curve.
+ @param P*
+ Exactly four points, interpreted as support and control points of
+ a cubic bezier curve.
- @param old_distance2
- Last squared distance to line for this recursion
- path. Used as an end condition, if it is no longer
- improving.
+ @param old_distance2
+ Last squared distance to line for this recursion
+ path. Used as an end condition, if it is no longer
+ improving.
- @param recursionDepth
- Depth of recursion. Used as a termination criterion, to
- prevent endless looping.
- */
- template < class ErrorFunctor > int ImplAdaptiveSubdivide( polygon::B2DPolygon& rPoly,
- ErrorFunctor rErrorFunctor,
- const double P1x, const double P1y,
- const double P2x, const double P2y,
- const double P3x, const double P3y,
- const double P4x, const double P4y,
- int recursionDepth )
+ @param recursionDepth
+ Depth of recursion. Used as a termination criterion, to
+ prevent endless looping.
+ */
+ template < class ErrorFunctor > int ImplAdaptiveSubdivide( B2DPolygon& rPoly,
+ ErrorFunctor rErrorFunctor,
+ const double P1x, const double P1y,
+ const double P2x, const double P2y,
+ const double P3x, const double P3y,
+ const double P4x, const double P4y,
+ int recursionDepth )
+ {
+ // Hard limit on recursion depth, empiric number.
+ enum {maxRecursionDepth=128};
+
+ // deCasteljau bezier arc, split at t=0.5
+ // Foley/vanDam, p. 508
+
+ // Note that for the pure distance error method, this
+ // subdivision could be moved into the if-branch. But
+ // since this accounts for saved work only for the
+ // very last subdivision step, and we need the
+ // subdivided curve for the angle criterium, I think
+ // it's justified here.
+ const double L1x( P1x ), L1y( P1y );
+ const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
+ const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
+ const double L3x( (L2x + Hx)*0.5 ), L3y( (L2y + Hy)*0.5 );
+ const double R4x( P4x ), R4y( P4y );
+ const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
+ const double R2x( (Hx + R3x)*0.5 ), R2y( (Hy + R3y)*0.5 );
+ const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
+ const double L4x( R1x ), L4y( R1y );
+
+ // stop at recursion level 128. This is a safety guard against
+ // floating point inaccuracies.
+ if( recursionDepth < maxRecursionDepth &&
+ rErrorFunctor.subdivideFurther( P1x, P1y,
+ P2x, P2y,
+ P3x, P3y,
+ P4x, P4y,
+ R1x, R1y ) )
{
- // Hard limit on recursion depth, empiric number.
- enum {maxRecursionDepth=128};
-
- // deCasteljau bezier arc, split at t=0.5
- // Foley/vanDam, p. 508
-
- // Note that for the pure distance error method, this
- // subdivision could be moved into the if-branch. But
- // since this accounts for saved work only for the
- // very last subdivision step, and we need the
- // subdivided curve for the angle criterium, I think
- // it's justified here.
- const double L1x( P1x ), L1y( P1y );
- const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
- const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
- const double L3x( (L2x + Hx)*0.5 ), L3y( (L2y + Hy)*0.5 );
- const double R4x( P4x ), R4y( P4y );
- const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
- const double R2x( (Hx + R3x)*0.5 ), R2y( (Hy + R3y)*0.5 );
- const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
- const double L4x( R1x ), L4y( R1y );
-
- // stop at recursion level 128. This is a safety guard against
- // floating point inaccuracies.
- if( recursionDepth < maxRecursionDepth &&
- rErrorFunctor.subdivideFurther( P1x, P1y,
- P2x, P2y,
- P3x, P3y,
- P4x, P4y,
- R1x, R1y ) )
- {
- // subdivide further
- ++recursionDepth;
+ // subdivide further
+ ++recursionDepth;
- int nGeneratedPoints(0);
+ int nGeneratedPoints(0);
- nGeneratedPoints += ImplAdaptiveSubdivide(rPoly, rErrorFunctor, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y, recursionDepth);
- nGeneratedPoints += ImplAdaptiveSubdivide(rPoly, rErrorFunctor, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y, recursionDepth);
+ nGeneratedPoints += ImplAdaptiveSubdivide(rPoly, rErrorFunctor, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y, recursionDepth);
+ nGeneratedPoints += ImplAdaptiveSubdivide(rPoly, rErrorFunctor, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y, recursionDepth);
- // return number of points generated in this
- // recursion branch
- return nGeneratedPoints;
- }
- else
- {
- // requested resolution reached. Add end points to
- // output iterator. order is preserved, since
- // this is so to say depth first traversal.
- rPoly.append( point::B2DPoint( P1x, P1y ) );
-
- // return number of points generated in this
- // recursion branch
- return 1;
- }
+ // return number of points generated in this
+ // recursion branch
+ return nGeneratedPoints;
}
+ else
+ {
+ // requested resolution reached. Add end points to
+ // output iterator. order is preserved, since
+ // this is so to say depth first traversal.
+ rPoly.append( B2DPoint( P1x, P1y ) );
+
+ // return number of points generated in this
+ // recursion branch
+ return 1;
+ }
+ }
// LATER
#if 0
- /* Approximate given cubic bezier curve by quadratic bezier segments */
- void ImplQuadBezierApprox( polygon::B2DPolygon& rPoly,
- BitStream& rBits,
- Point& rLastPoint,
- const double d2,
- const double P1x, const double P1y,
- const double P2x, const double P2y,
- const double P3x, const double P3y,
- const double P4x, const double P4y )
+ /* Approximate given cubic bezier curve by quadratic bezier segments */
+ void ImplQuadBezierApprox( B2DPolygon& rPoly,
+ BitStream& rBits,
+ Point& rLastPoint,
+ const double d2,
+ const double P1x, const double P1y,
+ const double P2x, const double P2y,
+ const double P3x, const double P3y,
+ const double P4x, const double P4y )
+ {
+ // Check for degenerate case, where the given cubic bezier curve
+ // is already quadratic: P4 == 3P3 - 3P2 + P1
+ if( P4x == 3.0*P3x - 3.0*P2x + P1x &&
+ P4y == 3.0*P3y - 3.0*P2y + P1y )
+ {
+ Impl_addQuadBezier( rBits, rLastPoint,
+ 3.0/2.0*P2x - 1.0/2.0*P1x, 3.0/2.0*P2y - 1.0/2.0*P1y,
+ P4x, P4y);
+ }
+ else
{
- // Check for degenerate case, where the given cubic bezier curve
- // is already quadratic: P4 == 3P3 - 3P2 + P1
- if( P4x == 3.0*P3x - 3.0*P2x + P1x &&
- P4y == 3.0*P3y - 3.0*P2y + P1y )
+ // Create quadratic segment for given cubic:
+ // Start and end point must coincide, determine quadratic control
+ // point in such a way that it lies on the intersection of the
+ // tangents at start and end point, resp. Thus, both cubic and
+ // quadratic curve segments will match in 0th and 1st derivative
+ // at the start and end points
+
+ // Intersection of P2P1 and P4P3
+ // (P2y-P4y)(P3x-P4x)-(P2x-P4x)(P3y-P4y)
+ // lambda = -------------------------------------
+ // (P1x-P2x)(P3y-P4y)-(P1y-P2y)(P3x-P4x)
+ //
+ // Intersection point IP is now
+ // IP = P2 + lambda(P1-P2)
+ //
+ const double nominator( (P2y-P4y)*(P3x-P4x) - (P2x-P4x)*(P3y-P4y) );
+ const double denominator( (P1x-P2x)*(P3y-P4y) - (P1y-P2y)*(P3x-P4x) );
+ const double lambda( nominator / denominator );
+
+ const double IPx( P2x + lambda*( P1x - P2x) );
+ const double IPy( P2y + lambda*( P1y - P2y) );
+
+ // Introduce some alias names: quadratic start point is P1, end
+ // point is P4, control point is IP
+ const double QP1x( P1x );
+ const double QP1y( P1y );
+ const double QP2x( IPx );
+ const double QP2y( IPy );
+ const double QP3x( P4x );
+ const double QP3y( P4y );
+
+ // Adapted bezier flatness test (lecture notes from R. Schaback,
+ // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
+ //
+ // ||C(t) - Q(t)|| <= max ||c_j - q_j||
+ // 0<=j<=n
+ //
+ // In this case, we don't need the distance from the cubic bezier
+ // to a straight line, but to a quadratic bezier. The c_j's are
+ // the cubic bezier's bernstein coefficients, the q_j's the
+ // quadratic bezier's. We have the c_j's given, the q_j's can be
+ // calculated from QPi like this (sorry, mixed index notation, we
+ // use [1,n], formulas use [0,n-1]):
+ //
+ // q_0 = QP1 = P1
+ // q_1 = 1/3 QP1 + 2/3 QP2
+ // q_2 = 2/3 QP2 + 1/3 QP3
+ // q_3 = QP3 = P4
+ //
+ // We can drop case 0 and 3, since there the curves coincide
+ // (distance is zero)
+
+ // calculate argument of max for j=1 and j=2
+ const double fJ1x( P2x - 1.0/3.0*QP1x - 2.0/3.0*QP2x );
+ const double fJ1y( P2y - 1.0/3.0*QP1y - 2.0/3.0*QP2y );
+ const double fJ2x( P3x - 2.0/3.0*QP2x - 1.0/3.0*QP3x );
+ const double fJ2y( P3y - 2.0/3.0*QP2y - 1.0/3.0*QP3y );
+
+ // stop if distance from cubic curve is guaranteed to be bounded by d
+ // Should denominator be 0: then P1P2 and P3P4 are parallel (P1P2^T R[90,P3P4] = 0.0),
+ // meaning that either we have a straight line or an inflexion point (see else block below)
+ if( 0.0 != denominator &&
+ ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
+ fJ2x*fJ2x + fJ2y*fJ2y) < d2 )
{
+ // requested resolution reached.
+ // Add end points to output file.
+ // order is preserved, since this is so to say depth first traversal.
Impl_addQuadBezier( rBits, rLastPoint,
- 3.0/2.0*P2x - 1.0/2.0*P1x, 3.0/2.0*P2y - 1.0/2.0*P1y,
- P4x, P4y);
+ QP2x, QP2y,
+ QP3x, QP3y);
}
else
{
- // Create quadratic segment for given cubic:
- // Start and end point must coincide, determine quadratic control
- // point in such a way that it lies on the intersection of the
- // tangents at start and end point, resp. Thus, both cubic and
- // quadratic curve segments will match in 0th and 1st derivative
- // at the start and end points
-
- // Intersection of P2P1 and P4P3
- // (P2y-P4y)(P3x-P4x)-(P2x-P4x)(P3y-P4y)
- // lambda = -------------------------------------
- // (P1x-P2x)(P3y-P4y)-(P1y-P2y)(P3x-P4x)
- //
- // Intersection point IP is now
- // IP = P2 + lambda(P1-P2)
- //
- const double nominator( (P2y-P4y)*(P3x-P4x) - (P2x-P4x)*(P3y-P4y) );
- const double denominator( (P1x-P2x)*(P3y-P4y) - (P1y-P2y)*(P3x-P4x) );
- const double lambda( nominator / denominator );
-
- const double IPx( P2x + lambda*( P1x - P2x) );
- const double IPy( P2y + lambda*( P1y - P2y) );
-
- // Introduce some alias names: quadratic start point is P1, end
- // point is P4, control point is IP
- const double QP1x( P1x );
- const double QP1y( P1y );
- const double QP2x( IPx );
- const double QP2y( IPy );
- const double QP3x( P4x );
- const double QP3y( P4y );
-
- // Adapted bezier flatness test (lecture notes from R. Schaback,
+ // Maybe subdivide further
+
+ // This is for robustness reasons, since the line intersection
+ // method below gets instable if the curve gets closer to a
+ // straight line. If the given cubic bezier does not deviate by
+ // more than d/4 from a straight line, either:
+ // - take the line (that's what we do here)
+ // - express the line by a quadratic bezier
+
+ // Perform bezier flatness test (lecture notes from R. Schaback,
// Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
//
- // ||C(t) - Q(t)|| <= max ||c_j - q_j||
+ // ||P(t) - L(t)|| <= max ||b_j - b_0 - j/n(b_n - b_0)||
// 0<=j<=n
//
- // In this case, we don't need the distance from the cubic bezier
- // to a straight line, but to a quadratic bezier. The c_j's are
- // the cubic bezier's bernstein coefficients, the q_j's the
- // quadratic bezier's. We have the c_j's given, the q_j's can be
- // calculated from QPi like this (sorry, mixed index notation, we
- // use [1,n], formulas use [0,n-1]):
- //
- // q_0 = QP1 = P1
- // q_1 = 1/3 QP1 + 2/3 QP2
- // q_2 = 2/3 QP2 + 1/3 QP3
- // q_3 = QP3 = P4
- //
- // We can drop case 0 and 3, since there the curves coincide
- // (distance is zero)
-
- // calculate argument of max for j=1 and j=2
- const double fJ1x( P2x - 1.0/3.0*QP1x - 2.0/3.0*QP2x );
- const double fJ1y( P2y - 1.0/3.0*QP1y - 2.0/3.0*QP2y );
- const double fJ2x( P3x - 2.0/3.0*QP2x - 1.0/3.0*QP3x );
- const double fJ2y( P3y - 2.0/3.0*QP2y - 1.0/3.0*QP3y );
-
- // stop if distance from cubic curve is guaranteed to be bounded by d
- // Should denominator be 0: then P1P2 and P3P4 are parallel (P1P2^T R[90,P3P4] = 0.0),
- // meaning that either we have a straight line or an inflexion point (see else block below)
- if( 0.0 != denominator &&
- ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
- fJ2x*fJ2x + fJ2y*fJ2y) < d2 )
+ // What is calculated here is an upper bound to the distance from
+ // a line through b_0 and b_3 (P1 and P4 in our notation) and the
+ // curve. We can drop 0 and n from the running indices, since the
+ // argument of max becomes zero for those cases.
+ const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
+ const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
+ const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
+ const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
+
+ // stop if distance from line is guaranteed to be bounded by d/4
+ if( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
+ fJ2x*fJ2x + fJ2y*fJ2y) < d2/16.0 )
{
- // requested resolution reached.
- // Add end points to output file.
- // order is preserved, since this is so to say depth first traversal.
- Impl_addQuadBezier( rBits, rLastPoint,
- QP2x, QP2y,
- QP3x, QP3y);
+ // do not subdivide further, add straight line instead
+ Impl_addStraightLine( rBits, rLastPoint, P4x, P4y);
}
else
{
- // Maybe subdivide further
-
- // This is for robustness reasons, since the line intersection
- // method below gets instable if the curve gets closer to a
- // straight line. If the given cubic bezier does not deviate by
- // more than d/4 from a straight line, either:
- // - take the line (that's what we do here)
- // - express the line by a quadratic bezier
-
- // Perform bezier flatness test (lecture notes from R. Schaback,
- // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
- //
- // ||P(t) - L(t)|| <= max ||b_j - b_0 - j/n(b_n - b_0)||
- // 0<=j<=n
- //
- // What is calculated here is an upper bound to the distance from
- // a line through b_0 and b_3 (P1 and P4 in our notation) and the
- // curve. We can drop 0 and n from the running indices, since the
- // argument of max becomes zero for those cases.
- const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
- const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
- const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
- const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
-
- // stop if distance from line is guaranteed to be bounded by d/4
- if( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
- fJ2x*fJ2x + fJ2y*fJ2y) < d2/16.0 )
- {
- // do not subdivide further, add straight line instead
- Impl_addStraightLine( rBits, rLastPoint, P4x, P4y);
- }
- else
- {
- // deCasteljau bezier arc, split at t=0.5
- // Foley/vanDam, p. 508
- const double L1x( P1x ), L1y( P1y );
- const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
- const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
- const double L3x( (L2x + Hx)*0.5 ), L3y( (L2y + Hy)*0.5 );
- const double R4x( P4x ), R4y( P4y );
- const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
- const double R2x( (Hx + R3x)*0.5 ), R2y( (Hy + R3y)*0.5 );
- const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
- const double L4x( R1x ), L4y( R1y );
-
- // subdivide further
- Impl_quadBezierApprox(rBits, rLastPoint, d2, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y);
- Impl_quadBezierApprox(rBits, rLastPoint, d2, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y);
- }
+ // deCasteljau bezier arc, split at t=0.5
+ // Foley/vanDam, p. 508
+ const double L1x( P1x ), L1y( P1y );
+ const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
+ const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
+ const double L3x( (L2x + Hx)*0.5 ), L3y( (L2y + Hy)*0.5 );
+ const double R4x( P4x ), R4y( P4y );
+ const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
+ const double R2x( (Hx + R3x)*0.5 ), R2y( (Hy + R3y)*0.5 );
+ const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
+ const double L4x( R1x ), L4y( R1y );
+
+ // subdivide further
+ Impl_quadBezierApprox(rBits, rLastPoint, d2, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y);
+ Impl_quadBezierApprox(rBits, rLastPoint, d2, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y);
}
}
}
-#endif
- }
-
- sal_Int32 adaptiveSubdivideByDistance( polygon::B2DPolygon& rPoly,
- const B2DCubicBezier& rCurve,
- double distanceBounds )
- {
- const point::B2DPoint start( rCurve.getStartPoint() );
- const point::B2DPoint control1( rCurve.getControlPointA() );
- const point::B2DPoint control2( rCurve.getControlPointB() );
- const point::B2DPoint end( rCurve.getEndPoint() );
-
- return ImplAdaptiveSubdivide( rPoly,
- DistanceErrorFunctor( distanceBounds ),
- start.getX(), start.getY(),
- control1.getX(), control1.getY(),
- control2.getX(), control2.getY(),
- end.getX(), end.getY(),
- 0 );
}
+#endif
+ }
- sal_Int32 adaptiveSubdivideByAngle( polygon::B2DPolygon& rPoly,
+ sal_Int32 adaptiveSubdivideByDistance( B2DPolygon& rPoly,
const B2DCubicBezier& rCurve,
- double angleBounds )
- {
- const point::B2DPoint start( rCurve.getStartPoint() );
- const point::B2DPoint control1( rCurve.getControlPointA() );
- const point::B2DPoint control2( rCurve.getControlPointB() );
- const point::B2DPoint end( rCurve.getEndPoint() );
-
- return ImplAdaptiveSubdivide( rPoly,
- AngleErrorFunctor( angleBounds ),
- start.getX(), start.getY(),
- control1.getX(), control1.getY(),
- control2.getX(), control2.getY(),
- end.getX(), end.getY(),
- 0 );
- }
+ double distanceBounds )
+ {
+ const B2DPoint start( rCurve.getStartPoint() );
+ const B2DPoint control1( rCurve.getControlPointA() );
+ const B2DPoint control2( rCurve.getControlPointB() );
+ const B2DPoint end( rCurve.getEndPoint() );
+
+ return ImplAdaptiveSubdivide( rPoly,
+ DistanceErrorFunctor( distanceBounds ),
+ start.getX(), start.getY(),
+ control1.getX(), control1.getY(),
+ control2.getX(), control2.getY(),
+ end.getX(), end.getY(),
+ 0 );
+ }
- sal_Int32 adaptiveSubdivideByDistance( polygon::B2DPolygon& rPoly,
- const B2DQuadraticBezier& rCurve,
- double distanceBounds )
- {
- // TODO
- return 0;
- }
+ sal_Int32 adaptiveSubdivideByAngle( B2DPolygon& rPoly,
+ const B2DCubicBezier& rCurve,
+ double angleBounds )
+ {
+ const B2DPoint start( rCurve.getStartPoint() );
+ const B2DPoint control1( rCurve.getControlPointA() );
+ const B2DPoint control2( rCurve.getControlPointB() );
+ const B2DPoint end( rCurve.getEndPoint() );
+
+ return ImplAdaptiveSubdivide( rPoly,
+ AngleErrorFunctor( angleBounds ),
+ start.getX(), start.getY(),
+ control1.getX(), control1.getY(),
+ control2.getX(), control2.getY(),
+ end.getX(), end.getY(),
+ 0 );
+ }
+
+ sal_Int32 adaptiveSubdivideByDistance( B2DPolygon& rPoly,
+ const B2DQuadraticBezier& rCurve,
+ double distanceBounds )
+ {
+ // TODO
+ return 0;
}
}
diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index 9633aa6b5130..33f6fdb8f1ca 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dcubicbezier.cxx,v $
*
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:07 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:00 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -67,90 +67,86 @@
namespace basegfx
{
- namespace curve
+ B2DCubicBezier::B2DCubicBezier(const B2DCubicBezier& rBezier)
+ : maStartPoint(rBezier.maStartPoint),
+ maEndPoint(rBezier.maEndPoint),
+ maControlPointA(rBezier.maControlPointA),
+ maControlPointB(rBezier.maControlPointB)
{
- B2DCubicBezier::B2DCubicBezier(const B2DCubicBezier& rBezier)
- : maStartPoint(rBezier.maStartPoint),
- maEndPoint(rBezier.maEndPoint),
- maControlPointA(rBezier.maControlPointA),
- maControlPointB(rBezier.maControlPointB)
- {
- }
-
- B2DCubicBezier::B2DCubicBezier()
- {
- }
-
- B2DCubicBezier::B2DCubicBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rEnd)
- : maStartPoint(rStart),
- maEndPoint(rEnd),
- maControlPointA(rStart),
- maControlPointB(rEnd)
- {
- }
+ }
- B2DCubicBezier::B2DCubicBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rControlPointA,
- const ::basegfx::point::B2DPoint& rControlPointB, const ::basegfx::point::B2DPoint& rEnd)
- : maStartPoint(rStart),
- maEndPoint(rEnd),
- maControlPointA(rControlPointA),
- maControlPointB(rControlPointB)
- {
- }
-
- B2DCubicBezier::~B2DCubicBezier()
- {
- }
+ B2DCubicBezier::B2DCubicBezier()
+ {
+ }
- // assignment operator
- B2DCubicBezier& B2DCubicBezier::operator=(const B2DCubicBezier& rBezier)
- {
- maStartPoint = rBezier.maStartPoint;
- maEndPoint = rBezier.maEndPoint;
- maControlPointA = rBezier.maControlPointA;
- maControlPointB = rBezier.maControlPointB;
+ B2DCubicBezier::B2DCubicBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rEnd)
+ : maStartPoint(rStart),
+ maEndPoint(rEnd),
+ maControlPointA(rStart),
+ maControlPointB(rEnd)
+ {
+ }
+
+ B2DCubicBezier::B2DCubicBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rControlPointA,
+ const ::basegfx::B2DPoint& rControlPointB, const ::basegfx::B2DPoint& rEnd)
+ : maStartPoint(rStart),
+ maEndPoint(rEnd),
+ maControlPointA(rControlPointA),
+ maControlPointB(rControlPointB)
+ {
+ }
- return *this;
- }
+ B2DCubicBezier::~B2DCubicBezier()
+ {
+ }
- // compare operators
- sal_Bool B2DCubicBezier::operator==(const B2DCubicBezier& rBezier) const
- {
- return (
- maStartPoint == rBezier.maStartPoint
- && maEndPoint == rBezier.maEndPoint
- && maControlPointA == rBezier.maControlPointA
- && maControlPointB == rBezier.maControlPointB
- );
- }
+ // assignment operator
+ B2DCubicBezier& B2DCubicBezier::operator=(const B2DCubicBezier& rBezier)
+ {
+ maStartPoint = rBezier.maStartPoint;
+ maEndPoint = rBezier.maEndPoint;
+ maControlPointA = rBezier.maControlPointA;
+ maControlPointB = rBezier.maControlPointB;
- sal_Bool B2DCubicBezier::operator!=(const B2DCubicBezier& rBezier) const
- {
- return (
- maStartPoint != rBezier.maStartPoint
- || maEndPoint != rBezier.maEndPoint
- || maControlPointA != rBezier.maControlPointA
- || maControlPointB != rBezier.maControlPointB
- );
- }
+ return *this;
+ }
- // test if vectors are used
- sal_Bool B2DCubicBezier::isBezier() const
+ // compare operators
+ sal_Bool B2DCubicBezier::operator==(const B2DCubicBezier& rBezier) const
+ {
+ return (
+ maStartPoint == rBezier.maStartPoint
+ && maEndPoint == rBezier.maEndPoint
+ && maControlPointA == rBezier.maControlPointA
+ && maControlPointB == rBezier.maControlPointB
+ );
+ }
+
+ sal_Bool B2DCubicBezier::operator!=(const B2DCubicBezier& rBezier) const
+ {
+ return (
+ maStartPoint != rBezier.maStartPoint
+ || maEndPoint != rBezier.maEndPoint
+ || maControlPointA != rBezier.maControlPointA
+ || maControlPointB != rBezier.maControlPointB
+ );
+ }
+
+ // test if vectors are used
+ sal_Bool B2DCubicBezier::isBezier() const
+ {
+ if(maControlPointA != maStartPoint || maControlPointB != maEndPoint)
{
- if(maControlPointA != maStartPoint || maControlPointB != maEndPoint)
- {
- return sal_True;
- }
-
- return sal_False;
+ return sal_True;
}
- void B2DCubicBezier::testAndSolveTrivialBezier()
- {
- // TODO
- }
+ return sal_False;
+ }
- } // end of namespace curve
+ void B2DCubicBezier::testAndSolveTrivialBezier()
+ {
+ // TODO
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/curve/b2dquadraticbezier.cxx b/basegfx/source/curve/b2dquadraticbezier.cxx
index 607d10b4a7bc..2086a9d1b15e 100644
--- a/basegfx/source/curve/b2dquadraticbezier.cxx
+++ b/basegfx/source/curve/b2dquadraticbezier.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dquadraticbezier.cxx,v $
*
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:08 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:00 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,75 +71,72 @@
namespace basegfx
{
- namespace curve
+ B2DQuadraticBezier::B2DQuadraticBezier(const B2DQuadraticBezier& rBezier)
+ : maStartPoint(rBezier.maStartPoint),
+ maEndPoint(rBezier.maEndPoint),
+ maControlPoint(rBezier.maControlPoint)
{
- B2DQuadraticBezier::B2DQuadraticBezier(const B2DQuadraticBezier& rBezier)
- : maStartPoint(rBezier.maStartPoint),
- maEndPoint(rBezier.maEndPoint),
- maControlPoint(rBezier.maControlPoint)
- {
- }
+ }
- B2DQuadraticBezier::B2DQuadraticBezier()
- {
- }
+ B2DQuadraticBezier::B2DQuadraticBezier()
+ {
+ }
- B2DQuadraticBezier::B2DQuadraticBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rEnd)
- : maStartPoint(rStart),
- maEndPoint(rEnd)
- {
- }
+ B2DQuadraticBezier::B2DQuadraticBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rEnd)
+ : maStartPoint(rStart),
+ maEndPoint(rEnd)
+ {
+ }
- B2DQuadraticBezier::B2DQuadraticBezier(const ::basegfx::point::B2DPoint& rStart, const ::basegfx::point::B2DPoint& rControl, const ::basegfx::point::B2DPoint& rEnd)
- : maStartPoint(rStart),
- maEndPoint(rEnd),
- maControlPoint(rControl)
- {
- }
+ B2DQuadraticBezier::B2DQuadraticBezier(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rControl, const ::basegfx::B2DPoint& rEnd)
+ : maStartPoint(rStart),
+ maEndPoint(rEnd),
+ maControlPoint(rControl)
+ {
+ }
- B2DQuadraticBezier::~B2DQuadraticBezier()
- {
- }
+ B2DQuadraticBezier::~B2DQuadraticBezier()
+ {
+ }
- // assignment operator
- B2DQuadraticBezier& B2DQuadraticBezier::operator=(const B2DQuadraticBezier& rBezier)
- {
- maStartPoint = rBezier.maStartPoint;
- maEndPoint = rBezier.maEndPoint;
- maControlPoint = rBezier.maControlPoint;
+ // assignment operator
+ B2DQuadraticBezier& B2DQuadraticBezier::operator=(const B2DQuadraticBezier& rBezier)
+ {
+ maStartPoint = rBezier.maStartPoint;
+ maEndPoint = rBezier.maEndPoint;
+ maControlPoint = rBezier.maControlPoint;
- return *this;
- }
+ return *this;
+ }
- // compare operators
- sal_Bool B2DQuadraticBezier::operator==(const B2DQuadraticBezier& rBezier) const
- {
- return (
- maStartPoint == rBezier.maStartPoint
- && maEndPoint == rBezier.maEndPoint
- && maControlPoint == rBezier.maControlPoint
- );
- }
+ // compare operators
+ sal_Bool B2DQuadraticBezier::operator==(const B2DQuadraticBezier& rBezier) const
+ {
+ return (
+ maStartPoint == rBezier.maStartPoint
+ && maEndPoint == rBezier.maEndPoint
+ && maControlPoint == rBezier.maControlPoint
+ );
+ }
- sal_Bool B2DQuadraticBezier::operator!=(const B2DQuadraticBezier& rBezier) const
- {
- return (
- maStartPoint != rBezier.maStartPoint
- || maEndPoint != rBezier.maEndPoint
- || maControlPoint != rBezier.maControlPoint
- );
- }
+ sal_Bool B2DQuadraticBezier::operator!=(const B2DQuadraticBezier& rBezier) const
+ {
+ return (
+ maStartPoint != rBezier.maStartPoint
+ || maEndPoint != rBezier.maEndPoint
+ || maControlPoint != rBezier.maControlPoint
+ );
+ }
- // test if control vector is used
- sal_Bool B2DQuadraticBezier::isBezier() const
- {
- // if control vector is empty, bezier is not used
- if(maControlPoint == maStartPoint || maControlPoint == maEndPoint)
- return sal_False;
+ // test if control vector is used
+ sal_Bool B2DQuadraticBezier::isBezier() const
+ {
+ // if control vector is empty, bezier is not used
+ if(maControlPoint == maStartPoint || maControlPoint == maEndPoint)
+ return sal_False;
- return sal_True;
- }
- } // end of namespace curve
+ return sal_True;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/inc/hommatrixtemplate.hxx b/basegfx/source/inc/hommatrixtemplate.hxx
index 9711dd4e3c01..4c688b09a218 100644
--- a/basegfx/source/inc/hommatrixtemplate.hxx
+++ b/basegfx/source/inc/hommatrixtemplate.hxx
@@ -2,9 +2,9 @@
*
* $RCSfile: hommatrixtemplate.hxx,v $
*
- * $Revision: 1.9 $
+ * $Revision: 1.10 $
*
- * last change: $Author: thb $ $Date: 2003-11-10 15:10:41 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:02 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -139,7 +139,7 @@ namespace basegfx
const double fDefault(implGetDefaultValue((RowSize - 1), a));
const double fLineValue(mpLine->get(a));
- if(!::basegfx::numeric::fTools::equal(fDefault, fLineValue))
+ if(!::basegfx::fTools::equal(fDefault, fLineValue))
{
return sal_False;
}
@@ -226,7 +226,7 @@ namespace basegfx
{
const double fDefault(implGetDefaultValue((RowSize - 1), nColumn));
- if(!::basegfx::numeric::fTools::equal(fDefault, rValue))
+ if(!::basegfx::fTools::equal(fDefault, rValue))
{
mpLine = new ImplMatLine< RowSize >((RowSize - 1), 0L);
mpLine->set(nColumn, rValue);
@@ -245,7 +245,7 @@ namespace basegfx
const double fDefault(implGetDefaultValue((RowSize - 1), a));
const double fLineValue(mpLine->get(a));
- if(!::basegfx::numeric::fTools::equal(fDefault, fLineValue))
+ if(!::basegfx::fTools::equal(fDefault, fLineValue))
{
bNecessary = sal_True;
}
@@ -278,13 +278,13 @@ namespace basegfx
{
double fTemp(fabs(get(a, b)));
- if(::basegfx::numeric::fTools::more(fTemp, fBig))
+ if(::basegfx::fTools::more(fTemp, fBig))
{
fBig = fTemp;
}
}
- if(::basegfx::numeric::fTools::equalZero(fBig))
+ if(::basegfx::fTools::equalZero(fBig))
{
return sal_False;
}
@@ -321,7 +321,7 @@ namespace basegfx
set(a, b, fSum);
fDum = fStorage[a] * fabs(fSum);
- if(::basegfx::numeric::fTools::moreOrEqual(fDum, fBig))
+ if(::basegfx::fTools::moreOrEqual(fDum, fBig))
{
fBig = fDum;
nAMax = a;
@@ -346,7 +346,7 @@ namespace basegfx
// here the failure of precision occurs
const double fValBB(fabs(get(b, b)));
- if(::basegfx::numeric::fTools::equalZero(fValBB))
+ if(::basegfx::fTools::equalZero(fValBB))
{
return sal_False;
}
@@ -384,7 +384,7 @@ namespace basegfx
fSum -= get(a, b) * fRow[b];
}
}
- else if(!::basegfx::numeric::fTools::equalZero(fSum))
+ else if(!::basegfx::fTools::equalZero(fSum))
{
a2 = a;
}
@@ -403,7 +403,7 @@ namespace basegfx
const double fValueAA(get(a, a));
- if(!::basegfx::numeric::fTools::equalZero(fValueAA))
+ if(!::basegfx::fTools::equalZero(fValueAA))
{
fRow[a] = fSum / get(a, a);
}
@@ -422,7 +422,7 @@ namespace basegfx
const double fDefault(implGetDefaultValue(a, b));
const double fValueAB(get(a, b));
- if(!::basegfx::numeric::fTools::equal(fDefault, fValueAB))
+ if(!::basegfx::fTools::equal(fDefault, fValueAB))
{
return sal_False;
}
@@ -448,14 +448,14 @@ namespace basegfx
const double fHomValue(get((RowSize - 1), (RowSize - 1)));
- if(::basegfx::numeric::fTools::equalZero(fHomValue))
+ if(::basegfx::fTools::equalZero(fHomValue))
{
return sal_True;
}
const double fOne(1.0);
- if(::basegfx::numeric::fTools::equal(fOne, fHomValue))
+ if(::basegfx::fTools::equal(fOne, fHomValue))
{
return sal_True;
}
@@ -634,7 +634,7 @@ namespace basegfx
const double fValueA(get(a, b));
const double fValueB(rMat.get(a, b));
- if(!::basegfx::numeric::fTools::equal(fValueA, fValueB))
+ if(!::basegfx::fTools::equal(fValueA, fValueB))
{
return sal_False;
}
diff --git a/basegfx/source/matrix/b2dhommatrix.cxx b/basegfx/source/matrix/b2dhommatrix.cxx
index d2175b502db3..ae36adfd72f9 100644
--- a/basegfx/source/matrix/b2dhommatrix.cxx
+++ b/basegfx/source/matrix/b2dhommatrix.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dhommatrix.cxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: thb $ $Date: 2003-11-10 15:10:57 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:02 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -81,336 +81,333 @@
namespace basegfx
{
- namespace matrix
+ class Impl2DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 3 >
{
- class Impl2DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 3 >
- {
- };
+ };
- static Impl2DHomMatrix& get2DIdentityMatrix()
- {
- static Impl2DHomMatrix maStatic2DIdentityHomMatrix;
- return maStatic2DIdentityHomMatrix;
- }
+ static Impl2DHomMatrix& get2DIdentityMatrix()
+ {
+ static Impl2DHomMatrix maStatic2DIdentityHomMatrix;
+ return maStatic2DIdentityHomMatrix;
+ }
- void B2DHomMatrix::implPrepareChange()
+ void B2DHomMatrix::implPrepareChange()
+ {
+ if(mpM->getRefCount())
{
- if(mpM->getRefCount())
- {
- mpM->decRefCount();
- mpM = new Impl2DHomMatrix(*mpM);
- }
+ mpM->decRefCount();
+ mpM = new Impl2DHomMatrix(*mpM);
}
+ }
- B2DHomMatrix::B2DHomMatrix()
- : mpM(&get2DIdentityMatrix())
- {
- mpM->incRefCount();
- }
+ B2DHomMatrix::B2DHomMatrix()
+ : mpM(&get2DIdentityMatrix())
+ {
+ mpM->incRefCount();
+ }
- B2DHomMatrix::B2DHomMatrix(const B2DHomMatrix& rMat)
- : mpM(rMat.mpM)
- {
- mpM->incRefCount();
- }
+ B2DHomMatrix::B2DHomMatrix(const B2DHomMatrix& rMat)
+ : mpM(rMat.mpM)
+ {
+ mpM->incRefCount();
+ }
- B2DHomMatrix::~B2DHomMatrix()
- {
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
- }
+ B2DHomMatrix::~B2DHomMatrix()
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
+ }
- B2DHomMatrix& B2DHomMatrix::operator=(const B2DHomMatrix& rMat)
- {
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ B2DHomMatrix& B2DHomMatrix::operator=(const B2DHomMatrix& rMat)
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
- mpM = rMat.mpM;
- mpM->incRefCount();
+ mpM = rMat.mpM;
+ mpM->incRefCount();
- return *this;
- }
+ return *this;
+ }
- double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
- {
- return mpM->get(nRow, nColumn);
- }
+ double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
+ {
+ return mpM->get(nRow, nColumn);
+ }
- void B2DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
- {
- implPrepareChange();
- mpM->set(nRow, nColumn, fValue);
- }
+ void B2DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
+ {
+ implPrepareChange();
+ mpM->set(nRow, nColumn, fValue);
+ }
- sal_Bool B2DHomMatrix::isIdentity() const
- {
- if(mpM == &get2DIdentityMatrix())
- return sal_True;
+ sal_Bool B2DHomMatrix::isIdentity() const
+ {
+ if(mpM == &get2DIdentityMatrix())
+ return sal_True;
- return mpM->isIdentity();
- }
+ return mpM->isIdentity();
+ }
- void B2DHomMatrix::identity()
+ void B2DHomMatrix::identity()
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
+
+ mpM = &get2DIdentityMatrix();
+ mpM->incRefCount();
+ }
+
+ sal_Bool B2DHomMatrix::isInvertible() const
+ {
+ return mpM->isInvertible();
+ }
+
+ sal_Bool B2DHomMatrix::invert()
+ {
+ Impl2DHomMatrix aWork(*mpM);
+ sal_uInt16* pIndex = new sal_uInt16[mpM->getEdgeLength()];
+ sal_Int16 nParity;
+
+ if(aWork.ludcmp(pIndex, nParity))
{
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ implPrepareChange();
+ mpM->doInvert(aWork, pIndex);
+ delete pIndex;
- mpM = &get2DIdentityMatrix();
- mpM->incRefCount();
+ return sal_True;
}
- sal_Bool B2DHomMatrix::isInvertible() const
+ delete pIndex;
+ return sal_False;
+ }
+
+ sal_Bool B2DHomMatrix::isNormalized() const
+ {
+ return mpM->isNormalized();
+ }
+
+ void B2DHomMatrix::normalize()
+ {
+ if(!mpM->isNormalized())
{
- return mpM->isInvertible();
+ implPrepareChange();
+ mpM->doNormalize();
}
+ }
- sal_Bool B2DHomMatrix::invert()
- {
- Impl2DHomMatrix aWork(*mpM);
- sal_uInt16* pIndex = new sal_uInt16[mpM->getEdgeLength()];
- sal_Int16 nParity;
+ double B2DHomMatrix::determinant() const
+ {
+ return mpM->doDeterminant();
+ }
- if(aWork.ludcmp(pIndex, nParity))
- {
- implPrepareChange();
- mpM->doInvert(aWork, pIndex);
- delete pIndex;
+ double B2DHomMatrix::trace() const
+ {
+ return mpM->doTrace();
+ }
- return sal_True;
- }
+ void B2DHomMatrix::transpose()
+ {
+ implPrepareChange();
+ mpM->doTranspose();
+ }
- delete pIndex;
- return sal_False;
- }
+ B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
+ {
+ implPrepareChange();
+ mpM->doAddMatrix(*rMat.mpM);
- sal_Bool B2DHomMatrix::isNormalized() const
- {
- return mpM->isNormalized();
- }
+ return *this;
+ }
- void B2DHomMatrix::normalize()
- {
- if(!mpM->isNormalized())
- {
- implPrepareChange();
- mpM->doNormalize();
- }
- }
+ B2DHomMatrix& B2DHomMatrix::operator-=(const B2DHomMatrix& rMat)
+ {
+ implPrepareChange();
+ mpM->doSubMatrix(*rMat.mpM);
- double B2DHomMatrix::determinant() const
- {
- return mpM->doDeterminant();
- }
+ return *this;
+ }
- double B2DHomMatrix::trace() const
- {
- return mpM->doTrace();
- }
+ B2DHomMatrix& B2DHomMatrix::operator*=(double fValue)
+ {
+ const double fOne(1.0);
- void B2DHomMatrix::transpose()
+ if(!::basegfx::fTools::equal(fOne, fValue))
{
implPrepareChange();
- mpM->doTranspose();
+ mpM->doMulMatrix(fValue);
}
- B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
- {
- implPrepareChange();
- mpM->doAddMatrix(*rMat.mpM);
+ return *this;
+ }
- return *this;
- }
+ B2DHomMatrix& B2DHomMatrix::operator/=(double fValue)
+ {
+ const double fOne(1.0);
- B2DHomMatrix& B2DHomMatrix::operator-=(const B2DHomMatrix& rMat)
+ if(!::basegfx::fTools::equal(fOne, fValue))
{
implPrepareChange();
- mpM->doSubMatrix(*rMat.mpM);
-
- return *this;
+ mpM->doMulMatrix(1.0 / fValue);
}
- B2DHomMatrix& B2DHomMatrix::operator*=(double fValue)
- {
- const double fOne(1.0);
-
- if(!::basegfx::numeric::fTools::equal(fOne, fValue))
- {
- implPrepareChange();
- mpM->doMulMatrix(fValue);
- }
+ return *this;
+ }
- return *this;
- }
-
- B2DHomMatrix& B2DHomMatrix::operator/=(double fValue)
+ B2DHomMatrix& B2DHomMatrix::operator*=(const B2DHomMatrix& rMat)
+ {
+ if(!rMat.isIdentity())
{
- const double fOne(1.0);
-
- if(!::basegfx::numeric::fTools::equal(fOne, fValue))
- {
- implPrepareChange();
- mpM->doMulMatrix(1.0 / fValue);
- }
-
- return *this;
+ implPrepareChange();
+ mpM->doMulMatrix(*rMat.mpM);
}
- B2DHomMatrix& B2DHomMatrix::operator*=(const B2DHomMatrix& rMat)
- {
- if(!rMat.isIdentity())
- {
- implPrepareChange();
- mpM->doMulMatrix(*rMat.mpM);
- }
+ return *this;
+ }
- return *this;
- }
+ sal_Bool B2DHomMatrix::operator==(const B2DHomMatrix& rMat) const
+ {
+ if(mpM == rMat.mpM)
+ return sal_True;
- sal_Bool B2DHomMatrix::operator==(const B2DHomMatrix& rMat) const
- {
- if(mpM == rMat.mpM)
- return sal_True;
+ return mpM->isEqual(*rMat.mpM);
+ }
- return mpM->isEqual(*rMat.mpM);
- }
+ sal_Bool B2DHomMatrix::operator!=(const B2DHomMatrix& rMat) const
+ {
+ if(mpM == rMat.mpM)
+ return sal_False;
+
+ return !mpM->isEqual(*rMat.mpM);
+ }
- sal_Bool B2DHomMatrix::operator!=(const B2DHomMatrix& rMat) const
+ void B2DHomMatrix::rotate(double fRadiant)
+ {
+ if(!::basegfx::fTools::equalZero(fRadiant))
{
- if(mpM == rMat.mpM)
- return sal_False;
+ Impl2DHomMatrix aRotMat(get2DIdentityMatrix());
+ double fSin(sin(fRadiant));
+ double fCos(cos(fRadiant));
- return !mpM->isEqual(*rMat.mpM);
- }
+ aRotMat.set(0, 0, fCos);
+ aRotMat.set(1, 1, fCos);
+ aRotMat.set(1, 0, fSin);
+ aRotMat.set(0, 1, -fSin);
- void B2DHomMatrix::rotate(double fRadiant)
- {
- if(!::basegfx::numeric::fTools::equalZero(fRadiant))
- {
- Impl2DHomMatrix aRotMat(get2DIdentityMatrix());
- double fSin(sin(fRadiant));
- double fCos(cos(fRadiant));
-
- aRotMat.set(0, 0, fCos);
- aRotMat.set(1, 1, fCos);
- aRotMat.set(1, 0, fSin);
- aRotMat.set(0, 1, -fSin);
-
- implPrepareChange();
- mpM->doMulMatrix(aRotMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aRotMat);
}
+ }
- void B2DHomMatrix::translate(double fX, double fY)
+ void B2DHomMatrix::translate(double fX, double fY)
+ {
+ if(!::basegfx::fTools::equalZero(fX) || !::basegfx::fTools::equalZero(fY))
{
- if(!::basegfx::numeric::fTools::equalZero(fX) || !::basegfx::numeric::fTools::equalZero(fY))
- {
- Impl2DHomMatrix aTransMat(get2DIdentityMatrix());
+ Impl2DHomMatrix aTransMat(get2DIdentityMatrix());
- aTransMat.set(0, 2, fX);
- aTransMat.set(1, 2, fY);
+ aTransMat.set(0, 2, fX);
+ aTransMat.set(1, 2, fY);
- implPrepareChange();
- mpM->doMulMatrix(aTransMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aTransMat);
}
+ }
- void B2DHomMatrix::scale(double fX, double fY)
- {
- const double fOne(1.0);
+ void B2DHomMatrix::scale(double fX, double fY)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fX) || !::basegfx::numeric::fTools::equal(fOne, fY))
- {
- Impl2DHomMatrix aScaleMat(get2DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fX) || !::basegfx::fTools::equal(fOne, fY))
+ {
+ Impl2DHomMatrix aScaleMat(get2DIdentityMatrix());
- aScaleMat.set(0, 0, fX);
- aScaleMat.set(1, 1, fY);
+ aScaleMat.set(0, 0, fX);
+ aScaleMat.set(1, 1, fY);
- implPrepareChange();
- mpM->doMulMatrix(aScaleMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aScaleMat);
}
+ }
- void B2DHomMatrix::shearX(double fSx)
- {
- const double fOne(1.0);
+ void B2DHomMatrix::shearX(double fSx)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fSx))
- {
- Impl2DHomMatrix aShearXMat(get2DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fSx))
+ {
+ Impl2DHomMatrix aShearXMat(get2DIdentityMatrix());
- aShearXMat.set(0, 1, fSx);
+ aShearXMat.set(0, 1, fSx);
- implPrepareChange();
- mpM->doMulMatrix(aShearXMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aShearXMat);
}
+ }
- void B2DHomMatrix::shearY(double fSy)
- {
- const double fOne(1.0);
+ void B2DHomMatrix::shearY(double fSy)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fSy))
- {
- Impl2DHomMatrix aShearYMat(get2DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fSy))
+ {
+ Impl2DHomMatrix aShearYMat(get2DIdentityMatrix());
- aShearYMat.set(1, 0, fSy);
+ aShearYMat.set(1, 0, fSy);
- implPrepareChange();
- mpM->doMulMatrix(aShearYMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aShearYMat);
}
+ }
- // Decomposition
- sal_Bool B2DHomMatrix::decompose(tuple::B2DTuple& rScale, tuple::B2DTuple& rTranslate, double& rRotate, double& rShearX) const
- {
- // when perspective is used, decompose is not made here
- if(!mpM->isLastLineDefault())
- return sal_False;
-
- // If determinant is zero, decomposition is not possible
- if(0.0 == mpM->doDeterminant())
- return sal_False;
+ // Decomposition
+ sal_Bool B2DHomMatrix::decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const
+ {
+ // when perspective is used, decompose is not made here
+ if(!mpM->isLastLineDefault())
+ return sal_False;
- // copy 2x2 matrix and translate vector to 3x3 matrix
- ::basegfx::matrix::B3DHomMatrix a3DHomMat;
+ // If determinant is zero, decomposition is not possible
+ if(0.0 == mpM->doDeterminant())
+ return sal_False;
- a3DHomMat.set(0, 0, get(0, 0));
- a3DHomMat.set(0, 1, get(0, 1));
- a3DHomMat.set(1, 0, get(1, 0));
- a3DHomMat.set(1, 1, get(1, 1));
- a3DHomMat.set(0, 2, get(0, 3));
- a3DHomMat.set(1, 2, get(1, 3));
+ // copy 2x2 matrix and translate vector to 3x3 matrix
+ ::basegfx::B3DHomMatrix a3DHomMat;
- ::basegfx::tuple::B3DTuple r3DScale, r3DTranslate, r3DRotate, r3DShear;
+ a3DHomMat.set(0, 0, get(0, 0));
+ a3DHomMat.set(0, 1, get(0, 1));
+ a3DHomMat.set(1, 0, get(1, 0));
+ a3DHomMat.set(1, 1, get(1, 1));
+ a3DHomMat.set(0, 2, get(0, 3));
+ a3DHomMat.set(1, 2, get(1, 3));
- if(a3DHomMat.decompose(r3DScale, r3DTranslate, r3DRotate, r3DShear))
- {
- // copy scale values
- rScale.setX(r3DScale.getX());
- rScale.setY(r3DScale.getY());
+ ::basegfx::B3DTuple r3DScale, r3DTranslate, r3DRotate, r3DShear;
- // copy shear
- rShearX = r3DShear.getX();
+ if(a3DHomMat.decompose(r3DScale, r3DTranslate, r3DRotate, r3DShear))
+ {
+ // copy scale values
+ rScale.setX(r3DScale.getX());
+ rScale.setY(r3DScale.getY());
- // copy rotate
- rRotate = r3DRotate.getZ();
+ // copy shear
+ rShearX = r3DShear.getX();
- // copy translate
- rTranslate.setX(r3DTranslate.getX());
- rTranslate.setY(r3DTranslate.getY());
+ // copy rotate
+ rRotate = r3DRotate.getZ();
- return sal_True;
- }
+ // copy translate
+ rTranslate.setX(r3DTranslate.getX());
+ rTranslate.setY(r3DTranslate.getY());
- return sal_False;
+ return sal_True;
}
- } // end of namespace matrix
+
+ return sal_False;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/matrix/b3dhommatrix.cxx b/basegfx/source/matrix/b3dhommatrix.cxx
index dee47579741f..b6df9ff51767 100644
--- a/basegfx/source/matrix/b3dhommatrix.cxx
+++ b/basegfx/source/matrix/b3dhommatrix.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dhommatrix.cxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: thb $ $Date: 2003-11-10 15:10:57 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:03 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -73,567 +73,564 @@
namespace basegfx
{
- namespace matrix
+ class Impl3DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 4 >
{
- class Impl3DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 4 >
- {
- };
+ };
- static Impl3DHomMatrix& get3DIdentityMatrix()
- {
- static Impl3DHomMatrix maStatic3DIdentityHomMatrix;
- return maStatic3DIdentityHomMatrix;
- }
+ static Impl3DHomMatrix& get3DIdentityMatrix()
+ {
+ static Impl3DHomMatrix maStatic3DIdentityHomMatrix;
+ return maStatic3DIdentityHomMatrix;
+ }
- void B3DHomMatrix::implPrepareChange()
+ void B3DHomMatrix::implPrepareChange()
+ {
+ if(mpM->getRefCount())
{
- if(mpM->getRefCount())
- {
- mpM->decRefCount();
- mpM = new Impl3DHomMatrix(*mpM);
- }
+ mpM->decRefCount();
+ mpM = new Impl3DHomMatrix(*mpM);
}
+ }
- B3DHomMatrix::B3DHomMatrix()
- : mpM(&get3DIdentityMatrix())
- {
- mpM->incRefCount();
- }
+ B3DHomMatrix::B3DHomMatrix()
+ : mpM(&get3DIdentityMatrix())
+ {
+ mpM->incRefCount();
+ }
- B3DHomMatrix::B3DHomMatrix(const B3DHomMatrix& rMat)
- : mpM(rMat.mpM)
- {
- mpM->incRefCount();
- }
+ B3DHomMatrix::B3DHomMatrix(const B3DHomMatrix& rMat)
+ : mpM(rMat.mpM)
+ {
+ mpM->incRefCount();
+ }
- B3DHomMatrix::~B3DHomMatrix()
- {
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
- }
+ B3DHomMatrix::~B3DHomMatrix()
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
+ }
- B3DHomMatrix& B3DHomMatrix::operator=(const B3DHomMatrix& rMat)
- {
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ B3DHomMatrix& B3DHomMatrix::operator=(const B3DHomMatrix& rMat)
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
- mpM = rMat.mpM;
- mpM->incRefCount();
+ mpM = rMat.mpM;
+ mpM->incRefCount();
- return *this;
- }
+ return *this;
+ }
- double B3DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
- {
- return mpM->get(nRow, nColumn);
- }
+ double B3DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
+ {
+ return mpM->get(nRow, nColumn);
+ }
- void B3DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
- {
- implPrepareChange();
- mpM->set(nRow, nColumn, fValue);
- }
+ void B3DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
+ {
+ implPrepareChange();
+ mpM->set(nRow, nColumn, fValue);
+ }
- sal_Bool B3DHomMatrix::isIdentity() const
- {
- if(mpM == &get3DIdentityMatrix())
- return sal_True;
+ sal_Bool B3DHomMatrix::isIdentity() const
+ {
+ if(mpM == &get3DIdentityMatrix())
+ return sal_True;
- return mpM->isIdentity();
- }
+ return mpM->isIdentity();
+ }
+
+ void B3DHomMatrix::identity()
+ {
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
+
+ mpM = &get3DIdentityMatrix();
+ mpM->incRefCount();
+ }
+
+ sal_Bool B3DHomMatrix::isInvertible() const
+ {
+ return mpM->isInvertible();
+ }
+
+ sal_Bool B3DHomMatrix::invert()
+ {
+ Impl3DHomMatrix aWork(*mpM);
+ sal_uInt16* pIndex = new sal_uInt16[mpM->getEdgeLength()];
+ sal_Int16 nParity;
- void B3DHomMatrix::identity()
+ if(aWork.ludcmp(pIndex, nParity))
{
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ implPrepareChange();
+ mpM->doInvert(aWork, pIndex);
+ delete pIndex;
- mpM = &get3DIdentityMatrix();
- mpM->incRefCount();
+ return sal_True;
}
- sal_Bool B3DHomMatrix::isInvertible() const
+ delete pIndex;
+ return sal_False;
+ }
+
+ sal_Bool B3DHomMatrix::isNormalized() const
+ {
+ return mpM->isNormalized();
+ }
+
+ void B3DHomMatrix::normalize()
+ {
+ if(!mpM->isNormalized())
{
- return mpM->isInvertible();
+ implPrepareChange();
+ mpM->doNormalize();
}
+ }
- sal_Bool B3DHomMatrix::invert()
- {
- Impl3DHomMatrix aWork(*mpM);
- sal_uInt16* pIndex = new sal_uInt16[mpM->getEdgeLength()];
- sal_Int16 nParity;
+ double B3DHomMatrix::determinant() const
+ {
+ return mpM->doDeterminant();
+ }
- if(aWork.ludcmp(pIndex, nParity))
- {
- implPrepareChange();
- mpM->doInvert(aWork, pIndex);
- delete pIndex;
+ double B3DHomMatrix::trace() const
+ {
+ return mpM->doTrace();
+ }
- return sal_True;
- }
+ void B3DHomMatrix::transpose()
+ {
+ implPrepareChange();
+ mpM->doTranspose();
+ }
- delete pIndex;
- return sal_False;
- }
+ B3DHomMatrix& B3DHomMatrix::operator+=(const B3DHomMatrix& rMat)
+ {
+ implPrepareChange();
+ mpM->doAddMatrix(*rMat.mpM);
- sal_Bool B3DHomMatrix::isNormalized() const
- {
- return mpM->isNormalized();
- }
+ return *this;
+ }
- void B3DHomMatrix::normalize()
- {
- if(!mpM->isNormalized())
- {
- implPrepareChange();
- mpM->doNormalize();
- }
- }
+ B3DHomMatrix& B3DHomMatrix::operator-=(const B3DHomMatrix& rMat)
+ {
+ implPrepareChange();
+ mpM->doSubMatrix(*rMat.mpM);
- double B3DHomMatrix::determinant() const
- {
- return mpM->doDeterminant();
- }
+ return *this;
+ }
- double B3DHomMatrix::trace() const
- {
- return mpM->doTrace();
- }
+ B3DHomMatrix& B3DHomMatrix::operator*=(double fValue)
+ {
+ const double fOne(1.0);
- void B3DHomMatrix::transpose()
+ if(!::basegfx::fTools::equal(fOne, fValue))
{
implPrepareChange();
- mpM->doTranspose();
+ mpM->doMulMatrix(fValue);
}
- B3DHomMatrix& B3DHomMatrix::operator+=(const B3DHomMatrix& rMat)
+ return *this;
+ }
+
+ B3DHomMatrix& B3DHomMatrix::operator/=(double fValue)
+ {
+ const double fOne(1.0);
+
+ if(!::basegfx::fTools::equal(fOne, fValue))
{
implPrepareChange();
- mpM->doAddMatrix(*rMat.mpM);
-
- return *this;
+ mpM->doMulMatrix(1.0 / fValue);
}
- B3DHomMatrix& B3DHomMatrix::operator-=(const B3DHomMatrix& rMat)
+ return *this;
+ }
+
+ B3DHomMatrix& B3DHomMatrix::operator*=(const B3DHomMatrix& rMat)
+ {
+ if(!rMat.isIdentity())
{
implPrepareChange();
- mpM->doSubMatrix(*rMat.mpM);
-
- return *this;
+ mpM->doMulMatrix(*rMat.mpM);
}
- B3DHomMatrix& B3DHomMatrix::operator*=(double fValue)
- {
- const double fOne(1.0);
+ return *this;
+ }
- if(!::basegfx::numeric::fTools::equal(fOne, fValue))
- {
- implPrepareChange();
- mpM->doMulMatrix(fValue);
- }
+ sal_Bool B3DHomMatrix::operator==(const B3DHomMatrix& rMat) const
+ {
+ if(mpM == rMat.mpM)
+ return sal_True;
- return *this;
- }
+ return mpM->isEqual(*rMat.mpM);
+ }
+
+ sal_Bool B3DHomMatrix::operator!=(const B3DHomMatrix& rMat) const
+ {
+ if(mpM == rMat.mpM)
+ return sal_False;
- B3DHomMatrix& B3DHomMatrix::operator/=(double fValue)
+ return !mpM->isEqual(*rMat.mpM);
+ }
+
+ void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
+ {
+ if(!::basegfx::fTools::equalZero(fAngleX) || !::basegfx::fTools::equalZero(fAngleY) || !::basegfx::fTools::equalZero(fAngleZ))
{
- const double fOne(1.0);
+ implPrepareChange();
- if(!::basegfx::numeric::fTools::equal(fOne, fValue))
+ if(!::basegfx::fTools::equalZero(fAngleX))
{
- implPrepareChange();
- mpM->doMulMatrix(1.0 / fValue);
- }
+ Impl3DHomMatrix aRotMatX(get3DIdentityMatrix());
+ double fSin(sin(fAngleX));
+ double fCos(cos(fAngleX));
- return *this;
- }
+ aRotMatX.set(1, 1, fCos);
+ aRotMatX.set(2, 2, fCos);
+ aRotMatX.set(2, 1, fSin);
+ aRotMatX.set(1, 2, -fSin);
- B3DHomMatrix& B3DHomMatrix::operator*=(const B3DHomMatrix& rMat)
- {
- if(!rMat.isIdentity())
- {
- implPrepareChange();
- mpM->doMulMatrix(*rMat.mpM);
+ mpM->doMulMatrix(aRotMatX);
}
- return *this;
- }
+ if(!::basegfx::fTools::equalZero(fAngleY))
+ {
+ Impl3DHomMatrix aRotMatY(get3DIdentityMatrix());
+ double fSin(sin(fAngleY));
+ double fCos(cos(fAngleY));
- sal_Bool B3DHomMatrix::operator==(const B3DHomMatrix& rMat) const
- {
- if(mpM == rMat.mpM)
- return sal_True;
+ aRotMatY.set(0, 0, fCos);
+ aRotMatY.set(2, 2, fCos);
+ aRotMatY.set(0, 2, fSin);
+ aRotMatY.set(2, 0, -fSin);
- return mpM->isEqual(*rMat.mpM);
- }
+ mpM->doMulMatrix(aRotMatY);
+ }
- sal_Bool B3DHomMatrix::operator!=(const B3DHomMatrix& rMat) const
- {
- if(mpM == rMat.mpM)
- return sal_False;
+ if(!::basegfx::fTools::equalZero(fAngleZ))
+ {
+ Impl3DHomMatrix aRotMatZ(get3DIdentityMatrix());
+ double fSin(sin(fAngleZ));
+ double fCos(cos(fAngleZ));
- return !mpM->isEqual(*rMat.mpM);
- }
+ aRotMatZ.set(0, 0, fCos);
+ aRotMatZ.set(1, 1, fCos);
+ aRotMatZ.set(1, 0, fSin);
+ aRotMatZ.set(0, 1, -fSin);
- void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
- {
- if(!::basegfx::numeric::fTools::equalZero(fAngleX) || !::basegfx::numeric::fTools::equalZero(fAngleY) || !::basegfx::numeric::fTools::equalZero(fAngleZ))
- {
- implPrepareChange();
-
- if(!::basegfx::numeric::fTools::equalZero(fAngleX))
- {
- Impl3DHomMatrix aRotMatX(get3DIdentityMatrix());
- 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);
-
- mpM->doMulMatrix(aRotMatX);
- }
-
- if(!::basegfx::numeric::fTools::equalZero(fAngleY))
- {
- Impl3DHomMatrix aRotMatY(get3DIdentityMatrix());
- 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);
-
- mpM->doMulMatrix(aRotMatY);
- }
-
- if(!::basegfx::numeric::fTools::equalZero(fAngleZ))
- {
- Impl3DHomMatrix aRotMatZ(get3DIdentityMatrix());
- double fSin(sin(fAngleZ));
- double fCos(cos(fAngleZ));
-
- aRotMatZ.set(0, 0, fCos);
- aRotMatZ.set(1, 1, fCos);
- aRotMatZ.set(1, 0, fSin);
- aRotMatZ.set(0, 1, -fSin);
-
- mpM->doMulMatrix(aRotMatZ);
- }
+ mpM->doMulMatrix(aRotMatZ);
}
}
+ }
- void B3DHomMatrix::translate(double fX, double fY, double fZ)
+ void B3DHomMatrix::translate(double fX, double fY, double fZ)
+ {
+ if(!::basegfx::fTools::equalZero(fX) || !::basegfx::fTools::equalZero(fY) || !::basegfx::fTools::equalZero(fZ))
{
- if(!::basegfx::numeric::fTools::equalZero(fX) || !::basegfx::numeric::fTools::equalZero(fY) || !::basegfx::numeric::fTools::equalZero(fZ))
- {
- Impl3DHomMatrix aTransMat(get3DIdentityMatrix());
+ Impl3DHomMatrix aTransMat(get3DIdentityMatrix());
- aTransMat.set(0, 2, fX);
- aTransMat.set(1, 2, fY);
- aTransMat.set(2, 2, fZ);
+ aTransMat.set(0, 2, fX);
+ aTransMat.set(1, 2, fY);
+ aTransMat.set(2, 2, fZ);
- implPrepareChange();
- mpM->doMulMatrix(aTransMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aTransMat);
}
+ }
- void B3DHomMatrix::scale(double fX, double fY, double fZ)
- {
- const double fOne(1.0);
+ void B3DHomMatrix::scale(double fX, double fY, double fZ)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fX) || !::basegfx::numeric::fTools::equal(fOne, fY) ||!::basegfx::numeric::fTools::equal(fOne, fZ))
- {
- Impl3DHomMatrix aScaleMat(get3DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fX) || !::basegfx::fTools::equal(fOne, fY) ||!::basegfx::fTools::equal(fOne, fZ))
+ {
+ Impl3DHomMatrix aScaleMat(get3DIdentityMatrix());
- aScaleMat.set(0, 0, fX);
- aScaleMat.set(1, 1, fY);
- aScaleMat.set(2, 2, fZ);
+ aScaleMat.set(0, 0, fX);
+ aScaleMat.set(1, 1, fY);
+ aScaleMat.set(2, 2, fZ);
- implPrepareChange();
- mpM->doMulMatrix(aScaleMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aScaleMat);
}
+ }
- void B3DHomMatrix::shearXY(double fSx, double fSy)
- {
- const double fOne(1.0);
+ void B3DHomMatrix::shearXY(double fSx, double fSy)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fSx) || !::basegfx::numeric::fTools::equal(fOne, fSy))
- {
- Impl3DHomMatrix aShearXYMat(get3DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fSx) || !::basegfx::fTools::equal(fOne, fSy))
+ {
+ Impl3DHomMatrix aShearXYMat(get3DIdentityMatrix());
- aShearXYMat.set(0, 2, fSx);
- aShearXYMat.set(1, 2, fSy);
+ aShearXYMat.set(0, 2, fSx);
+ aShearXYMat.set(1, 2, fSy);
- implPrepareChange();
- mpM->doMulMatrix(aShearXYMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aShearXYMat);
}
+ }
- void B3DHomMatrix::shearYZ(double fSy, double fSz)
- {
- const double fOne(1.0);
+ void B3DHomMatrix::shearYZ(double fSy, double fSz)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fSy) || !::basegfx::numeric::fTools::equal(fOne, fSz))
- {
- Impl3DHomMatrix aShearYZMat(get3DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fSy) || !::basegfx::fTools::equal(fOne, fSz))
+ {
+ Impl3DHomMatrix aShearYZMat(get3DIdentityMatrix());
- aShearYZMat.set(1, 0, fSy);
- aShearYZMat.set(2, 0, fSz);
+ aShearYZMat.set(1, 0, fSy);
+ aShearYZMat.set(2, 0, fSz);
- implPrepareChange();
- mpM->doMulMatrix(aShearYZMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aShearYZMat);
}
+ }
- void B3DHomMatrix::shearXZ(double fSx, double fSz)
- {
- const double fOne(1.0);
+ void B3DHomMatrix::shearXZ(double fSx, double fSz)
+ {
+ const double fOne(1.0);
- if(!::basegfx::numeric::fTools::equal(fOne, fSx) || !::basegfx::numeric::fTools::equal(fOne, fSz))
- {
- Impl3DHomMatrix aShearXZMat(get3DIdentityMatrix());
+ if(!::basegfx::fTools::equal(fOne, fSx) || !::basegfx::fTools::equal(fOne, fSz))
+ {
+ Impl3DHomMatrix aShearXZMat(get3DIdentityMatrix());
- aShearXZMat.set(0, 1, fSx);
- aShearXZMat.set(2, 1, fSz);
+ aShearXZMat.set(0, 1, fSx);
+ aShearXZMat.set(2, 1, fSz);
- implPrepareChange();
- mpM->doMulMatrix(aShearXZMat);
- }
+ implPrepareChange();
+ mpM->doMulMatrix(aShearXZMat);
}
+ }
- void B3DHomMatrix::frustum(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
+ void B3DHomMatrix::frustum(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
+ {
+ const double fZero(0.0);
+ const double fOne(1.0);
+
+ if(!::basegfx::fTools::more(fNear, fZero))
{
- const double fZero(0.0);
- const double fOne(1.0);
+ fNear = 0.001;
+ }
- if(!::basegfx::numeric::fTools::more(fNear, fZero))
- {
- fNear = 0.001;
- }
+ if(!::basegfx::fTools::more(fFar, fZero))
+ {
+ fFar = fOne;
+ }
- if(!::basegfx::numeric::fTools::more(fFar, fZero))
- {
- fFar = fOne;
- }
+ if(::basegfx::fTools::equal(fNear, fFar))
+ {
+ fFar = fNear + fOne;
+ }
- if(::basegfx::numeric::fTools::equal(fNear, fFar))
- {
- fFar = fNear + fOne;
- }
+ if(::basegfx::fTools::equal(fLeft, fRight))
+ {
+ fLeft -= fOne;
+ fRight += fOne;
+ }
- if(::basegfx::numeric::fTools::equal(fLeft, fRight))
- {
- fLeft -= fOne;
- fRight += fOne;
- }
+ if(::basegfx::fTools::equal(fTop, fBottom))
+ {
+ fBottom -= fOne;
+ fTop += fOne;
+ }
- if(::basegfx::numeric::fTools::equal(fTop, fBottom))
- {
- fBottom -= fOne;
- fTop += fOne;
- }
+ Impl3DHomMatrix aFrustumMat(get3DIdentityMatrix());
- Impl3DHomMatrix aFrustumMat(get3DIdentityMatrix());
+ aFrustumMat.set(0, 0, 2.0 * fNear / (fRight - fLeft));
+ aFrustumMat.set(1, 1, 2.0 * fNear / (fTop - fBottom));
+ aFrustumMat.set(0, 2, (fRight + fLeft) / (fRight - fLeft));
+ aFrustumMat.set(1, 2, (fTop + fBottom) / (fTop - fBottom));
+ aFrustumMat.set(2, 2, -fOne * ((fFar + fNear) / (fFar - fNear)));
+ aFrustumMat.set(3, 2, -fOne);
+ aFrustumMat.set(2, 3, -fOne * ((2.0 * fFar * fNear) / (fFar - fNear)));
+ aFrustumMat.set(3, 3, fZero);
- aFrustumMat.set(0, 0, 2.0 * fNear / (fRight - fLeft));
- aFrustumMat.set(1, 1, 2.0 * fNear / (fTop - fBottom));
- aFrustumMat.set(0, 2, (fRight + fLeft) / (fRight - fLeft));
- aFrustumMat.set(1, 2, (fTop + fBottom) / (fTop - fBottom));
- aFrustumMat.set(2, 2, -fOne * ((fFar + fNear) / (fFar - fNear)));
- aFrustumMat.set(3, 2, -fOne);
- aFrustumMat.set(2, 3, -fOne * ((2.0 * fFar * fNear) / (fFar - fNear)));
- aFrustumMat.set(3, 3, fZero);
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ mpM = new Impl3DHomMatrix(aFrustumMat);
+ }
- mpM = new Impl3DHomMatrix(aFrustumMat);
+ void B3DHomMatrix::ortho(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
+ {
+ if(::basegfx::fTools::equal(fNear, fFar))
+ {
+ fFar = fNear + 1.0;
}
- void B3DHomMatrix::ortho(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
+ if(::basegfx::fTools::equal(fLeft, fRight))
{
- if(::basegfx::numeric::fTools::equal(fNear, fFar))
- {
- fFar = fNear + 1.0;
- }
-
- if(::basegfx::numeric::fTools::equal(fLeft, fRight))
- {
- fLeft -= 1.0;
- fRight += 1.0;
- }
+ fLeft -= 1.0;
+ fRight += 1.0;
+ }
- if(::basegfx::numeric::fTools::equal(fTop, fBottom))
- {
- fBottom -= 1.0;
- fTop += 1.0;
- }
+ if(::basegfx::fTools::equal(fTop, fBottom))
+ {
+ fBottom -= 1.0;
+ fTop += 1.0;
+ }
- Impl3DHomMatrix aOrthoMat(get3DIdentityMatrix());
+ Impl3DHomMatrix aOrthoMat(get3DIdentityMatrix());
- aOrthoMat.set(0, 0, 2.0 / (fRight - fLeft));
- aOrthoMat.set(1, 1, 2.0 / (fTop - fBottom));
- aOrthoMat.set(2, 2, -1.0 * (2.0 / (fFar - fNear)));
- aOrthoMat.set(0, 3, -1.0 * ((fRight + fLeft) / (fRight - fLeft)));
- aOrthoMat.set(1, 3, -1.0 * ((fTop + fBottom) / (fTop - fBottom)));
- aOrthoMat.set(2, 3, -1.0 * ((fFar + fNear) / (fFar - fNear)));
+ aOrthoMat.set(0, 0, 2.0 / (fRight - fLeft));
+ aOrthoMat.set(1, 1, 2.0 / (fTop - fBottom));
+ aOrthoMat.set(2, 2, -1.0 * (2.0 / (fFar - fNear)));
+ aOrthoMat.set(0, 3, -1.0 * ((fRight + fLeft) / (fRight - fLeft)));
+ aOrthoMat.set(1, 3, -1.0 * ((fTop + fBottom) / (fTop - fBottom)));
+ aOrthoMat.set(2, 3, -1.0 * ((fFar + fNear) / (fFar - fNear)));
- if(mpM->getRefCount())
- mpM->decRefCount();
- else
- delete mpM;
+ if(mpM->getRefCount())
+ mpM->decRefCount();
+ else
+ delete mpM;
- mpM = new Impl3DHomMatrix(aOrthoMat);
- }
+ mpM = new Impl3DHomMatrix(aOrthoMat);
+ }
- sal_Bool B3DHomMatrix::decompose(tuple::B3DTuple& rScale, tuple::B3DTuple& rTranslate, tuple::B3DTuple& rRotate, tuple::B3DTuple& rShear) const
- {
- // when perspective is used, decompose is not made here
- if(!mpM->isLastLineDefault())
- return sal_False;
+ sal_Bool B3DHomMatrix::decompose(B3DTuple& rScale, B3DTuple& rTranslate, B3DTuple& rRotate, B3DTuple& rShear) const
+ {
+ // when perspective is used, decompose is not made here
+ if(!mpM->isLastLineDefault())
+ return sal_False;
- // If determinant is zero, decomposition is not possible
- if(0.0 == mpM->doDeterminant())
- return sal_False;
+ // If determinant is zero, decomposition is not possible
+ if(0.0 == mpM->doDeterminant())
+ return sal_False;
- // isolate translation
- rTranslate.setX(mpM->get(0, 3));
- rTranslate.setY(mpM->get(1, 3));
- rTranslate.setZ(mpM->get(2, 3));
+ // isolate translation
+ rTranslate.setX(mpM->get(0, 3));
+ rTranslate.setY(mpM->get(1, 3));
+ rTranslate.setZ(mpM->get(2, 3));
- // correct translate values
- rTranslate.correctValues();
+ // correct translate values
+ rTranslate.correctValues();
- // get scale and shear
- vector::B3DVector aCol0(mpM->get(0, 0), mpM->get(1, 0), mpM->get(2, 0));
- vector::B3DVector aCol1(mpM->get(0, 1), mpM->get(1, 1), mpM->get(2, 1));
- vector::B3DVector aCol2(mpM->get(0, 2), mpM->get(1, 2), mpM->get(2, 2));
- vector::B3DVector aTemp;
+ // get scale and shear
+ B3DVector aCol0(mpM->get(0, 0), mpM->get(1, 0), mpM->get(2, 0));
+ B3DVector aCol1(mpM->get(0, 1), mpM->get(1, 1), mpM->get(2, 1));
+ B3DVector aCol2(mpM->get(0, 2), mpM->get(1, 2), mpM->get(2, 2));
+ B3DVector aTemp;
- // get ScaleX
- rScale.setX(aCol0.getLength());
- aCol0.normalize();
+ // get ScaleX
+ rScale.setX(aCol0.getLength());
+ aCol0.normalize();
- // get ShearXY
- rShear.setX(aCol0.scalar(aCol1));
+ // get ShearXY
+ rShear.setX(aCol0.scalar(aCol1));
- if(::basegfx::numeric::fTools::equalZero(rShear.getX()))
- {
- rShear.setX(0.0);
- }
- else
- {
- aTemp.setX(aCol1.getX() - rShear.getX() * aCol0.getX());
- aTemp.setY(aCol1.getY() - rShear.getX() * aCol0.getY());
- aTemp.setZ(aCol1.getZ() - rShear.getX() * aCol0.getZ());
- aCol1 = aTemp;
- }
+ if(::basegfx::fTools::equalZero(rShear.getX()))
+ {
+ rShear.setX(0.0);
+ }
+ else
+ {
+ aTemp.setX(aCol1.getX() - rShear.getX() * aCol0.getX());
+ aTemp.setY(aCol1.getY() - rShear.getX() * aCol0.getY());
+ aTemp.setZ(aCol1.getZ() - rShear.getX() * aCol0.getZ());
+ aCol1 = aTemp;
+ }
- // get ScaleY
- rScale.setY(aCol1.getLength());
- aCol1.normalize();
+ // get ScaleY
+ rScale.setY(aCol1.getLength());
+ aCol1.normalize();
- const double fShearX(rShear.getX());
+ const double fShearX(rShear.getX());
- if(!::basegfx::numeric::fTools::equalZero(fShearX))
- {
- rShear.setX(rShear.getX() / rScale.getY());
- }
+ if(!::basegfx::fTools::equalZero(fShearX))
+ {
+ rShear.setX(rShear.getX() / rScale.getY());
+ }
- // get ShearXZ
- rShear.setY(aCol0.scalar(aCol2));
+ // get ShearXZ
+ rShear.setY(aCol0.scalar(aCol2));
- if(::basegfx::numeric::fTools::equalZero(rShear.getY()))
- {
- rShear.setY(0.0);
- }
- else
- {
- aTemp.setX(aCol2.getX() - rShear.getY() * aCol0.getX());
- aTemp.setY(aCol2.getY() - rShear.getY() * aCol0.getY());
- aTemp.setZ(aCol2.getZ() - rShear.getY() * aCol0.getZ());
- aCol2 = aTemp;
- }
+ if(::basegfx::fTools::equalZero(rShear.getY()))
+ {
+ rShear.setY(0.0);
+ }
+ else
+ {
+ aTemp.setX(aCol2.getX() - rShear.getY() * aCol0.getX());
+ aTemp.setY(aCol2.getY() - rShear.getY() * aCol0.getY());
+ aTemp.setZ(aCol2.getZ() - rShear.getY() * aCol0.getZ());
+ aCol2 = aTemp;
+ }
- // get ShearYZ
- rShear.setZ(aCol1.scalar(aCol2));
+ // get ShearYZ
+ rShear.setZ(aCol1.scalar(aCol2));
- if(::basegfx::numeric::fTools::equalZero(rShear.getZ()))
- {
- rShear.setZ(0.0);
- }
- else
- {
- aTemp.setX(aCol2.getX() - rShear.getZ() * aCol1.getX());
- aTemp.setY(aCol2.getY() - rShear.getZ() * aCol1.getY());
- aTemp.setZ(aCol2.getZ() - rShear.getZ() * aCol1.getZ());
- aCol2 = aTemp;
- }
+ if(::basegfx::fTools::equalZero(rShear.getZ()))
+ {
+ rShear.setZ(0.0);
+ }
+ else
+ {
+ aTemp.setX(aCol2.getX() - rShear.getZ() * aCol1.getX());
+ aTemp.setY(aCol2.getY() - rShear.getZ() * aCol1.getY());
+ aTemp.setZ(aCol2.getZ() - rShear.getZ() * aCol1.getZ());
+ aCol2 = aTemp;
+ }
- // get ScaleZ
- rScale.setZ(aCol2.getLength());
- aCol2.normalize();
+ // get ScaleZ
+ rScale.setZ(aCol2.getLength());
+ aCol2.normalize();
- const double fShearY(rShear.getY());
+ const double fShearY(rShear.getY());
- if(!::basegfx::numeric::fTools::equalZero(fShearY))
- {
- rShear.setY(rShear.getY() / rScale.getZ());
- }
+ if(!::basegfx::fTools::equalZero(fShearY))
+ {
+ rShear.setY(rShear.getY() / rScale.getZ());
+ }
- const double fShearZ(rShear.getZ());
+ const double fShearZ(rShear.getZ());
- if(!::basegfx::numeric::fTools::equalZero(fShearZ))
- {
- rShear.setZ(rShear.getZ() / rScale.getZ());
- }
+ if(!::basegfx::fTools::equalZero(fShearZ))
+ {
+ rShear.setZ(rShear.getZ() / rScale.getZ());
+ }
- // correct shear values
- rShear.correctValues();
+ // correct shear values
+ rShear.correctValues();
- // Coordinate system flip?
- if(0.0 > aCol0.scalar(aCol1.getPerpendicular(aCol2)))
- {
- rScale = -rScale;
- aCol0 = -aCol0;
- aCol1 = -aCol1;
- aCol2 = -aCol2;
- }
+ // Coordinate system flip?
+ if(0.0 > aCol0.scalar(aCol1.getPerpendicular(aCol2)))
+ {
+ rScale = -rScale;
+ aCol0 = -aCol0;
+ aCol1 = -aCol1;
+ aCol2 = -aCol2;
+ }
- // correct scale values
- rScale.correctValues(1.0);
+ // correct scale values
+ rScale.correctValues(1.0);
- // Get rotations
- rRotate.setY(asin(-aCol0.getZ()));
+ // Get rotations
+ rRotate.setY(asin(-aCol0.getZ()));
- if(::basegfx::numeric::fTools::equalZero(cos(rRotate.getY())))
- {
- rRotate.setX(atan2(aCol1.getX(), aCol1.getY()));
- rRotate.setZ(0.0);
- }
- else
- {
- rRotate.setX(atan2(aCol1.getZ(), aCol2.getZ()));
- rRotate.setZ(atan2(aCol0.getY(), aCol0.getX()));
- }
+ if(::basegfx::fTools::equalZero(cos(rRotate.getY())))
+ {
+ rRotate.setX(atan2(aCol1.getX(), aCol1.getY()));
+ rRotate.setZ(0.0);
+ }
+ else
+ {
+ rRotate.setX(atan2(aCol1.getZ(), aCol2.getZ()));
+ rRotate.setZ(atan2(aCol0.getY(), aCol0.getX()));
+ }
- // corrcet rotate values
- rRotate.correctValues();
+ // corrcet rotate values
+ rRotate.correctValues();
- return sal_True;
- }
- } // end of namespace matrix
+ return sal_True;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/numeric/ftools.cxx b/basegfx/source/numeric/ftools.cxx
index 9470c249a756..c39ee766a2bc 100644
--- a/basegfx/source/numeric/ftools.cxx
+++ b/basegfx/source/numeric/ftools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: ftools.cxx,v $
*
- * $Revision: 1.2 $
+ * $Revision: 1.3 $
*
- * last change: $Author: aw $ $Date: 2003-10-31 10:13:56 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:03 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -65,11 +65,8 @@
namespace basegfx
{
- namespace numeric
- {
- // init static member of class fTools
- double ::basegfx::numeric::fTools::mfSmallValue = 0.000000001;
- } // end of namespace numeric
+ // init static member of class fTools
+ double ::basegfx::fTools::mfSmallValue = 0.000000001;
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/point/b2dhompoint.cxx b/basegfx/source/point/b2dhompoint.cxx
index 575657491120..cda1e6f356b5 100644
--- a/basegfx/source/point/b2dhompoint.cxx
+++ b/basegfx/source/point/b2dhompoint.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dhompoint.cxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-10 11:45:49 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:04 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -73,230 +73,227 @@
namespace basegfx
{
- namespace point
+ sal_Bool B2DHomPoint::implIsHomogenized() const
{
- sal_Bool B2DHomPoint::implIsHomogenized() const
- {
- const double fOne(1.0);
- return ::basegfx::numeric::fTools::equal(fOne, mfW);
- }
+ const double fOne(1.0);
+ return ::basegfx::fTools::equal(fOne, mfW);
+ }
- void B2DHomPoint::implHomogenize()
- {
- const double fFactor(1.0 / mfW);
- maTuple.setX(maTuple.getX() * fFactor);
- maTuple.setY(maTuple.getY() * fFactor);
- mfW = 1.0;
- }
+ void B2DHomPoint::implHomogenize()
+ {
+ const double fFactor(1.0 / mfW);
+ maTuple.setX(maTuple.getX() * fFactor);
+ maTuple.setY(maTuple.getY() * fFactor);
+ mfW = 1.0;
+ }
- void B2DHomPoint::implTestAndHomogenize() const
- {
- if(!implIsHomogenized())
- ((B2DHomPoint*)this)->implHomogenize();
- }
+ void B2DHomPoint::implTestAndHomogenize() const
+ {
+ if(!implIsHomogenized())
+ ((B2DHomPoint*)this)->implHomogenize();
+ }
- B2DPoint B2DHomPoint::getB2DPoint() const
- {
- implTestAndHomogenize();
- return B2DPoint(maTuple.getX(), maTuple.getY());
- }
+ B2DPoint B2DHomPoint::getB2DPoint() const
+ {
+ implTestAndHomogenize();
+ return B2DPoint(maTuple.getX(), maTuple.getY());
+ }
- double B2DHomPoint::getX() const
- {
- implTestAndHomogenize();
- return maTuple.getX();
- }
+ double B2DHomPoint::getX() const
+ {
+ implTestAndHomogenize();
+ return maTuple.getX();
+ }
- double B2DHomPoint::getY() const
- {
- implTestAndHomogenize();
- return maTuple.getY();
- }
+ double B2DHomPoint::getY() const
+ {
+ implTestAndHomogenize();
+ return maTuple.getY();
+ }
- void B2DHomPoint::setX(double fX)
- {
- maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
- }
+ void B2DHomPoint::setX(double fX)
+ {
+ maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
+ }
- void B2DHomPoint::setY(double fY)
- {
- maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
- }
+ void B2DHomPoint::setY(double fY)
+ {
+ maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
+ }
- B2DHomPoint& B2DHomPoint::operator+=( const B2DHomPoint& rPnt )
- {
- maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
- maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
- mfW = mfW * rPnt.mfW;
+ B2DHomPoint& B2DHomPoint::operator+=( const B2DHomPoint& rPnt )
+ {
+ maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
+ maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
+ mfW = mfW * rPnt.mfW;
- return *this;
- }
+ return *this;
+ }
- B2DHomPoint& B2DHomPoint::operator-=( const B2DHomPoint& rPnt )
- {
- maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
- maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
- mfW = mfW * rPnt.mfW;
+ B2DHomPoint& B2DHomPoint::operator-=( const B2DHomPoint& rPnt )
+ {
+ maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
+ maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
+ mfW = mfW * rPnt.mfW;
- return *this;
- }
+ return *this;
+ }
- B2DHomPoint& B2DHomPoint::operator*=(double t)
+ B2DHomPoint& B2DHomPoint::operator*=(double t)
+ {
+ if(!::basegfx::fTools::equalZero(t))
{
- if(!::basegfx::numeric::fTools::equalZero(t))
- {
- mfW /= t;
- }
-
- return *this;
+ mfW /= t;
}
- B2DHomPoint& B2DHomPoint::operator*=( const matrix::B2DHomMatrix& rMat )
- {
- const double fTempX( rMat.get(0,0)*maTuple.getX() +
- rMat.get(0,1)*maTuple.getY() +
- rMat.get(0,2)*mfW );
-
- const double fTempY( rMat.get(1,0)*maTuple.getX() +
- rMat.get(1,1)*maTuple.getY() +
- rMat.get(1,2)*mfW );
-
- const double fTempZ( rMat.get(2,0)*maTuple.getX() +
- rMat.get(2,1)*maTuple.getY() +
- rMat.get(2,2)*mfW );
- maTuple.setX( fTempX );
- maTuple.setY( fTempY );
- mfW = fTempZ;
-
- return *this;
- }
+ return *this;
+ }
- B2DHomPoint& B2DHomPoint::operator/=(double t)
- {
- mfW *= t;
- return *this;
- }
+ B2DHomPoint& B2DHomPoint::operator*=( const B2DHomMatrix& rMat )
+ {
+ const double fTempX( rMat.get(0,0)*maTuple.getX() +
+ rMat.get(0,1)*maTuple.getY() +
+ rMat.get(0,2)*mfW );
- B2DHomPoint& B2DHomPoint::operator-(void)
- {
- mfW = -mfW;
- return *this;
- }
+ const double fTempY( rMat.get(1,0)*maTuple.getX() +
+ rMat.get(1,1)*maTuple.getY() +
+ rMat.get(1,2)*mfW );
- sal_Bool B2DHomPoint::operator==( const B2DHomPoint& rPnt ) const
- {
- implTestAndHomogenize();
- return (maTuple == rPnt.maTuple);
- }
+ const double fTempZ( rMat.get(2,0)*maTuple.getX() +
+ rMat.get(2,1)*maTuple.getY() +
+ rMat.get(2,2)*mfW );
+ maTuple.setX( fTempX );
+ maTuple.setY( fTempY );
+ mfW = fTempZ;
- sal_Bool B2DHomPoint::operator!=( const B2DHomPoint& rPnt ) const
- {
- implTestAndHomogenize();
- return (maTuple != rPnt.maTuple);
- }
+ return *this;
+ }
- B2DHomPoint& B2DHomPoint::operator=( const B2DHomPoint& rPnt )
- {
- maTuple = rPnt.maTuple;
- mfW = rPnt.mfW;
- return *this;
- }
+ B2DHomPoint& B2DHomPoint::operator/=(double t)
+ {
+ mfW *= t;
+ return *this;
+ }
- B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
- {
- B2DHomPoint aMin(
- (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
- (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY());
- return aMin;
- }
+ B2DHomPoint& B2DHomPoint::operator-(void)
+ {
+ mfW = -mfW;
+ return *this;
+ }
- B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
- {
- B2DHomPoint aMax(
- (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
- (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY());
- return aMax;
- }
- B2DHomPoint abs(const B2DHomPoint& rVec)
- {
- B2DHomPoint aAbs(
- (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
- (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY());
- return aAbs;
- }
+ sal_Bool B2DHomPoint::operator==( const B2DHomPoint& rPnt ) const
+ {
+ implTestAndHomogenize();
+ return (maTuple == rPnt.maTuple);
+ }
- B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t)
- {
- B2DHomPoint aInt(
- ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
- ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
- return aInt;
- }
+ sal_Bool B2DHomPoint::operator!=( const B2DHomPoint& rPnt ) const
+ {
+ implTestAndHomogenize();
+ return (maTuple != rPnt.maTuple);
+ }
- B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2)
- {
- B2DHomPoint aAvg(
- (rOld1.getX() + rOld2.getX()) * 0.5,
- (rOld1.getY() + rOld2.getY()) * 0.5);
- return aAvg;
- }
+ B2DHomPoint& B2DHomPoint::operator=( const B2DHomPoint& rPnt )
+ {
+ maTuple = rPnt.maTuple;
+ mfW = rPnt.mfW;
+ return *this;
+ }
- B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3)
- {
- B2DHomPoint aAvg(
- (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
- (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
- return aAvg;
- }
+ B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
+ {
+ B2DHomPoint aMin(
+ (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+ (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY());
+ return aMin;
+ }
- B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
- {
- B2DHomPoint aSum(rVecA);
- aSum += rVecB;
- return aSum;
- }
+ B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
+ {
+ B2DHomPoint aMax(
+ (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+ (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY());
+ return aMax;
+ }
+ B2DHomPoint abs(const B2DHomPoint& rVec)
+ {
+ B2DHomPoint aAbs(
+ (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
+ (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY());
+ return aAbs;
+ }
- B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
- {
- B2DHomPoint aSub(rVecA);
- aSub -= rVecB;
- return aSub;
- }
+ B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t)
+ {
+ B2DHomPoint aInt(
+ ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
+ ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
+ return aInt;
+ }
- B2DHomPoint operator*(const B2DHomPoint& rVec, double t)
- {
- B2DHomPoint aNew(rVec);
- aNew *= t;
- return aNew;
- }
+ B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2)
+ {
+ B2DHomPoint aAvg(
+ (rOld1.getX() + rOld2.getX()) * 0.5,
+ (rOld1.getY() + rOld2.getY()) * 0.5);
+ return aAvg;
+ }
- B2DHomPoint operator*(double t, const B2DHomPoint& rVec)
- {
- B2DHomPoint aNew(rVec);
- aNew *= t;
- return aNew;
- }
+ B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3)
+ {
+ B2DHomPoint aAvg(
+ (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
+ (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
+ return aAvg;
+ }
- B2DHomPoint operator*( const matrix::B2DHomMatrix& rMat, const B2DHomPoint& rPoint )
- {
- B2DHomPoint aNew(rPoint);
- return aNew*=rMat;
- }
+ B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
+ {
+ B2DHomPoint aSum(rVecA);
+ aSum += rVecB;
+ return aSum;
+ }
- B2DHomPoint operator/(const B2DHomPoint& rVec, double t)
- {
- B2DHomPoint aNew(rVec);
- aNew /= t;
- return aNew;
- }
+ B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
+ {
+ B2DHomPoint aSub(rVecA);
+ aSub -= rVecB;
+ return aSub;
+ }
- B2DHomPoint operator/(double t, const B2DHomPoint& rVec)
- {
- B2DHomPoint aNew(rVec);
- aNew /= t;
- return aNew;
- }
- } // end of namespace point
+ B2DHomPoint operator*(const B2DHomPoint& rVec, double t)
+ {
+ B2DHomPoint aNew(rVec);
+ aNew *= t;
+ return aNew;
+ }
+
+ B2DHomPoint operator*(double t, const B2DHomPoint& rVec)
+ {
+ B2DHomPoint aNew(rVec);
+ aNew *= t;
+ return aNew;
+ }
+
+ B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint )
+ {
+ B2DHomPoint aNew(rPoint);
+ return aNew*=rMat;
+ }
+
+ B2DHomPoint operator/(const B2DHomPoint& rVec, double t)
+ {
+ B2DHomPoint aNew(rVec);
+ aNew /= t;
+ return aNew;
+ }
+
+ B2DHomPoint operator/(double t, const B2DHomPoint& rVec)
+ {
+ B2DHomPoint aNew(rVec);
+ aNew /= t;
+ return aNew;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/point/b2dpoint.cxx b/basegfx/source/point/b2dpoint.cxx
index 34c14f89bdac..dab49a9fe392 100644
--- a/basegfx/source/point/b2dpoint.cxx
+++ b/basegfx/source/point/b2dpoint.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpoint.cxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-06 16:30:28 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:04 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -69,29 +69,26 @@
namespace basegfx
{
- namespace point
+ B2DPoint& B2DPoint::operator=( const ::basegfx::B2DTuple& rPoint )
{
- B2DPoint& B2DPoint::operator=( const ::basegfx::tuple::B2DTuple& rPoint )
- {
- mfX = rPoint.getX();
- mfY = rPoint.getY();
- return *this;
- }
+ mfX = rPoint.getX();
+ mfY = rPoint.getY();
+ return *this;
+ }
- B2DPoint& B2DPoint::operator*=( const ::basegfx::matrix::B2DHomMatrix& rMat )
- {
- const double fTempX( rMat.get(0,0)*mfX +
- rMat.get(0,1)*mfY +
- rMat.get(0,2) );
- const double fTempY( rMat.get(1,0)*mfX +
- rMat.get(1,1)*mfY +
- rMat.get(1,2) );
- mfX = fTempX;
- mfY = fTempY;
+ B2DPoint& B2DPoint::operator*=( const ::basegfx::B2DHomMatrix& rMat )
+ {
+ const double fTempX( rMat.get(0,0)*mfX +
+ rMat.get(0,1)*mfY +
+ rMat.get(0,2) );
+ const double fTempY( rMat.get(1,0)*mfX +
+ rMat.get(1,1)*mfY +
+ rMat.get(1,2) );
+ mfX = fTempX;
+ mfY = fTempY;
- return *this;
- }
- } // end of namespace point
+ return *this;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/point/b3dhompoint.cxx b/basegfx/source/point/b3dhompoint.cxx
index 07570ebd8208..7069ea73a9ba 100644
--- a/basegfx/source/point/b3dhompoint.cxx
+++ b/basegfx/source/point/b3dhompoint.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dhompoint.cxx,v $
*
- * $Revision: 1.2 $
+ * $Revision: 1.3 $
*
- * last change: $Author: aw $ $Date: 2003-10-31 10:13:57 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:04 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -65,17 +65,14 @@
namespace basegfx
{
- namespace point
+ void B3DHomPoint::implHomogenize()
{
- void B3DHomPoint::implHomogenize()
- {
- const double fFactor(1.0 / mfW);
- maTuple.setX(maTuple.getX() * fFactor);
- maTuple.setY(maTuple.getY() * fFactor);
- maTuple.setZ(maTuple.getZ() * fFactor);
- mfW = 1.0;
- }
- } // end of namespace point
+ const double fFactor(1.0 / mfW);
+ maTuple.setX(maTuple.getX() * fFactor);
+ maTuple.setY(maTuple.getY() * fFactor);
+ maTuple.setZ(maTuple.getZ() * fFactor);
+ mfW = 1.0;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/point/b3dpoint.cxx b/basegfx/source/point/b3dpoint.cxx
index 6d6471ffa07d..9ece7171af62 100644
--- a/basegfx/source/point/b3dpoint.cxx
+++ b/basegfx/source/point/b3dpoint.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpoint.cxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:10 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:04 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -69,29 +69,26 @@
namespace basegfx
{
- namespace point
+ B3DPoint& B3DPoint::operator*=( const ::basegfx::B3DHomMatrix& rMat )
{
- B3DPoint& B3DPoint::operator*=( const ::basegfx::matrix::B3DHomMatrix& rMat )
- {
- const double fTempX(rMat.get(0,0)*mfX +
- rMat.get(0,1)*mfY +
- rMat.get(0,2)*mfZ +
- rMat.get(0,3));
- const double fTempY(rMat.get(1,0)*mfX +
- rMat.get(1,1)*mfY +
- rMat.get(1,2)*mfZ +
- rMat.get(1,3));
- const double fTempZ(rMat.get(2,0)*mfX +
- rMat.get(2,1)*mfY +
- rMat.get(2,2)*mfZ +
- rMat.get(2,3));
- mfX = fTempX;
- mfY = fTempY;
- mfZ = fTempZ;
+ const double fTempX(rMat.get(0,0)*mfX +
+ rMat.get(0,1)*mfY +
+ rMat.get(0,2)*mfZ +
+ rMat.get(0,3));
+ const double fTempY(rMat.get(1,0)*mfX +
+ rMat.get(1,1)*mfY +
+ rMat.get(1,2)*mfZ +
+ rMat.get(1,3));
+ const double fTempZ(rMat.get(2,0)*mfX +
+ rMat.get(2,1)*mfY +
+ rMat.get(2,2)*mfZ +
+ rMat.get(2,3));
+ mfX = fTempX;
+ mfY = fTempY;
+ mfZ = fTempZ;
- return *this;
- }
- } // end of namespace point
+ return *this;
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index 7a9b477081f5..0dcbeaa7a3a2 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygon.cxx,v $
*
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:10 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:05 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -86,17 +86,17 @@
class CoordinateData2D
{
- ::basegfx::point::B2DPoint maPoint;
+ ::basegfx::B2DPoint maPoint;
public:
CoordinateData2D() {}
- CoordinateData2D(const ::basegfx::point::B2DPoint& rData) : maPoint(rData) {}
+ CoordinateData2D(const ::basegfx::B2DPoint& rData) : maPoint(rData) {}
~CoordinateData2D() {}
- const ::basegfx::point::B2DPoint& getCoordinate() const { return maPoint; }
- void setCoordinate(const ::basegfx::point::B2DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
+ const ::basegfx::B2DPoint& getCoordinate() const { return maPoint; }
+ void setCoordinate(const ::basegfx::B2DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
sal_Bool operator==(const CoordinateData2D& rData ) const { return (maPoint == rData.getCoordinate()); }
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix) { maPoint *= rMatrix; }
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix) { maPoint *= rMatrix; }
};
//////////////////////////////////////////////////////////////////////////////
@@ -137,12 +137,12 @@ public:
return (maVector == rCandidate.maVector);
}
- const ::basegfx::point::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
{
return maVector[nIndex].getCoordinate();
}
- void setCoordinate(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
+ void setCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
{
maVector[nIndex].setCoordinate(rValue);
}
@@ -233,7 +233,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
CoordinateData2DVector::iterator aStart(maVector.begin());
CoordinateData2DVector::iterator aEnd(maVector.end());
@@ -249,18 +249,18 @@ public:
class ControlVectorPair2D
{
- ::basegfx::vector::B2DVector maVectorA;
- ::basegfx::vector::B2DVector maVectorB;
+ ::basegfx::B2DVector maVectorA;
+ ::basegfx::B2DVector maVectorB;
public:
ControlVectorPair2D() {}
~ControlVectorPair2D() {}
- const ::basegfx::vector::B2DVector& getVectorA() const { return maVectorA; }
- void setVectorA(const ::basegfx::vector::B2DVector& rValue) { if(rValue != maVectorA) maVectorA = rValue; }
+ const ::basegfx::B2DVector& getVectorA() const { return maVectorA; }
+ void setVectorA(const ::basegfx::B2DVector& rValue) { if(rValue != maVectorA) maVectorA = rValue; }
- const ::basegfx::vector::B2DVector& getVectorB() const { return maVectorB; }
- void setVectorB(const ::basegfx::vector::B2DVector& rValue) { if(rValue != maVectorB) maVectorB = rValue; }
+ const ::basegfx::B2DVector& getVectorB() const { return maVectorB; }
+ void setVectorB(const ::basegfx::B2DVector& rValue) { if(rValue != maVectorB) maVectorB = rValue; }
sal_Bool operator==(const ControlVectorPair2D& rData ) const
{ return (maVectorA == rData.getVectorA() && maVectorB == rData.getVectorB()); }
@@ -329,12 +329,12 @@ public:
return (0L != mnUsedVectors);
}
- const ::basegfx::vector::B2DVector& getVectorA(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getVectorA(sal_uInt32 nIndex) const
{
return maVector[nIndex].getVectorA();
}
- void setVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
sal_Bool bWasUsed(mnUsedVectors && !maVector[nIndex].getVectorA().equalZero());
sal_Bool bIsUsed(!rValue.equalZero());
@@ -347,7 +347,7 @@ public:
}
else
{
- maVector[nIndex].setVectorA(::basegfx::vector::B2DVector::getEmptyVector());
+ maVector[nIndex].setVectorA(::basegfx::B2DVector::getEmptyVector());
mnUsedVectors--;
}
}
@@ -361,12 +361,12 @@ public:
}
}
- const ::basegfx::vector::B2DVector& getVectorB(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getVectorB(sal_uInt32 nIndex) const
{
return maVector[nIndex].getVectorB();
}
- void setVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
sal_Bool bWasUsed(mnUsedVectors && !maVector[nIndex].getVectorB().equalZero());
sal_Bool bIsUsed(!rValue.equalZero());
@@ -379,7 +379,7 @@ public:
}
else
{
- maVector[nIndex].setVectorB(::basegfx::vector::B2DVector::getEmptyVector());
+ maVector[nIndex].setVectorB(::basegfx::B2DVector::getEmptyVector());
mnUsedVectors--;
}
}
@@ -601,17 +601,17 @@ public:
return sal_False;
}
- const ::basegfx::point::B2DPoint& getPoint(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPoint& getPoint(sal_uInt32 nIndex) const
{
return maPoints.getCoordinate(nIndex);
}
- void setPoint(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
+ void setPoint(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
{
maPoints.setCoordinate(nIndex, rValue);
}
- void insert(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
{
if(nCount)
{
@@ -626,7 +626,7 @@ public:
}
}
- const ::basegfx::vector::B2DVector& getControlVectorA(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getControlVectorA(sal_uInt32 nIndex) const
{
if(mpControlVector)
{
@@ -634,11 +634,11 @@ public:
}
else
{
- return ::basegfx::vector::B2DVector::getEmptyVector();
+ return ::basegfx::B2DVector::getEmptyVector();
}
}
- void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
if(!mpControlVector)
{
@@ -665,7 +665,7 @@ public:
return (mpControlVector && mpControlVector->isUsed());
}
- const ::basegfx::vector::B2DVector& getControlVectorB(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getControlVectorB(sal_uInt32 nIndex) const
{
if(mpControlVector)
{
@@ -673,11 +673,11 @@ public:
}
else
{
- return ::basegfx::vector::B2DVector::getEmptyVector();
+ return ::basegfx::B2DVector::getEmptyVector();
}
}
- void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
if(!mpControlVector)
{
@@ -775,10 +775,10 @@ public:
const sal_uInt32 nVectorSource(nCoorSource ? nCoorSource - 1L : nCount - 1L);
// get source data
- const ::basegfx::point::B2DPoint& rSourceCoor = pCoordinateCopy->getCoordinate(nCoorSource);
- const ::basegfx::point::B2DPoint& rVectorSourceCoor = pCoordinateCopy->getCoordinate(nVectorSource);
- const ::basegfx::vector::B2DVector& rVectorSourceA = pVectorCopy->getVectorA(nVectorSource);
- const ::basegfx::vector::B2DVector& rVectorSourceB = pVectorCopy->getVectorB(nVectorSource);
+ const ::basegfx::B2DPoint& rSourceCoor = pCoordinateCopy->getCoordinate(nCoorSource);
+ const ::basegfx::B2DPoint& rVectorSourceCoor = pCoordinateCopy->getCoordinate(nVectorSource);
+ const ::basegfx::B2DVector& rVectorSourceA = pVectorCopy->getVectorA(nVectorSource);
+ const ::basegfx::B2DVector& rVectorSourceB = pVectorCopy->getVectorB(nVectorSource);
// copy point data
maPoints.setCoordinate(a, rSourceCoor);
@@ -787,12 +787,12 @@ public:
if(rVectorSourceA.equalZero())
{
// unused, use zero vector
- mpControlVector->setVectorB(a, ::basegfx::vector::B2DVector::getEmptyVector());
+ mpControlVector->setVectorB(a, ::basegfx::B2DVector::getEmptyVector());
}
else
{
// calculate new vector relative to new point
- ::basegfx::vector::B2DVector aNewVectorB((rVectorSourceA + rVectorSourceCoor) - rSourceCoor);
+ ::basegfx::B2DVector aNewVectorB((rVectorSourceA + rVectorSourceCoor) - rSourceCoor);
mpControlVector->setVectorB(a, aNewVectorB);
}
@@ -800,12 +800,12 @@ public:
if(rVectorSourceB.equalZero())
{
// unused, use zero vector
- mpControlVector->setVectorA(a, ::basegfx::vector::B2DVector::getEmptyVector());
+ mpControlVector->setVectorA(a, ::basegfx::B2DVector::getEmptyVector());
}
else
{
// calculate new vector relative to new point
- ::basegfx::vector::B2DVector aNewVectorA((rVectorSourceB + rVectorSourceCoor) - rSourceCoor);
+ ::basegfx::B2DVector aNewVectorA((rVectorSourceB + rVectorSourceCoor) - rSourceCoor);
mpControlVector->setVectorA(a, aNewVectorA);
}
}
@@ -939,28 +939,28 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
if(mpControlVector)
{
for(sal_uInt32 a(0L); a < maPoints.count(); a++)
{
- ::basegfx::point::B2DPoint aCandidate = maPoints.getCoordinate(a);
+ ::basegfx::B2DPoint aCandidate = maPoints.getCoordinate(a);
if(mpControlVector->isUsed())
{
- const ::basegfx::vector::B2DVector& rVectorA(mpControlVector->getVectorA(a));
- const ::basegfx::vector::B2DVector& rVectorB(mpControlVector->getVectorB(a));
+ const ::basegfx::B2DVector& rVectorA(mpControlVector->getVectorA(a));
+ const ::basegfx::B2DVector& rVectorB(mpControlVector->getVectorB(a));
if(!rVectorA.equalZero())
{
- ::basegfx::vector::B2DVector aVectorA(rMatrix * rVectorA);
+ ::basegfx::B2DVector aVectorA(rMatrix * rVectorA);
mpControlVector->setVectorA(a, aVectorA);
}
if(!rVectorB.equalZero())
{
- ::basegfx::vector::B2DVector aVectorB(rMatrix * rVectorB);
+ ::basegfx::B2DVector aVectorB(rMatrix * rVectorB);
mpControlVector->setVectorB(a, aVectorB);
}
}
@@ -986,294 +986,291 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB2DPolygon maStaticDefaultPolygon;
+ // init static default Polygon
+ static ImplB2DPolygon maStaticDefaultPolygon;
- void B2DPolygon::implForceUniqueCopy()
+ void B2DPolygon::implForceUniqueCopy()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- mpPolygon = new ImplB2DPolygon(*mpPolygon);
- }
+ mpPolygon->decRefCount();
+ mpPolygon = new ImplB2DPolygon(*mpPolygon);
}
+ }
- B2DPolygon::B2DPolygon()
- : mpPolygon(&maStaticDefaultPolygon)
- {
- mpPolygon->incRefCount();
- }
+ B2DPolygon::B2DPolygon()
+ : mpPolygon(&maStaticDefaultPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
+
+ B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
+ : mpPolygon(rPolygon.mpPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
+
+ B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
+ : mpPolygon(new ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ {
+ OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
+ }
- B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
- : mpPolygon(rPolygon.mpPolygon)
+ B2DPolygon::~B2DPolygon()
+ {
+ if(mpPolygon->getRefCount())
{
- mpPolygon->incRefCount();
+ mpPolygon->decRefCount();
}
-
- B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
- : mpPolygon(new ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ else
{
- OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
+ delete mpPolygon;
}
+ }
- B2DPolygon::~B2DPolygon()
+ B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
+ mpPolygon->decRefCount();
}
-
- B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
+ else
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
-
- mpPolygon = rPolygon.mpPolygon;
- mpPolygon->incRefCount();
-
- return *this;
+ delete mpPolygon;
}
- sal_Bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
- {
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_True;
- }
+ mpPolygon = rPolygon.mpPolygon;
+ mpPolygon->incRefCount();
- return mpPolygon->isEqual(*(rPolygon.mpPolygon));
- }
+ return *this;
+ }
- sal_Bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
+ sal_Bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
{
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_False;
- }
-
- return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ return sal_True;
}
- sal_uInt32 B2DPolygon::count() const
+ return mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
+
+ sal_Bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
{
- return mpPolygon->count();
+ return sal_False;
}
- ::basegfx::point::B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
- return mpPolygon->getPoint(nIndex);
- }
+ sal_uInt32 B2DPolygon::count() const
+ {
+ return mpPolygon->count();
+ }
- void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getPoint(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setPoint(nIndex, rValue);
- }
- }
+ return mpPolygon->getPoint(nIndex);
+ }
- void B2DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(nIndex, rPoint, nCount);
- }
+ if(mpPolygon->getPoint(nIndex) != rValue)
+ {
+ implForceUniqueCopy();
+ mpPolygon->setPoint(nIndex, rValue);
}
+ }
+
+ void B2DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- void B2DPolygon::append(const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
- }
+ implForceUniqueCopy();
+ mpPolygon->insert(nIndex, rPoint, nCount);
}
+ }
- ::basegfx::vector::B2DVector B2DPolygon::getControlVectorA(sal_uInt32 nIndex) const
+ void B2DPolygon::append(const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
-
- return mpPolygon->getControlVectorA(nIndex);
+ implForceUniqueCopy();
+ mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
}
+ }
- void B2DPolygon::setControlVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DVector B2DPolygon::getControlVectorA(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getControlVectorA(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setControlVectorA(nIndex, rValue);
- }
- }
+ return mpPolygon->getControlVectorA(nIndex);
+ }
- ::basegfx::vector::B2DVector B2DPolygon::getControlVectorB(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ void B2DPolygon::setControlVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- return mpPolygon->getControlVectorB(nIndex);
+ if(mpPolygon->getControlVectorA(nIndex) != rValue)
+ {
+ implForceUniqueCopy();
+ mpPolygon->setControlVectorA(nIndex, rValue);
}
+ }
- void B2DPolygon::setControlVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DVector B2DPolygon::getControlVectorB(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getControlVectorB(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setControlVectorB(nIndex, rValue);
- }
- }
+ return mpPolygon->getControlVectorB(nIndex);
+ }
- sal_Bool B2DPolygon::areControlPointsUsed() const
+ void B2DPolygon::setControlVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+
+ if(mpPolygon->getControlVectorB(nIndex) != rValue)
{
- return mpPolygon->areControlPointsUsed();
+ implForceUniqueCopy();
+ mpPolygon->setControlVectorB(nIndex, rValue);
}
+ }
- void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ sal_Bool B2DPolygon::areControlPointsUsed() const
+ {
+ return mpPolygon->areControlPointsUsed();
+ }
- if(rPoly.count())
- {
- implForceUniqueCopy();
+ void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- if(!nCount)
- {
- nCount = rPoly.count();
- }
+ if(rPoly.count())
+ {
+ implForceUniqueCopy();
- if(0L == nIndex2 && nCount == rPoly.count())
- {
- mpPolygon->insert(nIndex, *rPoly.mpPolygon);
- }
- else
- {
- OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
- mpPolygon->insert(nIndex, aTempPoly);
- }
+ if(!nCount)
+ {
+ nCount = rPoly.count();
}
- }
- void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
- {
- if(rPoly.count())
+ if(0L == nIndex2 && nCount == rPoly.count())
{
- implForceUniqueCopy();
-
- if(!nCount)
- {
- nCount = rPoly.count();
- }
-
- if(0L == nIndex && 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);
- }
+ mpPolygon->insert(nIndex, *rPoly.mpPolygon);
+ }
+ else
+ {
+ OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
+ mpPolygon->insert(nIndex, aTempPoly);
}
}
+ }
- void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ if(rPoly.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
+ implForceUniqueCopy();
- if(nCount)
+ if(!nCount)
{
- implForceUniqueCopy();
- mpPolygon->remove(nIndex, nCount);
+ nCount = rPoly.count();
}
- }
- void B2DPolygon::clear()
- {
- if(mpPolygon->getRefCount())
+ if(0L == nIndex && nCount == rPoly.count())
{
- mpPolygon->decRefCount();
+ mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
}
else
{
- delete mpPolygon;
+ OSL_ENSURE(nIndex + nCount > rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
+ ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
+ mpPolygon->insert(mpPolygon->count(), aTempPoly);
}
-
- mpPolygon = &maStaticDefaultPolygon;
- mpPolygon->incRefCount();
}
+ }
- sal_Bool B2DPolygon::isClosed() const
+ void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
+
+ if(nCount)
{
- return mpPolygon->isClosed();
+ implForceUniqueCopy();
+ mpPolygon->remove(nIndex, nCount);
}
+ }
- void B2DPolygon::setClosed(sal_Bool bNew)
+ void B2DPolygon::clear()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->isClosed() != bNew)
- {
- implForceUniqueCopy();
- mpPolygon->setClosed(bNew);
- }
+ mpPolygon->decRefCount();
+ }
+ else
+ {
+ delete mpPolygon;
}
- void B2DPolygon::flip()
+ mpPolygon = &maStaticDefaultPolygon;
+ mpPolygon->incRefCount();
+ }
+
+ sal_Bool B2DPolygon::isClosed() const
+ {
+ return mpPolygon->isClosed();
+ }
+
+ void B2DPolygon::setClosed(sal_Bool bNew)
+ {
+ if(mpPolygon->isClosed() != bNew)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->flip();
- }
+ implForceUniqueCopy();
+ mpPolygon->setClosed(bNew);
}
+ }
- sal_Bool B2DPolygon::hasDoublePoints() const
+ void B2DPolygon::flip()
+ {
+ if(mpPolygon->count() > 1)
{
- return mpPolygon->hasDoublePoints();
+ implForceUniqueCopy();
+ mpPolygon->flip();
}
+ }
- void B2DPolygon::removeDoublePoints()
+ sal_Bool B2DPolygon::hasDoublePoints() const
+ {
+ return mpPolygon->hasDoublePoints();
+ }
+
+ void B2DPolygon::removeDoublePoints()
+ {
+ if(mpPolygon->count() > 1)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->removeDoublePointsAtBeginEnd();
- mpPolygon->removeDoublePointsWholeTrack();
- }
+ implForceUniqueCopy();
+ mpPolygon->removeDoublePointsAtBeginEnd();
+ mpPolygon->removeDoublePointsWholeTrack();
}
+ }
- void B2DPolygon::transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void B2DPolygon::transform(const ::basegfx::B2DHomMatrix& rMatrix)
+ {
+ if(mpPolygon->count())
{
- if(mpPolygon->count())
- {
- implForceUniqueCopy();
- mpPolygon->transform(rMatrix);
- }
+ implForceUniqueCopy();
+ mpPolygon->transform(rMatrix);
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index c2a6faf8909a..6f5ef6e89fba 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygontools.cxx,v $
*
- * $Revision: 1.8 $
+ * $Revision: 1.9 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:11 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:05 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,6 +71,10 @@
#include <basegfx/polygon/b2dpolygon.hxx>
#endif
+#ifndef _BGFX_POLYGON_B2DPOLYPOLYGON_HXX
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#endif
+
#ifndef _BGFX_NUMERIC_FTOOLS_HXX
#include <basegfx/numeric/ftools.hxx>
#endif
@@ -91,925 +95,993 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B2DPolygon tools
+ void checkClosed(B2DPolygon& rCandidate)
{
- // B2DPolygon tools
- void checkClosed(polygon::B2DPolygon& rCandidate)
+ while(rCandidate.count() > 1L
+ && rCandidate.getB2DPoint(0L).equal(rCandidate.getB2DPoint(rCandidate.count() - 1L)))
{
- while(rCandidate.count() > 1L
- && rCandidate.getB2DPoint(0L).equal(rCandidate.getB2DPoint(rCandidate.count() - 1L)))
- {
- rCandidate.setClosed(sal_True);
- rCandidate.remove(rCandidate.count() - 1L);
- }
+ rCandidate.setClosed(sal_True);
+ rCandidate.remove(rCandidate.count() - 1L);
}
+ }
+
+ // Get index of outmost point (e.g. biggest X and biggest Y)
+ sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nRetval(0L);
- // Get index of outmost point (e.g. biggest X and biggest Y)
- sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(rCandidate.count())
{
- sal_uInt32 nRetval(0L);
+ ::basegfx::B2DPoint aOutmostPoint(rCandidate.getB2DPoint(0L));
- if(rCandidate.count())
+ for(sal_uInt32 a(1L); a < rCandidate.count(); a++)
{
- ::basegfx::point::B2DPoint aOutmostPoint(rCandidate.getB2DPoint(0L));
+ ::basegfx::B2DPoint rPoint(rCandidate.getB2DPoint(a));
- for(sal_uInt32 a(1L); a < rCandidate.count(); a++)
+ if(::basegfx::fTools::more(rPoint.getX(), aOutmostPoint.getX()))
{
- ::basegfx::point::B2DPoint rPoint(rCandidate.getB2DPoint(a));
-
- if(::basegfx::numeric::fTools::more(rPoint.getX(), aOutmostPoint.getX()))
+ nRetval = a;
+ aOutmostPoint = rPoint;
+ }
+ else
+ {
+ if(::basegfx::fTools::more(rPoint.getY(), aOutmostPoint.getY()))
{
nRetval = a;
aOutmostPoint = rPoint;
}
- else
- {
- if(::basegfx::numeric::fTools::more(rPoint.getY(), aOutmostPoint.getY()))
- {
- nRetval = a;
- aOutmostPoint = rPoint;
- }
- }
}
}
-
- return nRetval;
}
- // Get successor and predecessor indices. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ return nRetval;
+ }
- if(nIndex)
- {
- return nIndex - 1L;
- }
- else if(rCandidate.count())
- {
- return rCandidate.count() - 1L;
- }
- else
- {
- return nIndex;
- }
- }
+ // Get successor and predecessor indices. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(nIndex)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
-
- if(nIndex + 1L < rCandidate.count())
- {
- return nIndex + 1L;
- }
- else
- {
- return 0L;
- }
+ return nIndex - 1L;
}
-
- sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ else if(rCandidate.count())
{
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
-
- if(rCandidate.count() > 1)
- {
- nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
+ return rCandidate.count() - 1L;
+ }
+ else
+ {
+ return nIndex;
+ }
+ }
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
- }
- }
+ sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- return nNewIndex;
+ if(nIndex + 1L < rCandidate.count())
+ {
+ return nIndex + 1L;
}
+ else
+ {
+ return 0L;
+ }
+ }
+
+ sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(rCandidate.count() > 1)
{
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- if(rCandidate.count() > 1)
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
{
- nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
-
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
- }
+ nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
}
-
- return nNewIndex;
}
- ::basegfx::vector::B2DVectorOrientation getOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ return nNewIndex;
+ }
+
+ sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+
+ if(rCandidate.count() > 1)
{
- ::basegfx::vector::B2DVectorOrientation eRetval(::basegfx::vector::ORIENTATION_NEUTRAL);
+ nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- if(rCandidate.count() > 2)
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
{
- sal_uInt32 nIndex = getIndexOfOutmostPoint(rCandidate);
- eRetval = getPointOrientation(rCandidate, nIndex);
+ nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
}
-
- return eRetval;
}
- ::basegfx::vector::B2DVectorContinuity getContinuityInPoint(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ return nNewIndex;
+ }
+
+ ::basegfx::B2DVectorOrientation getOrientation(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ ::basegfx::B2DVectorOrientation eRetval(::basegfx::ORIENTATION_NEUTRAL);
+
+ if(rCandidate.count() > 2)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- ::basegfx::vector::B2DVectorContinuity eRetval(::basegfx::vector::CONTINUITY_NONE);
+ sal_uInt32 nIndex = getIndexOfOutmostPoint(rCandidate);
+ eRetval = getPointOrientation(rCandidate, nIndex);
+ }
- if(rCandidate.count() > 1L && rCandidate.areControlPointsUsed())
- {
- sal_uInt32 nPrevInd(getIndexOfPredecessor(nIndex, rCandidate));
- const ::basegfx::vector::B2DVector aForwardVector(rCandidate.getControlVectorA(nIndex));
- const ::basegfx::vector::B2DVector aBackVector(rCandidate.getControlVectorB(nPrevInd));
+ return eRetval;
+ }
- eRetval = ::basegfx::vector::getContinuity(aBackVector, aForwardVector);
- }
+ ::basegfx::B2DVectorContinuity getContinuityInPoint(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ ::basegfx::B2DVectorContinuity eRetval(::basegfx::CONTINUITY_NONE);
+
+ if(rCandidate.count() > 1L && rCandidate.areControlPointsUsed())
+ {
+ sal_uInt32 nPrevInd(getIndexOfPredecessor(nIndex, rCandidate));
+ const ::basegfx::B2DVector aForwardVector(rCandidate.getControlVectorA(nIndex));
+ const ::basegfx::B2DVector aBackVector(rCandidate.getControlVectorB(nPrevInd));
- return eRetval;
+ eRetval = ::basegfx::getContinuity(aBackVector, aForwardVector);
}
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistanceBound)
+ return eRetval;
+ }
+
+ ::basegfx::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolygon& rCandidate, double fDistanceBound)
+ {
+ ::basegfx::B2DPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aRetval(rCandidate);
+ const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ aRetval.clear();
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
- aRetval.clear();
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!aVectorA.equalZero() || !aVectorB.equalZero())
{
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
-
- if(!aVectorA.equalZero() || !aVectorB.equalZero())
- {
- // vectors are used, get points
- const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
- ::basegfx::point::B2DPoint aPointA(rCandidate.getB2DPoint(a));
- ::basegfx::point::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
-
- // build CubicBezier segment
- ::basegfx::curve::B2DCubicBezier aBezier(
- aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
-
- // generate DistanceBound
- double fBound;
+ // vectors are used, get points
+ const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
+ ::basegfx::B2DPoint aPointA(rCandidate.getB2DPoint(a));
+ ::basegfx::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
- if(0.0 == fDistanceBound)
- {
- // If not set, calculate rough length of bezier segment by taking
- // half of the sum of the edge and the control polygon
- ::basegfx::vector::B2DVector aSimpleDistance(aPointB - aPointA);
- ::basegfx::vector::B2DVector aTripleDistanceTop((aPointB + aVectorB) - (aPointA + aVectorA));
- const double fRoughLength(
- (aSimpleDistance.getLength()
- + (aVectorA.getLength() + aVectorB.getLength() + aTripleDistanceTop.getLength())) / 2.0);
-
- // take 1/100th of the rouch curve length
- fBound = fRoughLength * 0.01;
- }
- else
- {
- // use given bound value
- fBound = fDistanceBound;
- }
+ // build CubicBezier segment
+ ::basegfx::B2DCubicBezier aBezier(
+ aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
- // make sure bound value is not too small. The base units are 1/100th mm, thus
- // just make sure it's not smaller then 1/100th of that
- if(fBound < 0.01)
- {
- fBound = 0.01;
- }
+ // generate DistanceBound
+ double fBound;
- // call adaptive subdivide
- ::basegfx::curve::adaptiveSubdivideByDistance(aRetval, aBezier, fBound);
+ if(0.0 == fDistanceBound)
+ {
+ // If not set, calculate rough length of bezier segment by taking
+ // half of the sum of the edge and the control polygon
+ ::basegfx::B2DVector aSimpleDistance(aPointB - aPointA);
+ ::basegfx::B2DVector aTripleDistanceTop((aPointB + aVectorB) - (aPointA + aVectorA));
+ const double fRoughLength(
+ (aSimpleDistance.getLength()
+ + (aVectorA.getLength() + aVectorB.getLength() + aTripleDistanceTop.getLength())) / 2.0);
+
+ // take 1/100th of the rouch curve length
+ fBound = fRoughLength * 0.01;
}
else
{
- // no vectors used, add point
- aRetval.append(rCandidate.getB2DPoint(a));
+ // use given bound value
+ fBound = fDistanceBound;
+ }
+
+ // make sure bound value is not too small. The base units are 1/100th mm, thus
+ // just make sure it's not smaller then 1/100th of that
+ if(fBound < 0.01)
+ {
+ fBound = 0.01;
}
- }
- // check closed flag, aRetval was cleared and thus it may be invalid.
- if(aRetval.isClosed() != rCandidate.isClosed())
+ // call adaptive subdivide
+ ::basegfx::adaptiveSubdivideByDistance(aRetval, aBezier, fBound);
+ }
+ else
{
- aRetval.setClosed(rCandidate.isClosed());
+ // no vectors used, add point
+ aRetval.append(rCandidate.getB2DPoint(a));
}
}
- return aRetval;
+ // check closed flag, aRetval was cleared and thus it may be invalid.
+ if(aRetval.isClosed() != rCandidate.isClosed())
+ {
+ aRetval.setClosed(rCandidate.isClosed());
+ }
}
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolygon& rCandidate, double fAngleBound)
+ return aRetval;
+ }
+
+ ::basegfx::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolygon& rCandidate, double fAngleBound)
+ {
+ ::basegfx::B2DPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aRetval(rCandidate);
+ const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ aRetval.clear();
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
- aRetval.clear();
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!aVectorA.equalZero() || !aVectorB.equalZero())
{
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
-
- if(!aVectorA.equalZero() || !aVectorB.equalZero())
- {
- // vectors are used, get points
- const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
- ::basegfx::point::B2DPoint aPointA(rCandidate.getB2DPoint(a));
- ::basegfx::point::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
+ // vectors are used, get points
+ const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
+ ::basegfx::B2DPoint aPointA(rCandidate.getB2DPoint(a));
+ ::basegfx::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
- // build CubicBezier segment
- ::basegfx::curve::B2DCubicBezier aBezier(
- aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
+ // build CubicBezier segment
+ ::basegfx::B2DCubicBezier aBezier(
+ aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
- // generate AngleBound
- double fBound(fAngleBound);
+ // generate AngleBound
+ double fBound(fAngleBound);
- // make sure angle bound is not too small
- if(::basegfx::numeric::fTools::less(fAngleBound, 0.1))
- {
- fAngleBound = 0.1;
- }
-
- // call adaptive subdivide
- ::basegfx::curve::adaptiveSubdivideByAngle(aRetval, aBezier, fBound);
- }
- else
+ // make sure angle bound is not too small
+ if(::basegfx::fTools::less(fAngleBound, 0.1))
{
- // no vectors used, add point
- aRetval.append(rCandidate.getB2DPoint(a));
+ fAngleBound = 0.1;
}
- }
- // check closed flag, aRetval was cleared and thus it may be invalid.
- if(aRetval.isClosed() != rCandidate.isClosed())
+ // call adaptive subdivide
+ ::basegfx::adaptiveSubdivideByAngle(aRetval, aBezier, fBound);
+ }
+ else
{
- aRetval.setClosed(rCandidate.isClosed());
+ // no vectors used, add point
+ aRetval.append(rCandidate.getB2DPoint(a));
}
}
- return aRetval;
+ // check closed flag, aRetval was cleared and thus it may be invalid.
+ if(aRetval.isClosed() != rCandidate.isClosed())
+ {
+ aRetval.setClosed(rCandidate.isClosed());
+ }
}
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::point::B2DPoint& rPoint, sal_Bool bWithBorder)
+ return aRetval;
+ }
+
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPoint& rPoint, sal_Bool bWithBorder)
+ {
+ sal_Bool bRetval(sal_False);
+ const sal_uInt32 nPointCount(rCandidate.count());
+
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- sal_Bool bRetval(sal_False);
- const sal_uInt32 nPointCount(rCandidate.count());
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(bWithBorder && aCurrentPoint.equal(rPoint))
{
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ return sal_True;
+ }
- if(bWithBorder && aCurrentPoint.equal(rPoint))
- {
- return sal_True;
- }
+ // cross-over in Y?
+ const ::basegfx::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
+ const sal_Bool bCompYA(::basegfx::fTools::more(aPreviousPoint.getY(), rPoint.getY()));
+ const sal_Bool bCompYB(::basegfx::fTools::more(aCurrentPoint.getY(), rPoint.getY()));
- // cross-over in Y?
- const ::basegfx::point::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
- const sal_Bool bCompYA(::basegfx::numeric::fTools::more(aPreviousPoint.getY(), rPoint.getY()));
- const sal_Bool bCompYB(::basegfx::numeric::fTools::more(aCurrentPoint.getY(), rPoint.getY()));
+ if(bCompYA != bCompYB)
+ {
+ const sal_Bool bCompXA(::basegfx::fTools::more(aPreviousPoint.getX(), rPoint.getX()));
+ const sal_Bool bCompXB(::basegfx::fTools::more(aCurrentPoint.getX(), rPoint.getX()));
- if(bCompYA != bCompYB)
+ if(bCompXA == bCompXB)
{
- const sal_Bool bCompXA(::basegfx::numeric::fTools::more(aPreviousPoint.getX(), rPoint.getX()));
- const sal_Bool bCompXB(::basegfx::numeric::fTools::more(aCurrentPoint.getX(), rPoint.getX()));
+ if(bCompXA)
+ {
+ bRetval = !bRetval;
+ }
+ }
+ else
+ {
+ const double fCompare =
+ aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
+ (aPreviousPoint.getX() - aCurrentPoint.getX()) /
+ (aPreviousPoint.getY() - aCurrentPoint.getY());
- if(bCompXA == bCompXB)
+ if(bWithBorder && ::basegfx::fTools::more(fCompare, rPoint.getX()))
{
- if(bCompXA)
- {
- bRetval = !bRetval;
- }
+ bRetval = !bRetval;
}
- else
+ else if(::basegfx::fTools::moreOrEqual(fCompare, rPoint.getX()))
{
- const double fCompare =
- aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
- (aPreviousPoint.getX() - aCurrentPoint.getX()) /
- (aPreviousPoint.getY() - aCurrentPoint.getY());
-
- if(bWithBorder && ::basegfx::numeric::fTools::more(fCompare, rPoint.getX()))
- {
- bRetval = !bRetval;
- }
- else if(::basegfx::numeric::fTools::moreOrEqual(fCompare, rPoint.getX()))
- {
- bRetval = !bRetval;
- }
+ bRetval = !bRetval;
}
}
}
-
- return bRetval;
}
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::polygon::B2DPolygon& rPolygon, sal_Bool bWithBorder)
+ return bRetval;
+ }
+
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPolygon& rPolygon, sal_Bool bWithBorder)
+ {
+ const sal_uInt32 nPointCount(rPolygon.count());
+
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rPolygon.count());
+ const ::basegfx::B2DPoint aTestPoint(rPolygon.getB2DPoint(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!isInside(rCandidate, aTestPoint, bWithBorder))
{
- const ::basegfx::point::B2DPoint aTestPoint(rPolygon.getB2DPoint(a));
-
- if(!isInside(rCandidate, aTestPoint, bWithBorder))
- {
- return sal_False;
- }
+ return sal_False;
}
-
- return sal_True;
}
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- ::basegfx::range::B2DRange aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
+ return sal_True;
+ }
+
+ ::basegfx::B2DRange getRange(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ ::basegfx::B2DRange aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
- if(rCandidate.areControlPointsUsed())
+ if(rCandidate.areControlPointsUsed())
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- aRetval.expand(aTestPoint);
+ const ::basegfx::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
+ aRetval.expand(aTestPoint);
- if(!aVectorA.equalZero())
- {
- aRetval.expand(aTestPoint + aVectorA);
- }
+ if(!aVectorA.equalZero())
+ {
+ aRetval.expand(aTestPoint + aVectorA);
+ }
- if(!aVectorB.equalZero())
- {
- const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- aRetval.expand(aNextPoint + aVectorB);
- }
+ if(!aVectorB.equalZero())
+ {
+ const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ aRetval.expand(aNextPoint + aVectorB);
}
}
- else
+ }
+ else
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
- aRetval.expand(aTestPoint);
- }
+ const ::basegfx::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
+ aRetval.expand(aTestPoint);
}
-
- return aRetval;
}
- double getArea(const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return aRetval;
+ }
- if(nPointCount > 2)
+ double getArea(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
+
+ if(nPointCount > 2)
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- fRetval += aPreviousPoint.getX() * aCurrentPoint.getY();
- fRetval -= aPreviousPoint.getY() * aCurrentPoint.getX();
- }
+ fRetval += aPreviousPoint.getX() * aCurrentPoint.getY();
+ fRetval -= aPreviousPoint.getY() * aCurrentPoint.getX();
+ }
- fRetval /= 2.0;
+ fRetval /= 2.0;
- const double fZero(0.0);
+ const double fZero(0.0);
- if(::basegfx::numeric::fTools::less(fRetval, fZero))
- {
- fRetval = -fRetval;
- }
+ if(::basegfx::fTools::less(fRetval, fZero))
+ {
+ fRetval = -fRetval;
}
-
- return fRetval;
}
- double getEdgeLength(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
- {
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return fRetval;
+ }
+
+ double getEdgeLength(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
- if(nIndex < nPointCount)
+ if(nIndex < nPointCount)
+ {
+ if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
{
- if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
- {
- const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(nIndex));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- const ::basegfx::vector::B2DVector aVector(aNextPoint - aCurrentPoint);
- fRetval = aVector.getLength();
- }
+ const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(nIndex));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval = aVector.getLength();
}
+ }
+
+ return fRetval;
+ }
- return fRetval;
+ double getLength(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ // This method may also be implemented using a loop over getEdgeLength, but
+ // since this would cause a lot of sqare roots to be solved it is much better
+ // to sum up the quadrats first and then use a singe suare root (if necessary)
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
+ const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
+
+ for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ {
+ const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval += aVector.scalar(aVector);
}
- double getLength(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(!::basegfx::fTools::equalZero(fRetval))
{
- // This method may also be implemented using a loop over getEdgeLength, but
- // since this would cause a lot of sqare roots to be solved it is much better
- // to sum up the quadrats first and then use a singe suare root (if necessary)
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
- const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
+ const double fOne(1.0);
- for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ if(!::basegfx::fTools::equal(fOne, fRetval))
{
- const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- const ::basegfx::vector::B2DVector aVector(aNextPoint - aCurrentPoint);
- fRetval += aVector.scalar(aVector);
+ fRetval = sqrt(fRetval);
}
+ }
- if(!::basegfx::numeric::fTools::equalZero(fRetval))
- {
- const double fOne(1.0);
+ return fRetval;
+ }
- if(!::basegfx::numeric::fTools::equal(fOne, fRetval))
- {
- fRetval = sqrt(fRetval);
- }
- }
-
- return fRetval;
- }
+ ::basegfx::B2DPoint getPositionAbsolute(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ ::basegfx::B2DPoint aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
- ::basegfx::point::B2DPoint getPositionAbsolute(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength)
+ if(nPointCount > 1L)
{
- ::basegfx::point::B2DPoint aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
+ sal_uInt32 nIndex(0L);
+ sal_Bool bIndexDone(sal_False);
+ const double fZero(0.0);
+ double fEdgeLength(fZero);
- if(nPointCount > 1L)
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
{
- sal_uInt32 nIndex(0L);
- sal_Bool bIndexDone(sal_False);
- const double fZero(0.0);
- double fEdgeLength(fZero);
+ fLength = getLength(rCandidate);
+ }
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
+ // handle fDistance < 0.0
+ if(::basegfx::fTools::less(fDistance, fZero))
+ {
+ if(rCandidate.isClosed())
{
- fLength = getLength(rCandidate);
+ // 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 = sal_True;
+ }
+ }
- // handle fDistance < 0.0
- if(::basegfx::numeric::fTools::less(fDistance, fZero))
+ // handle fDistance >= fLength
+ if(::basegfx::fTools::moreOrEqual(fDistance, fLength))
+ {
+ if(rCandidate.isClosed())
{
- 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 = sal_True;
- }
+ // 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 = sal_True;
}
+ }
- // handle fDistance >= fLength
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fLength))
+ // look for correct index. fDistance is now [0.0 .. fLength[
+ if(!bIndexDone)
+ {
+ do
{
- if(rCandidate.isClosed())
+ // get length of next edge
+ fEdgeLength = getEdgeLength(rCandidate, nIndex);
+
+ if(::basegfx::fTools::moreOrEqual(fDistance, fEdgeLength))
{
- // if fDistance >= fLength decrement with multiple of fLength
- sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
- fDistance -= (double)(nCount) * fLength;
+ // go to next edge
+ fDistance -= fEdgeLength;
+ nIndex++;
}
else
{
- // crop to polygon end
- fDistance = fZero;
- nIndex = nPointCount - 1L;
+ // it's on this edge, stop
bIndexDone = sal_True;
}
- }
-
- // look for correct index. fDistance is now [0.0 .. fLength[
- if(!bIndexDone)
- {
- do
- {
- // get length of next edge
- fEdgeLength = getEdgeLength(rCandidate, nIndex);
+ } while (!bIndexDone);
+ }
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fEdgeLength))
- {
- // go to next edge
- fDistance -= fEdgeLength;
- nIndex++;
- }
- else
- {
- // it's on this edge, stop
- bIndexDone = sal_True;
- }
- } while (!bIndexDone);
- }
+ // get the point using nIndex
+ aRetval = rCandidate.getB2DPoint(nIndex);
- // get the point using nIndex
- aRetval = rCandidate.getB2DPoint(nIndex);
+ // if fDistance != 0.0, move that length on the edge. The edge
+ // length is in fEdgeLength.
+ if(!::basegfx::fTools::equalZero(fDistance))
+ {
+ sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ double fRelative(fZero);
- // if fDistance != 0.0, move that length on the edge. The edge
- // length is in fEdgeLength.
- if(!::basegfx::numeric::fTools::equalZero(fDistance))
+ if(!::basegfx::fTools::equalZero(fEdgeLength))
{
- sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- double fRelative(fZero);
-
- if(!::basegfx::numeric::fTools::equalZero(fEdgeLength))
- {
- fRelative = fDistance / fEdgeLength;
- }
-
- // add calculated average value to the return value
- aRetval += ::basegfx::tuple::average(aRetval, aNextPoint, fRelative);
+ fRelative = fDistance / fEdgeLength;
}
- }
- return aRetval;
+ // add calculated average value to the return value
+ aRetval = ::basegfx::interpolate(aRetval, aNextPoint, fRelative);
+ }
}
- ::basegfx::point::B2DPoint getPositionRelative(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength)
- {
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
- {
- fLength = getLength(rCandidate);
- }
+ return aRetval;
+ }
- // multiply fDistance with real length to get absolute position and
- // use getPositionAbsolute
- return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ ::basegfx::B2DPoint getPositionRelative(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
+ {
+ fLength = getLength(rCandidate);
}
- ::basegfx::vector::B2DVectorOrientation getPointOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ // multiply fDistance with real length to get absolute position and
+ // use getPositionAbsolute
+ return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ }
+
+ ::basegfx::B2DVectorOrientation getPointOrientation(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ ::basegfx::B2DVectorOrientation eRetval(::basegfx::ORIENTATION_NEUTRAL);
+
+ if(rCandidate.count() > 2)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- ::basegfx::vector::B2DVectorOrientation eRetval(::basegfx::vector::ORIENTATION_NEUTRAL);
+ sal_uInt32 nIndPrev = getIndexOfDifferentPredecessor(nIndex, rCandidate);
- if(rCandidate.count() > 2)
+ if(nIndPrev != nIndex)
{
- sal_uInt32 nIndPrev = getIndexOfDifferentPredecessor(nIndex, rCandidate);
+ sal_uInt32 nIndNext = getIndexOfDifferentSuccessor(nIndex, rCandidate);
- if(nIndPrev != nIndex)
+ if(nIndNext != nIndex && nIndNext != nIndPrev)
{
- sal_uInt32 nIndNext = getIndexOfDifferentSuccessor(nIndex, rCandidate);
-
- if(nIndNext != nIndex && nIndNext != nIndPrev)
- {
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- ::basegfx::vector::B2DVector aVecPrev(rCandidate.getB2DPoint(nIndPrev) - aPoint);
- ::basegfx::vector::B2DVector aVecNext(rCandidate.getB2DPoint(nIndNext) - aPoint);
- eRetval = ::basegfx::vector::getOrientation(aVecPrev, aVecNext);
- }
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
+ ::basegfx::B2DVector aVecPrev(rCandidate.getB2DPoint(nIndPrev) - aPoint);
+ ::basegfx::B2DVector aVecNext(rCandidate.getB2DPoint(nIndNext) - aPoint);
+ eRetval = ::basegfx::getOrientation(aVecPrev, aVecNext);
}
}
-
- return eRetval;
}
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate,
- sal_uInt32 nIndex1, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return eRetval;
+ }
- if(nIndex1 < nPointCount && nIndex2 < nPointCount && nIndex1 != nIndex2)
- {
- sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate));
- sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate));
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate,
+ sal_uInt32 nIndex1, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ const sal_uInt32 nPointCount(rCandidate.count());
- const ::basegfx::point::B2DPoint aStart1(rCandidate.getB2DPoint(nIndex1));
- const ::basegfx::point::B2DPoint aEnd1(rCandidate.getB2DPoint(nEnd1));
- const ::basegfx::vector::B2DVector aVector1(aEnd1 - aStart1);
+ if(nIndex1 < nPointCount && nIndex2 < nPointCount && nIndex1 != nIndex2)
+ {
+ sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate));
+ sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate));
- const ::basegfx::point::B2DPoint aStart2(rCandidate.getB2DPoint(nIndex2));
- const ::basegfx::point::B2DPoint aEnd2(rCandidate.getB2DPoint(nEnd2));
- const ::basegfx::vector::B2DVector aVector2(aEnd2 - aStart2);
+ const ::basegfx::B2DPoint aStart1(rCandidate.getB2DPoint(nIndex1));
+ const ::basegfx::B2DPoint aEnd1(rCandidate.getB2DPoint(nEnd1));
+ const ::basegfx::B2DVector aVector1(aEnd1 - aStart1);
- aRetval = findCut(
- aStart1, aVector1, aStart2, aVector2,
- aCutFlags, pCut1, pCut2);
- }
+ const ::basegfx::B2DPoint aStart2(rCandidate.getB2DPoint(nIndex2));
+ const ::basegfx::B2DPoint aEnd2(rCandidate.getB2DPoint(nEnd2));
+ const ::basegfx::B2DVector aVector2(aEnd2 - aStart2);
- return aRetval;
+ aRetval = findCut(
+ aStart1, aVector1, aStart2, aVector2,
+ aCutFlags, pCut1, pCut2);
}
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
- const ::basegfx::polygon::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- const sal_uInt32 nPointCount1(rCandidate1.count());
- const sal_uInt32 nPointCount2(rCandidate2.count());
+ return aRetval;
+ }
- if(nIndex1 < nPointCount1 && nIndex2 < nPointCount2)
- {
- sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate1));
- sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate2));
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
+ const ::basegfx::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ const sal_uInt32 nPointCount1(rCandidate1.count());
+ const sal_uInt32 nPointCount2(rCandidate2.count());
- const ::basegfx::point::B2DPoint aStart1(rCandidate1.getB2DPoint(nIndex1));
- const ::basegfx::point::B2DPoint aEnd1(rCandidate1.getB2DPoint(nEnd1));
- const ::basegfx::vector::B2DVector aVector1(aEnd1 - aStart1);
+ if(nIndex1 < nPointCount1 && nIndex2 < nPointCount2)
+ {
+ sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate1));
+ sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate2));
- const ::basegfx::point::B2DPoint aStart2(rCandidate2.getB2DPoint(nIndex2));
- const ::basegfx::point::B2DPoint aEnd2(rCandidate2.getB2DPoint(nEnd2));
- const ::basegfx::vector::B2DVector aVector2(aEnd2 - aStart2);
+ const ::basegfx::B2DPoint aStart1(rCandidate1.getB2DPoint(nIndex1));
+ const ::basegfx::B2DPoint aEnd1(rCandidate1.getB2DPoint(nEnd1));
+ const ::basegfx::B2DVector aVector1(aEnd1 - aStart1);
- aRetval = findCut(
- aStart1, aVector1, aStart2, aVector2,
- aCutFlags, pCut1, pCut2);
- }
+ const ::basegfx::B2DPoint aStart2(rCandidate2.getB2DPoint(nIndex2));
+ const ::basegfx::B2DPoint aEnd2(rCandidate2.getB2DPoint(nEnd2));
+ const ::basegfx::B2DVector aVector2(aEnd2 - aStart2);
- return aRetval;
+ aRetval = findCut(
+ aStart1, aVector1, aStart2, aVector2,
+ aCutFlags, pCut1, pCut2);
}
- CutFlagValue findCut(
- const ::basegfx::point::B2DPoint& rEdge1Start, const ::basegfx::vector::B2DVector& rEdge1Delta,
- const ::basegfx::point::B2DPoint& rEdge2Start, const ::basegfx::vector::B2DVector& rEdge2Delta,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- double fCut1(0.0);
- double fCut2(0.0);
- sal_Bool bFinished(!((sal_Bool)(aCutFlags & CUTFLAG_ALL)));
+ return aRetval;
+ }
- // test for same points?
- if(!bFinished
- && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END1))
- && (aCutFlags & (CUTFLAG_START2|CUTFLAG_END2)))
+ CutFlagValue findCut(
+ const ::basegfx::B2DPoint& rEdge1Start, const ::basegfx::B2DVector& rEdge1Delta,
+ const ::basegfx::B2DPoint& rEdge2Start, const ::basegfx::B2DVector& rEdge2Delta,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ double fCut1(0.0);
+ double fCut2(0.0);
+ sal_Bool bFinished(!((sal_Bool)(aCutFlags & CUTFLAG_ALL)));
+
+ // test for same points?
+ if(!bFinished
+ && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END1))
+ && (aCutFlags & (CUTFLAG_START2|CUTFLAG_END2)))
+ {
+ // same startpoint?
+ if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_START2)) == (CUTFLAG_START1|CUTFLAG_START2))
{
- // same startpoint?
- if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_START2)) == (CUTFLAG_START1|CUTFLAG_START2))
+ if(rEdge1Start.equal(rEdge2Start))
{
- if(rEdge1Start.equal(rEdge2Start))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START1|CUTFLAG_START2);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START1|CUTFLAG_START2);
}
+ }
- // same endpoint?
- if(!bFinished && (aCutFlags & (CUTFLAG_END1|CUTFLAG_END2)) == (CUTFLAG_END1|CUTFLAG_END2))
- {
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ // same endpoint?
+ if(!bFinished && (aCutFlags & (CUTFLAG_END1|CUTFLAG_END2)) == (CUTFLAG_END1|CUTFLAG_END2))
+ {
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(aEnd1.equal(aEnd2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_END1|CUTFLAG_END2);
- fCut1 = fCut2 = 1.0;
- }
+ if(aEnd1.equal(aEnd2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_END1|CUTFLAG_END2);
+ fCut1 = fCut2 = 1.0;
}
+ }
- // startpoint1 == endpoint2?
- if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END2)) == (CUTFLAG_START1|CUTFLAG_END2))
- {
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ // startpoint1 == endpoint2?
+ if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END2)) == (CUTFLAG_START1|CUTFLAG_END2))
+ {
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(rEdge1Start.equal(aEnd2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START1|CUTFLAG_END2);
- fCut1 = 0.0;
- fCut2 = 1.0;
- }
+ if(rEdge1Start.equal(aEnd2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START1|CUTFLAG_END2);
+ fCut1 = 0.0;
+ fCut2 = 1.0;
}
+ }
- // startpoint2 == endpoint1?
- if(!bFinished&& (aCutFlags & (CUTFLAG_START2|CUTFLAG_END1)) == (CUTFLAG_START2|CUTFLAG_END1))
- {
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ // startpoint2 == endpoint1?
+ if(!bFinished&& (aCutFlags & (CUTFLAG_START2|CUTFLAG_END1)) == (CUTFLAG_START2|CUTFLAG_END1))
+ {
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- if(rEdge2Start.equal(aEnd1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START2|CUTFLAG_END1);
- fCut1 = 1.0;
- fCut2 = 0.0;
- }
+ if(rEdge2Start.equal(aEnd1))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START2|CUTFLAG_END1);
+ fCut1 = 1.0;
+ fCut2 = 0.0;
}
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_LINE))
+ if(!bFinished && (aCutFlags & CUTFLAG_LINE))
+ {
+ if(!bFinished && (aCutFlags & CUTFLAG_START1))
{
- if(!bFinished && (aCutFlags & CUTFLAG_START1))
+ // start1 on line 2 ?
+ if(isPointOnEdge(rEdge1Start, rEdge2Start, rEdge2Delta, &fCut2))
{
- // start1 on line 2 ?
- if(isPointOnEdge(rEdge1Start, rEdge2Start, rEdge2Delta, &fCut2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_START1);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_START1);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_START2))
+ if(!bFinished && (aCutFlags & CUTFLAG_START2))
+ {
+ // start2 on line 1 ?
+ if(isPointOnEdge(rEdge2Start, rEdge1Start, rEdge1Delta, &fCut1))
{
- // start2 on line 1 ?
- if(isPointOnEdge(rEdge2Start, rEdge1Start, rEdge1Delta, &fCut1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_START2);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_START2);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_END1))
- {
- // end1 on line 2 ?
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ if(!bFinished && (aCutFlags & CUTFLAG_END1))
+ {
+ // end1 on line 2 ?
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- if(isPointOnEdge(aEnd1, rEdge2Start, rEdge2Delta, &fCut2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_END1);
- }
+ if(isPointOnEdge(aEnd1, rEdge2Start, rEdge2Delta, &fCut2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_END1);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_END2))
- {
- // end2 on line 1 ?
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ if(!bFinished && (aCutFlags & CUTFLAG_END2))
+ {
+ // end2 on line 1 ?
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(isPointOnEdge(aEnd2, rEdge1Start, rEdge1Delta, &fCut1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_END2);
- }
+ if(isPointOnEdge(aEnd2, rEdge1Start, rEdge1Delta, &fCut1))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_END2);
}
+ }
+
+ if(!bFinished)
+ {
+ // cut in line1, line2 ?
+ fCut1 = (rEdge1Delta.getX() * rEdge2Delta.getY()) - (rEdge1Delta.getY() * rEdge2Delta.getX());
- if(!bFinished)
+ if(!::basegfx::fTools::equalZero(fCut1))
{
- // cut in line1, line2 ?
- fCut1 = (rEdge1Delta.getX() * rEdge2Delta.getY()) - (rEdge1Delta.getY() * rEdge2Delta.getX());
+ fCut1 = (rEdge2Delta.getY() * (rEdge2Start.getX() - rEdge1Start.getX())
+ + rEdge2Delta.getX() * (rEdge1Start.getY() - rEdge2Start.getY())) / fCut1;
- if(!::basegfx::numeric::fTools::equalZero(fCut1))
- {
- fCut1 = (rEdge2Delta.getY() * (rEdge2Start.getX() - rEdge1Start.getX())
- + rEdge2Delta.getX() * (rEdge1Start.getY() - rEdge2Start.getY())) / fCut1;
+ const double fZero(0.0);
+ const double fOne(1.0);
- const double fZero(0.0);
- const double fOne(1.0);
+ // inside parameter range edge1 AND fCut2 is calcable
+ if(::basegfx::fTools::more(fCut1, fZero) && ::basegfx::fTools::less(fCut1, fOne)
+ && (!::basegfx::fTools::equalZero(rEdge2Delta.getX()) || !::basegfx::fTools::equalZero(rEdge2Delta.getY())))
+ {
+ // take the mopre precise calculation of the two possible
+ if(fabs(rEdge2Delta.getX()) > fabs(rEdge2Delta.getY()))
+ {
+ fCut2 = (rEdge1Start.getX() + fCut1
+ * rEdge1Delta.getX() - rEdge2Start.getX()) / rEdge2Delta.getX();
+ }
+ else
+ {
+ fCut2 = (rEdge1Start.getY() + fCut1
+ * rEdge1Delta.getY() - rEdge2Start.getY()) / rEdge2Delta.getY();
+ }
- // inside parameter range edge1 AND fCut2 is calcable
- if(::basegfx::numeric::fTools::more(fCut1, fZero) && ::basegfx::numeric::fTools::less(fCut1, fOne)
- && (!::basegfx::numeric::fTools::equalZero(rEdge2Delta.getX()) || !::basegfx::numeric::fTools::equalZero(rEdge2Delta.getY())))
+ // inside parameter range edge2, too
+ if(::basegfx::fTools::more(fCut2, fZero) && ::basegfx::fTools::less(fCut2, fOne))
{
- // take the mopre precise calculation of the two possible
- if(fabs(rEdge2Delta.getX()) > fabs(rEdge2Delta.getY()))
- {
- fCut2 = (rEdge1Start.getX() + fCut1
- * rEdge1Delta.getX() - rEdge2Start.getX()) / rEdge2Delta.getX();
- }
- else
- {
- fCut2 = (rEdge1Start.getY() + fCut1
- * rEdge1Delta.getY() - rEdge2Start.getY()) / rEdge2Delta.getY();
- }
-
- // inside parameter range edge2, too
- if(::basegfx::numeric::fTools::more(fCut2, fZero) && ::basegfx::numeric::fTools::less(fCut2, fOne))
- {
- bFinished = sal_True;
- aRetval = CUTFLAG_LINE;
- }
+ bFinished = sal_True;
+ aRetval = CUTFLAG_LINE;
}
}
}
}
+ }
- // copy values if wanted
- if(pCut1)
- {
- *pCut1 = fCut1;
- }
-
- if(pCut2)
- {
- *pCut2 = fCut2;
- }
-
- return aRetval;
+ // copy values if wanted
+ if(pCut1)
+ {
+ *pCut1 = fCut1;
}
- sal_Bool isPointOnEdge(
- const ::basegfx::point::B2DPoint& rPoint,
- const ::basegfx::point::B2DPoint& rEdgeStart,
- const ::basegfx::vector::B2DVector& rEdgeDelta,
- double* pCut)
+ if(pCut2)
{
- sal_Bool bDeltaXIsZero(::basegfx::numeric::fTools::equalZero(rEdgeDelta.getX()));
- sal_Bool bDeltaYIsZero(::basegfx::numeric::fTools::equalZero(rEdgeDelta.getY()));
- const double fZero(0.0);
- const double fOne(1.0);
+ *pCut2 = fCut2;
+ }
- if(bDeltaXIsZero && bDeltaYIsZero)
- {
- // no line, just a point
- return sal_False;
- }
- else if(bDeltaXIsZero)
+ return aRetval;
+ }
+
+ sal_Bool isPointOnEdge(
+ const ::basegfx::B2DPoint& rPoint,
+ const ::basegfx::B2DPoint& rEdgeStart,
+ const ::basegfx::B2DVector& rEdgeDelta,
+ double* pCut)
+ {
+ sal_Bool bDeltaXIsZero(::basegfx::fTools::equalZero(rEdgeDelta.getX()));
+ sal_Bool bDeltaYIsZero(::basegfx::fTools::equalZero(rEdgeDelta.getY()));
+ const double fZero(0.0);
+ const double fOne(1.0);
+
+ if(bDeltaXIsZero && bDeltaYIsZero)
+ {
+ // no line, just a point
+ return sal_False;
+ }
+ else if(bDeltaXIsZero)
+ {
+ // vertical line
+ if(::basegfx::fTools::equal(rPoint.getX(), rEdgeStart.getX()))
{
- // vertical line
- if(::basegfx::numeric::fTools::equal(rPoint.getX(), rEdgeStart.getX()))
- {
- double fValue = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+ double fValue = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
- if(::basegfx::numeric::fTools::more(fValue, fZero) && ::basegfx::numeric::fTools::less(fValue, fOne))
+ if(::basegfx::fTools::more(fValue, fZero) && ::basegfx::fTools::less(fValue, fOne))
+ {
+ if(pCut)
{
- if(pCut)
- {
- *pCut = fValue;
- }
-
- return sal_True;
+ *pCut = fValue;
}
+
+ return sal_True;
}
}
- else if(bDeltaYIsZero)
+ }
+ else if(bDeltaYIsZero)
+ {
+ // horizontal line
+ if(::basegfx::fTools::equal(rPoint.getY(), rEdgeStart.getY()))
{
- // horizontal line
- if(::basegfx::numeric::fTools::equal(rPoint.getY(), rEdgeStart.getY()))
- {
- double fValue = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
+ double fValue = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
- if(::basegfx::numeric::fTools::more(fValue, fZero)
- && ::basegfx::numeric::fTools::less(fValue, fOne))
+ if(::basegfx::fTools::more(fValue, fZero)
+ && ::basegfx::fTools::less(fValue, fOne))
+ {
+ if(pCut)
{
- if(pCut)
- {
- *pCut = fValue;
- }
-
- return sal_True;
+ *pCut = fValue;
}
+
+ return sal_True;
}
}
- else
+ }
+ else
+ {
+ // any angle line
+ double fTOne = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
+ double fTTwo = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+
+ if(::basegfx::fTools::equal(fTOne, fTTwo))
{
- // any angle line
- double fTOne = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
- double fTTwo = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+ // same parameter representation, point is on line. Take
+ // middle value for better results
+ double fValue = (fTOne + fTTwo) / 2.0;
- if(::basegfx::numeric::fTools::equal(fTOne, fTTwo))
+ if(::basegfx::fTools::more(fValue, fZero) && ::basegfx::fTools::less(fValue, fOne))
{
- // same parameter representation, point is on line. Take
- // middle value for better results
- double fValue = (fTOne + fTTwo) / 2.0;
+ // point is inside line bounds, too
+ if(pCut)
+ {
+ *pCut = fValue;
+ }
+
+ return sal_True;
+ }
+ }
+ }
- if(::basegfx::numeric::fTools::more(fValue, fZero) && ::basegfx::numeric::fTools::less(fValue, fOne))
+ return sal_False;
+ }
+
+ ::basegfx::B2DPolyPolygon applyLineDashing(const ::basegfx::B2DPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen)
+ {
+ ::basegfx::B2DPolyPolygon aRetval;
+
+ if(rCandidate.count() && fFullDashDotLen > 0.0)
+ {
+ const sal_uInt32 nCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ sal_uInt32 nDashDotIndex(0L);
+ double fDashDotLength(raDashDotArray[nDashDotIndex]);
+
+ for(sal_uInt32 a(0L); a < nCount; a++)
+ {
+ const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
+ const ::basegfx::B2DPoint aStart(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aEnd(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aEnd - aStart);
+ double fLength(aVector.getLength());
+ double fPosOnVector(0.0);
+
+ while(fLength >= fDashDotLength)
+ {
+ // handle [fPosOnVector .. fPosOnVector+fDashDotLength]
+ if(nDashDotIndex % 2)
{
- // point is inside line bounds, too
- if(pCut)
+ ::basegfx::B2DPolygon aResult;
+
+ // add start point
+ if(fPosOnVector == 0.0)
+ {
+ aResult.append(aStart);
+ }
+ else
{
- *pCut = fValue;
+ aResult.append(aStart + (aVector * fPosOnVector));
}
- return sal_True;
+ // add end point
+ aResult.append(aStart + (aVector * (fPosOnVector + fDashDotLength)));
+
+ // add line to PolyPolygon
+ aRetval.append(aResult);
}
+
+ // consume from fDashDotLength
+ fPosOnVector += fDashDotLength;
+ fLength -= fDashDotLength;
+ nDashDotIndex = (nDashDotIndex + 1L) % raDashDotArray.size();
+ fDashDotLength = raDashDotArray[nDashDotIndex];
}
- }
- return sal_False;
+ // handle [fPosOnVector .. fPosOnVector+fLength (bzw. end)]
+ if((fLength > 0.0) && (nDashDotIndex % 2))
+ {
+ ::basegfx::B2DPolygon aResult;
+
+ // add start and end point
+ const ::basegfx::B2DPoint aPosA(aStart + (aVector * fPosOnVector));
+ aResult.append(aPosA);
+
+ // add line to PolyPolygon
+ aRetval.append(aResult);
+ }
+
+ // consume from fDashDotLength
+ fDashDotLength -= fLength;
+ }
}
- } // end of namespace tools
- } // end of namespace polygon
+
+ return aRetval;
+ }
+ } // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolypolygon.cxx b/basegfx/source/polygon/b2dpolypolygon.cxx
index 301d5a68edd8..f6fcbd9c0e55 100644
--- a/basegfx/source/polygon/b2dpolypolygon.cxx
+++ b/basegfx/source/polygon/b2dpolypolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygon.cxx,v $
*
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:11 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -81,7 +81,7 @@
class ImplB2DPolyPolygon
{
- typedef ::std::vector< ::basegfx::polygon::B2DPolygon > PolygonVector;
+ typedef ::std::vector< ::basegfx::B2DPolygon > PolygonVector;
PolygonVector maPolygons;
sal_uInt32 mnRefCount;
@@ -127,17 +127,17 @@ public:
return sal_True;
}
- const ::basegfx::polygon::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
{
return maPolygons[nIndex];
}
- void setB2DPolygon(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rPolygon)
+ void setB2DPolygon(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rPolygon)
{
maPolygons[nIndex] = rPolygon;
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rPolygon, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rPolygon, sal_uInt32 nCount)
{
if(nCount)
{
@@ -148,7 +148,7 @@ public:
}
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolyPolygon& rPolyPolygon)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPolyPolygon& rPolyPolygon)
{
const sal_uInt32 nCount = rPolyPolygon.count();
@@ -209,7 +209,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
for(sal_uInt32 a(0L); a < maPolygons.size(); a++)
{
@@ -222,247 +222,244 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB2DPolyPolygon maStaticDefaultPolyPolygon;
+ // init static default Polygon
+ static ImplB2DPolyPolygon maStaticDefaultPolyPolygon;
- void B2DPolyPolygon::implForceUniqueCopy()
+ void B2DPolyPolygon::implForceUniqueCopy()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- mpPolyPolygon = new ImplB2DPolyPolygon(*mpPolyPolygon);
- }
+ mpPolyPolygon->decRefCount();
+ mpPolyPolygon = new ImplB2DPolyPolygon(*mpPolyPolygon);
}
+ }
- B2DPolyPolygon::B2DPolyPolygon()
- : mpPolyPolygon(&maStaticDefaultPolyPolygon)
- {
- mpPolyPolygon->incRefCount();
- }
+ B2DPolyPolygon::B2DPolyPolygon()
+ : mpPolyPolygon(&maStaticDefaultPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
- B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon)
- : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon)
+ : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
+
+ B2DPolyPolygon::~B2DPolyPolygon()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- mpPolyPolygon->incRefCount();
+ mpPolyPolygon->decRefCount();
}
-
- B2DPolyPolygon::~B2DPolyPolygon()
+ else
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ delete mpPolyPolygon;
}
+ }
- B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon& rPolyPolygon)
+ B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon& rPolyPolygon)
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
-
- mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
- mpPolyPolygon->incRefCount();
-
- return *this;
+ mpPolyPolygon->decRefCount();
}
-
- sal_Bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
+ else
{
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_True;
- }
-
- return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ delete mpPolyPolygon;
}
- sal_Bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
- {
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_False;
- }
+ mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
+ mpPolyPolygon->incRefCount();
- return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
- }
+ return *this;
+ }
- sal_uInt32 B2DPolyPolygon::count() const
+ sal_Bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
{
- return mpPolyPolygon->count();
+ return sal_True;
}
- B2DPolygon B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+ return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
- return mpPolyPolygon->getB2DPolygon(nIndex);
+ sal_Bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
+ {
+ return sal_False;
}
- void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+ return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
- if(mpPolyPolygon->getB2DPolygon(nIndex) != rPolygon)
- {
- implForceUniqueCopy();
- mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
- }
- }
+ sal_uInt32 B2DPolyPolygon::count() const
+ {
+ return mpPolyPolygon->count();
+ }
- sal_Bool B2DPolyPolygon::areControlPointsUsed() const
- {
- for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
- {
- const ::basegfx::polygon::B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
+ B2DPolygon B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
- if(rPolygon.areControlPointsUsed())
- {
- return sal_True;
- }
- }
+ return mpPolyPolygon->getB2DPolygon(nIndex);
+ }
- return sal_False;
+ void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+
+ if(mpPolyPolygon->getB2DPolygon(nIndex) != rPolygon)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
}
+ }
- void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ sal_Bool B2DPolyPolygon::areControlPointsUsed() const
+ {
+ for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
{
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
+ const ::basegfx::B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
- if(nCount)
+ if(rPolygon.areControlPointsUsed())
{
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolygon, nCount);
+ return sal_True;
}
}
- void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ return sal_False;
+ }
+
+ void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
+
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolygon, nCount);
}
+ }
- void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
+ void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
-
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
}
+ }
+
+ void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
- void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
+ if(rPolyPolygon.count())
{
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolyPolygon);
}
+ }
- void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
+ {
+ if(rPolyPolygon.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
-
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->remove(nIndex, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
}
+ }
- void B2DPolyPolygon::clear()
- {
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
- mpPolyPolygon = &maStaticDefaultPolyPolygon;
- mpPolyPolygon->incRefCount();
+ if(nCount)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->remove(nIndex, nCount);
}
+ }
- sal_Bool B2DPolyPolygon::isClosed() const
+ void B2DPolyPolygon::clear()
+ {
+ if(mpPolyPolygon->getRefCount())
+ {
+ mpPolyPolygon->decRefCount();
+ }
+ else
{
- sal_Bool bRetval(sal_True);
+ delete mpPolyPolygon;
+ }
- // PolyPOlygon is closed when all contained Polygons are closed or
- // no Polygon exists.
- for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
- {
- if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
- {
- bRetval = sal_False;
- }
- }
+ mpPolyPolygon = &maStaticDefaultPolyPolygon;
+ mpPolyPolygon->incRefCount();
+ }
- return bRetval;
- }
+ sal_Bool B2DPolyPolygon::isClosed() const
+ {
+ sal_Bool bRetval(sal_True);
- void B2DPolyPolygon::setClosed(sal_Bool bNew)
+ // PolyPOlygon is closed when all contained Polygons are closed or
+ // no Polygon exists.
+ for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
{
- if(bNew != isClosed())
+ if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
{
- implForceUniqueCopy();
- mpPolyPolygon->setClosed(bNew);
+ bRetval = sal_False;
}
}
- void B2DPolyPolygon::flip()
+ return bRetval;
+ }
+
+ void B2DPolyPolygon::setClosed(sal_Bool bNew)
+ {
+ if(bNew != isClosed())
{
implForceUniqueCopy();
- mpPolyPolygon->flip();
+ mpPolyPolygon->setClosed(bNew);
}
+ }
- sal_Bool B2DPolyPolygon::hasDoublePoints() const
- {
- sal_Bool bRetval(sal_False);
-
- for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
- {
- if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
- {
- bRetval = sal_True;
- }
- }
+ void B2DPolyPolygon::flip()
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->flip();
+ }
- return bRetval;
- }
+ sal_Bool B2DPolyPolygon::hasDoublePoints() const
+ {
+ sal_Bool bRetval(sal_False);
- void B2DPolyPolygon::removeDoublePoints()
+ for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
{
- if(hasDoublePoints())
+ if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
{
- implForceUniqueCopy();
- mpPolyPolygon->removeDoublePoints();
+ bRetval = sal_True;
}
}
- void B2DPolyPolygon::transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ return bRetval;
+ }
+
+ void B2DPolyPolygon::removeDoublePoints()
+ {
+ if(hasDoublePoints())
{
implForceUniqueCopy();
- mpPolyPolygon->transform(rMatrix);
+ mpPolyPolygon->removeDoublePoints();
}
- } // end of namespace polygon
+ }
+
+ void B2DPolyPolygon::transform(const ::basegfx::B2DHomMatrix& rMatrix)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->transform(rMatrix);
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index a86bfce3d937..17d1c476acbf 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygoncutter.cxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:12 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -88,231 +88,228 @@
namespace basegfx
{
- namespace polygon
+ B2DPolygonNode::B2DPolygonNode(const ::basegfx::B2DPoint& rPosition, B2DPolygonNode* pPrevious)
+ : maPosition(rPosition)
{
- B2DPolygonNode::B2DPolygonNode(const ::basegfx::point::B2DPoint& rPosition, B2DPolygonNode* pPrevious)
- : maPosition(rPosition)
- {
- mpListPrevious = this;
- mpListNext = this;
+ mpListPrevious = this;
+ mpListNext = this;
- if(pPrevious)
- {
- mpNext = pPrevious->getNext();
- mpPrevious = pPrevious;
- mpNext->mpPrevious = this;
- mpPrevious->mpNext = this;
- }
- else
- {
- mpPrevious = mpNext = this;
- }
+ if(pPrevious)
+ {
+ mpNext = pPrevious->getNext();
+ mpPrevious = pPrevious;
+ mpNext->mpPrevious = this;
+ mpPrevious->mpNext = this;
}
-
- B2DPolygonNode::~B2DPolygonNode()
+ else
{
- if(mpNext != this)
- {
- mpPrevious->mpNext = mpNext;
- mpNext->mpPrevious = mpPrevious;
- }
+ mpPrevious = mpNext = this;
}
+ }
- void B2DPolygonNode::calcMinMaxX(double& fMaxAX, double& fMinAX) const
+ B2DPolygonNode::~B2DPolygonNode()
+ {
+ if(mpNext != this)
{
- if(maPosition.getX() > mpNext->maPosition.getX())
- {
- fMaxAX = maPosition.getX();
- fMinAX = mpNext->maPosition.getX();
- }
- else
- {
- fMaxAX = mpNext->maPosition.getX();
- fMinAX = maPosition.getX();
- }
+ mpPrevious->mpNext = mpNext;
+ mpNext->mpPrevious = mpPrevious;
}
+ }
- void B2DPolygonNode::calcMinMaxY(double& fMaxAY, double& fMinAY) const
+ void B2DPolygonNode::calcMinMaxX(double& fMaxAX, double& fMinAX) const
+ {
+ if(maPosition.getX() > mpNext->maPosition.getX())
{
- if(maPosition.getY() > mpNext->maPosition.getY())
- {
- fMaxAY = maPosition.getY();
- fMinAY = mpNext->maPosition.getY();
- }
- else
- {
- fMaxAY = mpNext->maPosition.getY();
- fMinAY = maPosition.getY();
- }
+ fMaxAX = maPosition.getX();
+ fMinAX = mpNext->maPosition.getX();
+ }
+ else
+ {
+ fMaxAX = mpNext->maPosition.getX();
+ fMinAX = maPosition.getX();
}
+ }
- void B2DPolygonNode::swapNextPointers(B2DPolygonNode* pCand)
+ void B2DPolygonNode::calcMinMaxY(double& fMaxAY, double& fMinAY) const
+ {
+ if(maPosition.getY() > mpNext->maPosition.getY())
{
- B2DPolygonNode* pTemporary = mpNext;
- mpNext = pCand->mpNext;
- pCand->mpNext = pTemporary;
- mpNext->mpPrevious = this;
- pCand->mpNext->mpPrevious = pCand;
+ fMaxAY = maPosition.getY();
+ fMinAY = mpNext->maPosition.getY();
+ }
+ else
+ {
+ fMaxAY = mpNext->maPosition.getY();
+ fMinAY = maPosition.getY();
}
+ }
- void B2DPolygonNode::addToList(B2DPolygonNode*& rpList)
+ void B2DPolygonNode::swapNextPointers(B2DPolygonNode* pCand)
+ {
+ B2DPolygonNode* pTemporary = mpNext;
+ mpNext = pCand->mpNext;
+ pCand->mpNext = pTemporary;
+ mpNext->mpPrevious = this;
+ pCand->mpNext->mpPrevious = pCand;
+ }
+
+ void B2DPolygonNode::addToList(B2DPolygonNode*& rpList)
+ {
+ if(rpList)
{
- if(rpList)
- {
- mpListNext = rpList->mpListNext;
- rpList->mpListNext = this;
- mpListPrevious = rpList;
- mpListNext->mpListPrevious = this;
- }
- else
- {
- rpList = this;
- }
+ mpListNext = rpList->mpListNext;
+ rpList->mpListNext = this;
+ mpListPrevious = rpList;
+ mpListNext->mpListPrevious = this;
+ }
+ else
+ {
+ rpList = this;
}
+ }
- void B2DPolygonNode::remFromList(B2DPolygonNode*& rpList)
+ void B2DPolygonNode::remFromList(B2DPolygonNode*& rpList)
+ {
+ if(mpListNext != this)
{
- if(mpListNext != this)
+ if(rpList == this)
{
- if(rpList == this)
- {
- rpList = mpListPrevious;
- }
-
- mpListPrevious->mpListNext = mpListNext;
- mpListNext->mpListPrevious = mpListPrevious;
- mpListNext = mpListPrevious = this;
+ rpList = mpListPrevious;
}
- else
+
+ mpListPrevious->mpListNext = mpListNext;
+ mpListNext->mpListPrevious = mpListPrevious;
+ mpListNext = mpListPrevious = this;
+ }
+ else
+ {
+ if(rpList == this)
{
- if(rpList == this)
- {
- rpList = 0L;
- }
+ rpList = 0L;
}
}
+ }
- sal_Bool B2DPolygonNode::getOrientation() const
- {
- const B2DPolygonNode* pOutmost = this;
- const B2DPolygonNode* pCurrent = this->getNext();
+ sal_Bool B2DPolygonNode::getOrientation() const
+ {
+ const B2DPolygonNode* pOutmost = this;
+ const B2DPolygonNode* pCurrent = this->getNext();
- while(pCurrent != this)
+ while(pCurrent != this)
+ {
+ if(::basegfx::fTools::more(pOutmost->getPosition().getX(), pCurrent->getPosition().getX()))
{
- if(::basegfx::numeric::fTools::more(pOutmost->getPosition().getX(), pCurrent->getPosition().getX()))
+ if(pCurrent->getPosition().getX() < pOutmost->getPosition().getX())
+ {
+ pOutmost = pCurrent;
+ }
+ else
{
- if(pCurrent->getPosition().getX() < pOutmost->getPosition().getX())
+ if(pCurrent->getPosition().getY() < pOutmost->getPosition().getY())
{
pOutmost = pCurrent;
}
- else
- {
- if(pCurrent->getPosition().getY() < pOutmost->getPosition().getY())
- {
- pOutmost = pCurrent;
- }
- }
}
-
- // next node
- pCurrent = pCurrent->getNext();
}
- ::basegfx::vector::B2DVector aVec1(pOutmost->getPrevious()->getPosition() - pOutmost->getPosition());
- ::basegfx::vector::B2DVector aVec2(pOutmost->getNext()->getPosition() - pOutmost->getPosition());
- return sal_Bool(::basegfx::numeric::fTools::more(aVec1.getX() * aVec2.getY(), aVec1.getY() * aVec2.getX()));
+ // next node
+ pCurrent = pCurrent->getNext();
}
- void B2DPolygonNode::swapOrientation()
- {
- B2DPolygonNode* pCurrent = this;
+ ::basegfx::B2DVector aVec1(pOutmost->getPrevious()->getPosition() - pOutmost->getPosition());
+ ::basegfx::B2DVector aVec2(pOutmost->getNext()->getPosition() - pOutmost->getPosition());
+ return sal_Bool(::basegfx::fTools::more(aVec1.getX() * aVec2.getY(), aVec1.getY() * aVec2.getX()));
+ }
- do {
- pCurrent->swapPreviousNext();
- pCurrent = pCurrent->getPrevious();
- } while(pCurrent != this);
- }
+ void B2DPolygonNode::swapOrientation()
+ {
+ B2DPolygonNode* pCurrent = this;
- ::basegfx::range::B2DRange B2DPolygonNode::getRange() const
- {
- ::basegfx::range::B2DRange aRetval;
- const B2DPolygonNode* pCurrent = this;
+ do {
+ pCurrent->swapPreviousNext();
+ pCurrent = pCurrent->getPrevious();
+ } while(pCurrent != this);
+ }
- do {
- aRetval.expand(pCurrent->getPosition());
- pCurrent = pCurrent->getPrevious();
- } while(pCurrent != this);
+ ::basegfx::B2DRange B2DPolygonNode::getRange() const
+ {
+ ::basegfx::B2DRange aRetval;
+ const B2DPolygonNode* pCurrent = this;
- return aRetval;
- }
+ do {
+ aRetval.expand(pCurrent->getPosition());
+ pCurrent = pCurrent->getPrevious();
+ } while(pCurrent != this);
- sal_Bool B2DPolygonNode::isInside(const ::basegfx::point::B2DPoint& rPoint, sal_Bool bWithBorder) const
+ return aRetval;
+ }
+
+ sal_Bool B2DPolygonNode::isInside(const ::basegfx::B2DPoint& rPoint, sal_Bool bWithBorder) const
+ {
+ sal_Bool bInside(sal_False);
+ const B2DPolygonNode* pCurrent = this;
+
+ do
{
- sal_Bool bInside(sal_False);
- const B2DPolygonNode* pCurrent = this;
+ if(bWithBorder && pCurrent->getPosition().equal(rPoint))
+ {
+ return sal_True;
+ }
+
+ B2DPolygonNode* pNext = pCurrent->getNext();
+ const sal_Bool bCompYA(::basegfx::fTools::more(pCurrent->getPosition().getY(), rPoint.getY()));
+ const sal_Bool bCompYB(::basegfx::fTools::more(pNext->getPosition().getY(), rPoint.getY()));
- do
+ if(bCompYA != bCompYB)
{
- if(bWithBorder && pCurrent->getPosition().equal(rPoint))
+ const sal_Bool bCompXA(::basegfx::fTools::more(pCurrent->getPosition().getX(), rPoint.getX()));
+ const sal_Bool bCompXB(::basegfx::fTools::more(pNext->getPosition().getX(), rPoint.getX()));
+
+ if(bCompXA == bCompXB)
{
- return sal_True;
+ if(bCompXA)
+ {
+ bInside = !bInside;
+ }
}
-
- B2DPolygonNode* pNext = pCurrent->getNext();
- const sal_Bool bCompYA(::basegfx::numeric::fTools::more(pCurrent->getPosition().getY(), rPoint.getY()));
- const sal_Bool bCompYB(::basegfx::numeric::fTools::more(pNext->getPosition().getY(), rPoint.getY()));
-
- if(bCompYA != bCompYB)
+ else
{
- const sal_Bool bCompXA(::basegfx::numeric::fTools::more(pCurrent->getPosition().getX(), rPoint.getX()));
- const sal_Bool bCompXB(::basegfx::numeric::fTools::more(pNext->getPosition().getX(), rPoint.getX()));
+ double fCmp =
+ pNext->getPosition().getX() - (pNext->getPosition().getY() - rPoint.getY()) *
+ (pCurrent->getPosition().getX() - pNext->getPosition().getX()) /
+ (pCurrent->getPosition().getY() - pNext->getPosition().getY());
- if(bCompXA == bCompXB)
+ if(bWithBorder && ::basegfx::fTools::more(fCmp, rPoint.getX()))
{
- if(bCompXA)
- {
- bInside = !bInside;
- }
+ bInside = !bInside;
}
- else
+ else if(::basegfx::fTools::moreOrEqual(fCmp, rPoint.getX()))
{
- double fCmp =
- pNext->getPosition().getX() - (pNext->getPosition().getY() - rPoint.getY()) *
- (pCurrent->getPosition().getX() - pNext->getPosition().getX()) /
- (pCurrent->getPosition().getY() - pNext->getPosition().getY());
-
- if(bWithBorder && ::basegfx::numeric::fTools::more(fCmp, rPoint.getX()))
- {
- bInside = !bInside;
- }
- else if(::basegfx::numeric::fTools::moreOrEqual(fCmp, rPoint.getX()))
- {
- bInside = !bInside;
- }
+ bInside = !bInside;
}
}
+ }
- // next edge
- pCurrent = pNext;
+ // next edge
+ pCurrent = pNext;
- } while(pCurrent != this);
+ } while(pCurrent != this);
- return bInside;
- }
+ return bInside;
+ }
- sal_Bool B2DPolygonNode::isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder) const
- {
- B2DPolygonNode* pTest = pPoly;
- sal_Bool bAllAInside(sal_True);
+ sal_Bool B2DPolygonNode::isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder) const
+ {
+ B2DPolygonNode* pTest = pPoly;
+ sal_Bool bAllAInside(sal_True);
- do {
- bAllAInside = isInside(pTest->getPosition(), bWithBorder);
- pTest = pTest->getNext();
- } while(bAllAInside && pTest != pPoly);
+ do {
+ bAllAInside = isInside(pTest->getPosition(), bWithBorder);
+ pTest = pTest->getNext();
+ } while(bAllAInside && pTest != pPoly);
- return bAllAInside;
- }
- } // end of namespace polygon
+ return bAllAInside;
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -320,26 +317,23 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ void B2DSimpleCut::solve()
{
- void B2DSimpleCut::solve()
- {
- mpLeft->swapNextPointers(mpRight);
+ mpLeft->swapNextPointers(mpRight);
- if(mbCorrectOrientation)
+ if(mbCorrectOrientation)
+ {
+ if(mpLeft->getOrientation() != mbOrientation)
{
- if(mpLeft->getOrientation() != mbOrientation)
- {
- mpLeft->swapOrientation();
- }
+ mpLeft->swapOrientation();
+ }
- if(mpRight->getOrientation() != mbOrientation)
- {
- mpRight->swapOrientation();
- }
+ if(mpRight->getOrientation() != mbOrientation)
+ {
+ mpRight->swapOrientation();
}
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -347,27 +341,24 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ void B2DClipExtraPolygonInfo::init(B2DPolygonNode* pNew)
{
- void B2DClipExtraPolygonInfo::init(B2DPolygonNode* pNew)
+ maRange = pNew->getRange();
+ mbOrientation = pNew->getOrientation();
+ mnDepth = (mbOrientation) ? 0L : -1L;
+ }
+
+ void B2DClipExtraPolygonInfo::changeDepth(sal_Bool bOrientation)
+ {
+ if(bOrientation)
{
- maRange = pNew->getRange();
- mbOrientation = pNew->getOrientation();
- mnDepth = (mbOrientation) ? 0L : -1L;
+ mnDepth++;
}
-
- void B2DClipExtraPolygonInfo::changeDepth(sal_Bool bOrientation)
+ else
{
- if(bOrientation)
- {
- mnDepth++;
- }
- else
- {
- mnDepth--;
- }
+ mnDepth--;
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -375,772 +366,769 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ B2DPolyPolygonCutter::~B2DPolyPolygonCutter()
{
- B2DPolyPolygonCutter::~B2DPolyPolygonCutter()
+ for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
{
- for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
- {
- delete maPolygonList[a];
- }
-
- maPolygonList.clear();
+ delete maPolygonList[a];
}
- void B2DPolyPolygonCutter::removeIncludedPolygons(sal_Bool bUseOr)
+ maPolygonList.clear();
+ }
+
+ void B2DPolyPolygonCutter::removeIncludedPolygons(sal_Bool bUseOr)
+ {
+ const sal_uInt32 aCount(maPolygonList.size());
+ B2DClipExtraPolygonInfo* pInfos = new B2DClipExtraPolygonInfo[aCount];
+ sal_uInt32 a, b;
+
+ // fill infos
+ for(a = 0L; a < aCount; a++)
{
- const sal_uInt32 aCount(maPolygonList.size());
- B2DClipExtraPolygonInfo* pInfos = new B2DClipExtraPolygonInfo[aCount];
- sal_uInt32 a, b;
+ pInfos[a].init(maPolygonList[a]);
+ }
- // fill infos
- for(a = 0L; a < aCount; a++)
- {
- pInfos[a].init(maPolygonList[a]);
- }
+ // get all includes
+ for(a = 0L; a < aCount; a++)
+ {
+ B2DClipExtraPolygonInfo& rInfoA = pInfos[a];
- // get all includes
- for(a = 0L; a < aCount; a++)
+ for(b = 0L; b < aCount; b++)
{
- B2DClipExtraPolygonInfo& rInfoA = pInfos[a];
+ B2DClipExtraPolygonInfo& rInfoB = pInfos[b];
- for(b = 0L; b < aCount; b++)
+ if(a != b && doRangesInclude(rInfoA.getRange(), rInfoB.getRange()))
{
- B2DClipExtraPolygonInfo& rInfoB = pInfos[b];
-
- if(a != b && doRangesInclude(rInfoA.getRange(), rInfoB.getRange()))
+ // volume B in A, test pA, pB for inclusion, with border
+ if(maPolygonList[a]->isPolygonInside(maPolygonList[b], sal_True))
{
- // volume B in A, test pA, pB for inclusion, with border
- if(maPolygonList[a]->isPolygonInside(maPolygonList[b], sal_True))
- {
- // pB is inside pA
- rInfoB.changeDepth(rInfoA.getOrientation());
- }
+ // pB is inside pA
+ rInfoB.changeDepth(rInfoA.getOrientation());
}
}
}
+ }
- // delete removable
- for(a = 0L, b = 0L; a < aCount; a++)
- {
- B2DClipExtraPolygonInfo& rInfo = pInfos[a];
+ // delete removable
+ for(a = 0L, b = 0L; a < aCount; a++)
+ {
+ B2DClipExtraPolygonInfo& rInfo = pInfos[a];
- if((bUseOr && rInfo.getDepth() != 0L) || (!bUseOr && rInfo.getDepth() < 1L))
- {
- B2DPolygonNodeVector::iterator aPosition(maPolygonList.begin() + b);
- B2DPolygonNode* pCandidate = *aPosition;
- maPolygonList.erase(aPosition);
- deletePolygon(pCandidate);
- }
- else
- {
- b++;
- }
+ if((bUseOr && rInfo.getDepth() != 0L) || (!bUseOr && rInfo.getDepth() < 1L))
+ {
+ B2DPolygonNodeVector::iterator aPosition(maPolygonList.begin() + b);
+ B2DPolygonNode* pCandidate = *aPosition;
+ maPolygonList.erase(aPosition);
+ deletePolygon(pCandidate);
+ }
+ else
+ {
+ b++;
}
-
- // delete infos
- delete[] pInfos;
}
- void B2DPolyPolygonCutter::solveAllCuts(B2DSimpleCutVector& rCuts)
- {
- B2DPolygonNode* pNewList = 0L;
-
- // add all nodes of polys to list
- polysToList(pNewList);
+ // delete infos
+ delete[] pInfos;
+ }
- // solve cuts
- B2DSimpleCutVector::iterator aCandidate(rCuts.begin());
+ void B2DPolyPolygonCutter::solveAllCuts(B2DSimpleCutVector& rCuts)
+ {
+ B2DPolygonNode* pNewList = 0L;
- for(; aCandidate < rCuts.end(); aCandidate++)
- {
- B2DSimpleCut* pCut = *aCandidate;
- pCut->solve();
- delete pCut;
- }
+ // add all nodes of polys to list
+ polysToList(pNewList);
- rCuts.clear();
+ // solve cuts
+ B2DSimpleCutVector::iterator aCandidate(rCuts.begin());
- // extract polys
- listToPolys(pNewList);
+ for(; aCandidate < rCuts.end(); aCandidate++)
+ {
+ B2DSimpleCut* pCut = *aCandidate;
+ pCut->solve();
+ delete pCut;
}
- void B2DPolyPolygonCutter::polysToList(B2DPolygonNode*& rpList)
- {
- B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
+ rCuts.clear();
- for(; aCandidate != maPolygonList.end(); aCandidate++)
- {
- addAllNodes(*aCandidate, rpList);
- }
+ // extract polys
+ listToPolys(pNewList);
+ }
- maPolygonList.clear();
- }
+ void B2DPolyPolygonCutter::polysToList(B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
- void B2DPolyPolygonCutter::listToPolys(B2DPolygonNode*& rpList)
+ for(; aCandidate != maPolygonList.end(); aCandidate++)
{
- while(rpList)
- {
- // get one
- B2DPolygonNode* pNew = extractNextPolygon(rpList);
-
- if(pNew)
- {
- maPolygonList.push_back(pNew);
- }
- }
+ addAllNodes(*aCandidate, rpList);
}
- B2DPolygonNode* B2DPolyPolygonCutter::createNewPolygon(const B2DPolygon& rPolygon)
+ maPolygonList.clear();
+ }
+
+ void B2DPolyPolygonCutter::listToPolys(B2DPolygonNode*& rpList)
+ {
+ while(rpList)
{
- B2DPolygonNode* pRetval = NULL;
+ // get one
+ B2DPolygonNode* pNew = extractNextPolygon(rpList);
- for(sal_uInt32 a(0L); a < rPolygon.count(); a++)
+ if(pNew)
{
- ::basegfx::point::B2DPoint aPoint(rPolygon.getB2DPoint(a));
- pRetval = new B2DPolygonNode(aPoint, pRetval);
+ maPolygonList.push_back(pNew);
}
-
- return pRetval;
}
+ }
+
+ B2DPolygonNode* B2DPolyPolygonCutter::createNewPolygon(const B2DPolygon& rPolygon)
+ {
+ B2DPolygonNode* pRetval = NULL;
- void B2DPolyPolygonCutter::deletePolygon(B2DPolygonNode* pCand)
+ for(sal_uInt32 a(0L); a < rPolygon.count(); a++)
{
- B2DPolygonNode* pPoly = pCand;
+ ::basegfx::B2DPoint aPoint(rPolygon.getB2DPoint(a));
+ pRetval = new B2DPolygonNode(aPoint, pRetval);
+ }
- while(pPoly)
- {
- B2DPolygonNode* pNext = pPoly->getNext();
+ return pRetval;
+ }
- if(pNext == pPoly)
- {
- pNext = 0L;
- }
+ void B2DPolyPolygonCutter::deletePolygon(B2DPolygonNode* pCand)
+ {
+ B2DPolygonNode* pPoly = pCand;
+
+ while(pPoly)
+ {
+ B2DPolygonNode* pNext = pPoly->getNext();
- delete pPoly;
- pPoly = pNext;
+ if(pNext == pPoly)
+ {
+ pNext = 0L;
}
+
+ delete pPoly;
+ pPoly = pNext;
}
+ }
- void B2DPolyPolygonCutter::addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList)
- {
- B2DPolygonNode* pAct = pPolygon;
+ void B2DPolyPolygonCutter::addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNode* pAct = pPolygon;
- do {
- pAct->addToList(rpList);
- pAct = pAct->getNext();
- } while(pAct != pPolygon);
- }
+ do {
+ pAct->addToList(rpList);
+ pAct = pAct->getNext();
+ } while(pAct != pPolygon);
+ }
- void B2DPolyPolygonCutter::addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation)
+ void B2DPolyPolygonCutter::addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation)
+ {
+ for(sal_uInt32 a(0L); a < rPolyPolygon.count(); a++)
{
- for(sal_uInt32 a(0L); a < rPolyPolygon.count(); a++)
- {
- B2DPolygon aCandidate = rPolyPolygon.getB2DPolygon(a);
- aCandidate.removeDoublePoints();
+ B2DPolygon aCandidate = rPolyPolygon.getB2DPolygon(a);
+ aCandidate.removeDoublePoints();
- if(!aCandidate.isClosed() || aCandidate.count() < 3)
- {
- maNotClosedPolygons.append(aCandidate);
- }
- else
+ if(!aCandidate.isClosed() || aCandidate.count() < 3)
+ {
+ maNotClosedPolygons.append(aCandidate);
+ }
+ else
+ {
+ if(bForceOrientation)
{
- if(bForceOrientation)
- {
- ::basegfx::vector::B2DVectorOrientation aOrientation =
- ::basegfx::polygon::tools::getOrientation(aCandidate);
+ ::basegfx::B2DVectorOrientation aOrientation =
+ ::basegfx::tools::getOrientation(aCandidate);
- if(::basegfx::vector::ORIENTATION_POSITIVE != aOrientation)
- {
- aCandidate.flip();
- }
+ if(::basegfx::ORIENTATION_POSITIVE != aOrientation)
+ {
+ aCandidate.flip();
}
-
- B2DPolygonNode* pNew = createNewPolygon(aCandidate);
- maPolygonList.push_back(pNew);
}
+
+ B2DPolygonNode* pNew = createNewPolygon(aCandidate);
+ maPolygonList.push_back(pNew);
}
}
+ }
+
+ void B2DPolyPolygonCutter::getPolyPolygon(B2DPolyPolygon& rPolyPolygon)
+ {
+ B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
- void B2DPolyPolygonCutter::getPolyPolygon(B2DPolyPolygon& rPolyPolygon)
+ for(; aCandidate < maPolygonList.end(); aCandidate++)
{
- B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
+ B2DPolygonNode* pCand = *aCandidate;
+ B2DPolygonNode* pAct = pCand;
+ sal_uInt32 nCount(0L);
+
+ do {
+ nCount++;
+ pAct = pAct->getNext();
+ } while(pAct != pCand);
- for(; aCandidate < maPolygonList.end(); aCandidate++)
+ if(nCount > 2L)
{
- B2DPolygonNode* pCand = *aCandidate;
- B2DPolygonNode* pAct = pCand;
- sal_uInt32 nCount(0L);
+ B2DPolygon aNewPolygon;
do {
- nCount++;
+ aNewPolygon.append(pAct->getPosition());
pAct = pAct->getNext();
} while(pAct != pCand);
- if(nCount > 2L)
- {
- B2DPolygon aNewPolygon;
+ aNewPolygon.setClosed(sal_True);
+ rPolyPolygon.append(aNewPolygon);
+ }
- do {
- aNewPolygon.append(pAct->getPosition());
- pAct = pAct->getNext();
- } while(pAct != pCand);
+ deletePolygon(pCand);
+ }
- aNewPolygon.setClosed(sal_True);
- rPolyPolygon.append(aNewPolygon);
- }
+ maPolygonList.clear();
- deletePolygon(pCand);
- }
+ while(maNotClosedPolygons.count())
+ {
+ rPolyPolygon.append(maNotClosedPolygons.getB2DPolygon(0L));
+ maNotClosedPolygons.remove(0L);
+ }
+ }
- maPolygonList.clear();
+ B2DSimpleCut* B2DPolyPolygonCutter::getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB)
+ {
+ for(sal_uInt32 a(0L); a < rTmpCuts.size(); a++)
+ {
+ B2DSimpleCut* pCand = rTmpCuts[a];
- while(maNotClosedPolygons.count())
+ if(pCand->isSameCut(pA, pB))
{
- rPolyPolygon.append(maNotClosedPolygons.getB2DPolygon(0L));
- maNotClosedPolygons.remove(0L);
+ return pCand;
}
}
- B2DSimpleCut* B2DPolyPolygonCutter::getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB)
- {
- for(sal_uInt32 a(0L); a < rTmpCuts.size(); a++)
- {
- B2DSimpleCut* pCand = rTmpCuts[a];
+ return 0L;
+ }
- if(pCand->isSameCut(pA, pB))
- {
- return pCand;
- }
- }
+ B2DPolygonNode* B2DPolyPolygonCutter::extractNextPolygon(B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNode* pStart = rpList;
+
+ // remove all nodes of this poly from list
+ B2DPolygonNode* pAct = pStart;
+ sal_uInt32 nNumNodes(0L);
+
+ do {
+ pAct->remFromList(rpList);
+ pAct = pAct->getNext();
+ nNumNodes++;
+ } while(pAct != pStart);
+ if(nNumNodes < 3L)
+ {
+ deletePolygon(pStart);
return 0L;
}
-
- B2DPolygonNode* B2DPolyPolygonCutter::extractNextPolygon(B2DPolygonNode*& rpList)
+ else
{
- B2DPolygonNode* pStart = rpList;
-
- // remove all nodes of this poly from list
- B2DPolygonNode* pAct = pStart;
- sal_uInt32 nNumNodes(0L);
-
- do {
- pAct->remFromList(rpList);
- pAct = pAct->getNext();
- nNumNodes++;
- } while(pAct != pStart);
-
- if(nNumNodes < 3L)
- {
- deletePolygon(pStart);
- return 0L;
- }
- else
- {
- return pStart;
- }
+ return pStart;
}
+ }
- void B2DPolyPolygonCutter::removeSelfIntersections()
+ void B2DPolyPolygonCutter::removeSelfIntersections()
+ {
+ B2DSimpleCutVector aCuts;
+ B2DSimpleCutVector aNewCuts;
+ B2DPolygonNode* pCand;
+ B2DPolygonNode* pA;
+ B2DPolygonNode* pB;
+ double fMaxAX, fMinAX, fMaxAY, fMinAY;
+ double fMaxBX, fMinBX, fMaxBY, fMinBY;
+ double fCut;
+
+ // first job: Find all cuts and add points there
+ for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
{
- B2DSimpleCutVector aCuts;
- B2DSimpleCutVector aNewCuts;
- B2DPolygonNode* pCand;
- B2DPolygonNode* pA;
- B2DPolygonNode* pB;
- double fMaxAX, fMinAX, fMaxAY, fMinAY;
- double fMaxBX, fMinBX, fMaxBY, fMinBY;
- double fCut;
-
- // first job: Find all cuts and add points there
- for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
- {
- pCand = maPolygonList[a];
- pA = pCand;
+ pCand = maPolygonList[a];
+ pA = pCand;
+
+ // one run to find same start positions (so there is no need to
+ // search for existing cuts in main loop)
+ do {
+ pB = pA->getNext();
- // one run to find same start positions (so there is no need to
- // search for existing cuts in main loop)
do {
- pB = pA->getNext();
+ if(isSamePos(pA->getPosition(), pB->getPosition()))
+ {
+ aNewCuts.push_back(new B2DSimpleCut(pA, pB, sal_True, pCand->getOrientation()));
+ }
- do {
- if(isSamePos(pA->getPosition(), pB->getPosition()))
- {
- aNewCuts.push_back(new B2DSimpleCut(pA, pB, sal_True, pCand->getOrientation()));
- }
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCand);
- // next B
- pB = pB->getNext();
- } while(pB != pCand);
+ // next A
+ pA = pA->getNext();
+ } while(pA->getNext() != pCand);
- // next A
- pA = pA->getNext();
- } while(pA->getNext() != pCand);
+ // second run to find real cuts
+ pA = pCand;
- // second run to find real cuts
- pA = pCand;
+ do {
+ // get bounds for this edge in poly
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ pB = pA->getNext();
do {
- // get bounds for this edge in poly
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- pB = pA->getNext();
+ pB->calcMinMaxX(fMaxBX, fMinBX);
- do {
- pB->calcMinMaxX(fMaxBX, fMinBX);
+ if(::basegfx::fTools::more(fMaxBX, fMinAX)
+ && ::basegfx::fTools::more(fMaxAX, fMinBX))
+ {
+ pB->calcMinMaxY(fMaxBY, fMinBY);
- if(::basegfx::numeric::fTools::more(fMaxBX, fMinAX)
- && ::basegfx::numeric::fTools::more(fMaxAX, fMinBX))
+ if(::basegfx::fTools::more(fMaxBY, fMinAY)
+ && ::basegfx::fTools::more(fMaxAY, fMinBY))
{
- pB->calcMinMaxY(fMaxBY, fMinBY);
-
- if(::basegfx::numeric::fTools::more(fMaxBY, fMinAY)
- && ::basegfx::numeric::fTools::more(fMaxAY, fMinBY))
+ if(!isSamePos(pA->getPosition(), pB->getPosition()))
{
- if(!isSamePos(pA->getPosition(), pB->getPosition()))
- {
- const ::basegfx::vector::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
- const ::basegfx::vector::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
+ const ::basegfx::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
+ const ::basegfx::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
- if(::basegfx::polygon::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ if(::basegfx::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ {
+ // crossover, two new points
+ ::basegfx::B2DPoint aNewPos(::basegfx::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi, sal_True, pCand->getOrientation()));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ }
+ else
+ {
+ if(::basegfx::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
{
- // crossover, two new points
- ::basegfx::point::B2DPoint aNewPos(::basegfx::tuple::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
- B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
- B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi, sal_True, pCand->getOrientation()));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
+ // startpoint A at edge B, one new point
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
+ aNewCuts.push_back(new B2DSimpleCut(pA, pCutHi, sal_True, pCand->getOrientation()));
}
- else
+ else if(::basegfx::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
{
- if(::basegfx::polygon::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
- {
- // startpoint A at edge B, one new point
- B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
- aNewCuts.push_back(new B2DSimpleCut(pA, pCutHi, sal_True, pCand->getOrientation()));
- }
- else if(::basegfx::polygon::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
- {
- // startpoint B at edge A, one new point
- B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pB, sal_True, pCand->getOrientation()));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- }
+ // startpoint B at edge A, one new point
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pB, sal_True, pCand->getOrientation()));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
}
}
}
}
+ }
- // next B
- pB = pB->getNext();
- } while(pB != pCand);
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCand);
- // next A
- pA = pA->getNext();
- } while(pA->getNext() != pCand);
+ // next A
+ pA = pA->getNext();
+ } while(pA->getNext() != pCand);
- // copy new cuts to cuts
- aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
- aNewCuts.clear();
- }
+ // copy new cuts to cuts
+ aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
+ aNewCuts.clear();
+ }
- // second job: if there were cuts, split polys
- if(aCuts.size())
- {
- solveAllCuts(aCuts);
- }
+ // second job: if there were cuts, split polys
+ if(aCuts.size())
+ {
+ solveAllCuts(aCuts);
}
+ }
- sal_Bool B2DPolyPolygonCutter::isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB)
+ sal_Bool B2DPolyPolygonCutter::isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB)
+ {
+ // build entering vectors
+ ::basegfx::B2DVector aVecA(pA->getPrevious()->getPosition() - pA->getPosition());
+ ::basegfx::B2DVector aVecB(pB->getPrevious()->getPosition() - pA->getPosition());
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX());
+ double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX());
+
+ // build leaving vectors
+ aVecA = pA->getNext()->getPosition() - pA->getPosition();
+ aVecB = pB->getNext()->getPosition() - pA->getPosition();
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX());
+ double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX());
+
+ // compare
+ if(fDegreeA1 > fDegreeA2)
{
- // build entering vectors
- ::basegfx::vector::B2DVector aVecA(pA->getPrevious()->getPosition() - pA->getPosition());
- ::basegfx::vector::B2DVector aVecB(pB->getPrevious()->getPosition() - pA->getPosition());
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX());
- double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX());
-
- // build leaving vectors
- aVecA = pA->getNext()->getPosition() - pA->getPosition();
- aVecB = pB->getNext()->getPosition() - pA->getPosition();
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX());
- double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX());
-
- // compare
- if(fDegreeA1 > fDegreeA2)
- {
- double fTemp = fDegreeA2;
- fDegreeA2 = fDegreeA1;
- fDegreeA1 = fTemp;
- }
+ double fTemp = fDegreeA2;
+ fDegreeA2 = fDegreeA1;
+ fDegreeA1 = fTemp;
+ }
- sal_Bool bB1Inside(::basegfx::numeric::fTools::more(fDegreeB1, fDegreeA1)
- && ::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB1));
- sal_Bool bB2Inside(::basegfx::numeric::fTools::more(fDegreeB2, fDegreeA1)
- && ::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB2));
+ sal_Bool bB1Inside(::basegfx::fTools::more(fDegreeB1, fDegreeA1)
+ && ::basegfx::fTools::more(fDegreeA2, fDegreeB1));
+ sal_Bool bB2Inside(::basegfx::fTools::more(fDegreeB2, fDegreeA1)
+ && ::basegfx::fTools::more(fDegreeA2, fDegreeB2));
- if(bB1Inside && bB2Inside)
- {
- return sal_False;
- }
+ if(bB1Inside && bB2Inside)
+ {
+ return sal_False;
+ }
+
+ sal_Bool bB1Outside(::basegfx::fTools::more(fDegreeA1, fDegreeB1)
+ || ::basegfx::fTools::more(fDegreeB1, fDegreeA2));
+ sal_Bool bB2Outside(::basegfx::fTools::more(fDegreeA1, fDegreeB2)
+ || ::basegfx::fTools::more(fDegreeB2, fDegreeA2));
- sal_Bool bB1Outside(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB1)
- || ::basegfx::numeric::fTools::more(fDegreeB1, fDegreeA2));
- sal_Bool bB2Outside(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB2)
- || ::basegfx::numeric::fTools::more(fDegreeB2, fDegreeA2));
+ return !(bB1Outside && bB2Outside);
+ }
- return !(bB1Outside && bB2Outside);
+ sal_Bool B2DPolyPolygonCutter::isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave)
+ {
+ // build entering vectors
+ ::basegfx::B2DVector aVecJ(pEnter->getLeft()->getNext()->getPosition() - pEnter->getLeft()->getPosition());
+ ::basegfx::B2DVector aVecA(pEnter->getLeft()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
+ ::basegfx::B2DVector aVecB(pEnter->getRight()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
+ aVecJ.normalize();
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
+ double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
+ double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
+
+ // move to range [0..2PI[
+ while(fDegreeA2 < 0.0)
+ {
+ fDegreeA2 += (2.0 * F_PI);
}
- sal_Bool B2DPolyPolygonCutter::isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave)
+ while(fDegreeA2 >= (2.0 * F_PI))
{
- // build entering vectors
- ::basegfx::vector::B2DVector aVecJ(pEnter->getLeft()->getNext()->getPosition() - pEnter->getLeft()->getPosition());
- ::basegfx::vector::B2DVector aVecA(pEnter->getLeft()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
- ::basegfx::vector::B2DVector aVecB(pEnter->getRight()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
- aVecJ.normalize();
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
- double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
- double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
-
- // move to range [0..2PI[
- while(fDegreeA2 < 0.0)
- {
- fDegreeA2 += (2.0 * F_PI);
- }
+ fDegreeA2 -= (2.0 * F_PI);
+ }
- while(fDegreeA2 >= (2.0 * F_PI))
- {
- fDegreeA2 -= (2.0 * F_PI);
- }
+ // move to range [0..2PI[
+ while(fDegreeB2 < 0.0)
+ {
+ fDegreeB2 += (2.0 * F_PI);
+ }
- // move to range [0..2PI[
- while(fDegreeB2 < 0.0)
- {
- fDegreeB2 += (2.0 * F_PI);
- }
+ while(fDegreeB2 >= (2.0 * F_PI))
+ {
+ fDegreeB2 -= (2.0 * F_PI);
+ }
- while(fDegreeB2 >= (2.0 * F_PI))
- {
- fDegreeB2 -= (2.0 * F_PI);
- }
+ sal_Bool bA2BiggerB2(::basegfx::fTools::more(fDegreeA2, fDegreeB2));
+
+ // build leaving vectors
+ aVecJ = pLeave->getLeft()->getPrevious()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecA = pLeave->getLeft()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecB = pLeave->getRight()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecJ.normalize();
+ aVecA.normalize();
+ aVecB.normalize();
+ fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
+ double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
+ double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
+
+ // move to range [0..2PI[
+ while(fDegreeA1 < 0.0)
+ {
+ fDegreeA1 += (2.0 * F_PI);
+ }
- sal_Bool bA2BiggerB2(::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB2));
-
- // build leaving vectors
- aVecJ = pLeave->getLeft()->getPrevious()->getPosition() - pLeave->getLeft()->getPosition();
- aVecA = pLeave->getLeft()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
- aVecB = pLeave->getRight()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
- aVecJ.normalize();
- aVecA.normalize();
- aVecB.normalize();
- fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
- double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
- double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
-
- // move to range [0..2PI[
- while(fDegreeA1 < 0.0)
- {
- fDegreeA1 += (2.0 * F_PI);
- }
+ while(fDegreeA1 >= (2.0 * F_PI))
+ {
+ fDegreeA1 -= (2.0 * F_PI);
+ }
- while(fDegreeA1 >= (2.0 * F_PI))
- {
- fDegreeA1 -= (2.0 * F_PI);
- }
+ // move to range [0..2PI[
+ while(fDegreeB1 < 0)
+ {
+ fDegreeB1 += (2.0 * F_PI);
+ }
- // move to range [0..2PI[
- while(fDegreeB1 < 0)
- {
- fDegreeB1 += (2.0 * F_PI);
- }
+ while(fDegreeB1 >= (2.0 * F_PI))
+ {
+ fDegreeB1 -= (2.0 * F_PI);
+ }
- while(fDegreeB1 >= (2.0 * F_PI))
- {
- fDegreeB1 -= (2.0 * F_PI);
- }
+ sal_Bool bA1BiggerB1(::basegfx::fTools::more(fDegreeA1, fDegreeB1));
- sal_Bool bA1BiggerB1(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB1));
+ // compare
+ return (bA1BiggerB1 == bA2BiggerB2);
+ }
- // compare
- return (bA1BiggerB1 == bA2BiggerB2);
+ void B2DPolyPolygonCutter::removeDoubleIntersections()
+ {
+ double fMaxAX, fMinAX, fMaxAY, fMinAY;
+ double fMaxBX, fMinBX, fMaxBY, fMinBY;
+ double fCut;
+ B2DSimpleCutVector aCuts;
+ B2DSimpleCutVector aTmpCuts;
+ B2DSimpleCutVector aNewCuts;
+ B2DPolygonNode* pCandA;
+ B2DPolygonNode* pCandB;
+ B2DPolygonNode* pA;
+ B2DPolygonNode* pB;
+ sal_uInt32 a;
+
+ // create volume list for all polys for faster compares
+ ::basegfx::B2DRange* pVolumes = new ::basegfx::B2DRange[maPolygonList.size()];
+
+ for(a = 0L; a < maPolygonList.size(); a++)
+ {
+ pVolumes[a] = maPolygonList[a]->getRange();
}
- void B2DPolyPolygonCutter::removeDoubleIntersections()
+ // register cuts (and add points for them) between pCandA and pCandB
+ for(a = 0L; a + 1L < maPolygonList.size(); a++)
{
- double fMaxAX, fMinAX, fMaxAY, fMinAY;
- double fMaxBX, fMinBX, fMaxBY, fMinBY;
- double fCut;
- B2DSimpleCutVector aCuts;
- B2DSimpleCutVector aTmpCuts;
- B2DSimpleCutVector aNewCuts;
- B2DPolygonNode* pCandA;
- B2DPolygonNode* pCandB;
- B2DPolygonNode* pA;
- B2DPolygonNode* pB;
- sal_uInt32 a;
-
- // create volume list for all polys for faster compares
- ::basegfx::range::B2DRange* pVolumes = new ::basegfx::range::B2DRange[maPolygonList.size()];
-
- for(a = 0L; a < maPolygonList.size(); a++)
- {
- pVolumes[a] = maPolygonList[a]->getRange();
- }
+ pCandA = maPolygonList[a];
- // register cuts (and add points for them) between pCandA and pCandB
- for(a = 0L; a + 1L < maPolygonList.size(); a++)
+ for(sal_uInt32 b = a + 1L; b < maPolygonList.size(); b++)
{
- pCandA = maPolygonList[a];
-
- for(sal_uInt32 b = a + 1L; b < maPolygonList.size(); b++)
+ if(doRangesIntersect(pVolumes[a], pVolumes[b]))
{
- if(doRangesIntersect(pVolumes[a], pVolumes[b]))
- {
- pCandB = maPolygonList[b];
- pA = pCandA;
+ pCandB = maPolygonList[b];
+ pA = pCandA;
+
+ // one run to find same start positions (so there is no need to
+ // search for existing cuts in main loop)
+ do {
+ pB = pCandB;
- // one run to find same start positions (so there is no need to
- // search for existing cuts in main loop)
do {
- pB = pCandB;
+ if(isSamePos(pA->getPosition(), pB->getPosition()))
+ {
+ aTmpCuts.push_back(new B2DSimpleCut(pA, pB));
+ }
- do {
- if(isSamePos(pA->getPosition(), pB->getPosition()))
- {
- aTmpCuts.push_back(new B2DSimpleCut(pA, pB));
- }
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCandB);
- // next B
- pB = pB->getNext();
- } while(pB != pCandB);
+ // next A
+ pA = pA->getNext();
+ } while(pA != pCandA);
- // next A
- pA = pA->getNext();
- } while(pA != pCandA);
+ // second run to find real cuts
+ pA = pCandA;
- // second run to find real cuts
- pA = pCandA;
+ do {
+ // get bounds for this edge in poly
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ pB = pCandB;
do {
- // get bounds for this edge in poly
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- pB = pCandB;
+ pB->calcMinMaxX(fMaxBX, fMinBX);
- do {
- pB->calcMinMaxX(fMaxBX, fMinBX);
+ if(::basegfx::fTools::more(fMaxBX, fMinAX)
+ && ::basegfx::fTools::more(fMaxAX, fMinBX))
+ {
+ pB->calcMinMaxY(fMaxBY, fMinBY);
- if(::basegfx::numeric::fTools::more(fMaxBX, fMinAX)
- && ::basegfx::numeric::fTools::more(fMaxAX, fMinBX))
+ if(::basegfx::fTools::more(fMaxBY, fMinAY)
+ && ::basegfx::fTools::more(fMaxAY, fMinBY))
{
- pB->calcMinMaxY(fMaxBY, fMinBY);
-
- if(::basegfx::numeric::fTools::more(fMaxBY, fMinAY)
- && ::basegfx::numeric::fTools::more(fMaxAY, fMinBY))
+ if(!isSamePos(pA->getPosition(), pB->getPosition()))
{
- if(!isSamePos(pA->getPosition(), pB->getPosition()))
- {
- const ::basegfx::vector::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
- const ::basegfx::vector::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
+ const ::basegfx::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
+ const ::basegfx::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
- if(::basegfx::polygon::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ if(::basegfx::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ {
+ // crossover, two new points, use as cutpoint
+ ::basegfx::B2DPoint aNewPos(::basegfx::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ }
+ else
+ {
+ if(::basegfx::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
{
- // crossover, two new points, use as cutpoint
- ::basegfx::point::B2DPoint aNewPos(::basegfx::tuple::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
- B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
- B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
+ // startpoint A at edge B, one new point
+ // leaves or enters common section
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
+ aTmpCuts.push_back(new B2DSimpleCut(pA, pCutHi));
}
- else
+ else if(::basegfx::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
{
- if(::basegfx::polygon::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
- {
- // startpoint A at edge B, one new point
- // leaves or enters common section
- B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
- aTmpCuts.push_back(new B2DSimpleCut(pA, pCutHi));
- }
- else if(::basegfx::polygon::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
- {
- // startpoint B at edge A, one new point
- // leaves or enters common section
- B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
- aTmpCuts.push_back(new B2DSimpleCut(pCutLo, pB));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- }
+ // startpoint B at edge A, one new point
+ // leaves or enters common section
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
+ aTmpCuts.push_back(new B2DSimpleCut(pCutLo, pB));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
}
}
}
}
+ }
- // next B
- pB = pB->getNext();
- } while(pB != pCandB);
-
- // next A
- pA = pA->getNext();
- } while(pA != pCandA);
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCandB);
- // test all temporary cuts for simple criteria
- for(sal_uInt32 c(0L); c < aTmpCuts.size();)
- {
- B2DSimpleCut* pCand = aTmpCuts[c];
- sal_Bool bPrevSamePos(isPrevSamePos(pCand->getLeft(), pCand->getRight()));
- sal_Bool bNextSamePos(isNextSamePos(pCand->getLeft(), pCand->getRight()));
- sal_Bool bDelete(sal_False);
- sal_Bool bIncC(sal_True);
+ // next A
+ pA = pA->getNext();
+ } while(pA != pCandA);
- if(bPrevSamePos && bNextSamePos)
- {
- // single point inside continued same direction section
- bDelete = sal_True;
- }
- else if(!bPrevSamePos && !bNextSamePos)
- {
- // this is no same direction section, test for real cut
- if(isCrossover(pCand->getLeft(), pCand->getRight()))
- {
- // real cut, move to real cutlist
- aNewCuts.push_back(pCand);
- aTmpCuts.erase(aTmpCuts.begin() + c);
- bIncC = sal_False;
- }
- else
- {
- // no cut, just a touch in one point
- bDelete = sal_True;
- }
- }
+ // test all temporary cuts for simple criteria
+ for(sal_uInt32 c(0L); c < aTmpCuts.size();)
+ {
+ B2DSimpleCut* pCand = aTmpCuts[c];
+ sal_Bool bPrevSamePos(isPrevSamePos(pCand->getLeft(), pCand->getRight()));
+ sal_Bool bNextSamePos(isNextSamePos(pCand->getLeft(), pCand->getRight()));
+ sal_Bool bDelete(sal_False);
+ sal_Bool bIncC(sal_True);
- // delete if wanted
- if(bDelete)
+ if(bPrevSamePos && bNextSamePos)
+ {
+ // single point inside continued same direction section
+ bDelete = sal_True;
+ }
+ else if(!bPrevSamePos && !bNextSamePos)
+ {
+ // this is no same direction section, test for real cut
+ if(isCrossover(pCand->getLeft(), pCand->getRight()))
{
- delete pCand;
+ // real cut, move to real cutlist
+ aNewCuts.push_back(pCand);
aTmpCuts.erase(aTmpCuts.begin() + c);
bIncC = sal_False;
}
+ else
+ {
+ // no cut, just a touch in one point
+ bDelete = sal_True;
+ }
+ }
- // next candidate
- if(bIncC)
- c++;
+ // delete if wanted
+ if(bDelete)
+ {
+ delete pCand;
+ aTmpCuts.erase(aTmpCuts.begin() + c);
+ bIncC = sal_False;
}
- // are there entering/leaving same direction sections?
- while(aTmpCuts.size())
+ // next candidate
+ if(bIncC)
+ c++;
+ }
+
+ // are there entering/leaving same direction sections?
+ while(aTmpCuts.size())
+ {
+ // this cuts enter/leave a common same-direction section between
+ // polygons pCandA, pCandB. If it is a real crossover, a cutpoint
+ // for it is needed, else it can be ignored.
+ B2DSimpleCut* pCutA = aTmpCuts[0L];
+ aTmpCuts.erase(aTmpCuts.begin());
+ B2DPolygonNode* pActA = pCutA->getLeft();
+ B2DPolygonNode* pActB = pCutA->getRight();
+ sal_Bool bPrevSamePos(isPrevSamePos(pActA, pActB));
+ sal_Bool bNextSamePos(isNextSamePos(pActA, pActB));
+
+ if(aTmpCuts.size())
{
- // this cuts enter/leave a common same-direction section between
- // polygons pCandA, pCandB. If it is a real crossover, a cutpoint
- // for it is needed, else it can be ignored.
- B2DSimpleCut* pCutA = aTmpCuts[0L];
- aTmpCuts.erase(aTmpCuts.begin());
- B2DPolygonNode* pActA = pCutA->getLeft();
- B2DPolygonNode* pActB = pCutA->getRight();
- sal_Bool bPrevSamePos(isPrevSamePos(pActA, pActB));
- sal_Bool bNextSamePos(isNextSamePos(pActA, pActB));
-
- if(aTmpCuts.size())
+ B2DSimpleCut* pCutB = 0L;
+
+ if(isNextSamePos(pCutA->getLeft(), pCutA->getRight()))
{
- B2DSimpleCut* pCutB = 0L;
+ // this is a start node
+ B2DPolygonNode* pActA = pCutA->getLeft()->getNext();
+ B2DPolygonNode* pActB = pCutA->getRight()->getNext();
- if(isNextSamePos(pCutA->getLeft(), pCutA->getRight()))
+ while(!pCutB && pActA != pCutA->getLeft())
{
- // this is a start node
- B2DPolygonNode* pActA = pCutA->getLeft()->getNext();
- B2DPolygonNode* pActB = pCutA->getRight()->getNext();
-
- while(!pCutB && pActA != pCutA->getLeft())
+ if(!isNextSamePos(pActA, pActB))
{
- if(!isNextSamePos(pActA, pActB))
- {
- pCutB = getExistingCut(aTmpCuts, pActA, pActB);
- }
-
- pActA = pActA->getNext();
- pActB = pActB->getNext();
+ pCutB = getExistingCut(aTmpCuts, pActA, pActB);
}
- if(pCutB)
+ pActA = pActA->getNext();
+ pActB = pActB->getNext();
+ }
+
+ if(pCutB)
+ {
+ const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
+ aTmpCuts.erase(aFindResult);
+
+ if(isCrossover(pCutA, pCutB))
+ {
+ aNewCuts.push_back(pCutB);
+ }
+ else
{
- const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
- aTmpCuts.erase(aFindResult);
+ delete pCutB;
+ }
+ }
+ }
+ else
+ {
+ // this is a end node
+ B2DPolygonNode* pActA = pCutA->getLeft()->getPrevious();
+ B2DPolygonNode* pActB = pCutA->getRight()->getPrevious();
- if(isCrossover(pCutA, pCutB))
- {
- aNewCuts.push_back(pCutB);
- }
- else
- {
- delete pCutB;
- }
+ while(!pCutB && pActA != pCutA->getLeft())
+ {
+ if(!isPrevSamePos(pActA, pActB))
+ {
+ pCutB = getExistingCut(aTmpCuts, pActA, pActB);
}
+
+ pActA = pActA->getPrevious();
+ pActB = pActB->getPrevious();
}
- else
+
+ if(pCutB)
{
- // this is a end node
- B2DPolygonNode* pActA = pCutA->getLeft()->getPrevious();
- B2DPolygonNode* pActB = pCutA->getRight()->getPrevious();
+ const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
+ aTmpCuts.erase(aFindResult);
- while(!pCutB && pActA != pCutA->getLeft())
+ if(isCrossover(pCutB, pCutA))
{
- if(!isPrevSamePos(pActA, pActB))
- {
- pCutB = getExistingCut(aTmpCuts, pActA, pActB);
- }
-
- pActA = pActA->getPrevious();
- pActB = pActB->getPrevious();
+ aNewCuts.push_back(pCutB);
}
-
- if(pCutB)
+ else
{
- const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
- aTmpCuts.erase(aFindResult);
-
- if(isCrossover(pCutB, pCutA))
- {
- aNewCuts.push_back(pCutB);
- }
- else
- {
- delete pCutB;
- }
+ delete pCutB;
}
}
}
-
- // delete cut in EVERY case
- delete pCutA;
}
- // copy new cuts to all cuts
- aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
- aNewCuts.clear();
+ // delete cut in EVERY case
+ delete pCutA;
}
+
+ // copy new cuts to all cuts
+ aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
+ aNewCuts.clear();
}
}
+ }
- // delete volume list again
- delete[] pVolumes;
+ // delete volume list again
+ delete[] pVolumes;
- // are there cuts to solve? Solve them all in one run
- if(aCuts.size())
- {
- solveAllCuts(aCuts);
- }
+ // are there cuts to solve? Solve them all in one run
+ if(aCuts.size())
+ {
+ solveAllCuts(aCuts);
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 3ddb6f11a0a3..60f61b347135 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygontools.cxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:12 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -87,153 +87,164 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B2DPolyPolygon tools
+
+ void correctOrientations(::basegfx::B2DPolyPolygon& rCandidate)
{
- // B2DPolyPolygon tools
+ const sal_uInt32 nPolygonCount(rCandidate.count());
+ sal_uInt32 nIndexOfOutmostPolygon(0L);
+ sal_Bool bIndexOfOutmostPolygonSet(sal_False);
- void correctOrientations(::basegfx::polygon::B2DPolyPolygon& rCandidate)
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(rCandidate.count());
- sal_uInt32 nIndexOfOutmostPolygon(0L);
- sal_Bool bIndexOfOutmostPolygonSet(sal_False);
+ ::basegfx::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
- for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+ if(aCandidate.count() > 2L)
{
- ::basegfx::polygon::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
-
- if(aCandidate.count() > 2L)
+ ::basegfx::B2DVectorOrientation aOrientation =
+ ::basegfx::tools::getOrientation(aCandidate);
+ sal_Bool bDoFlip(::basegfx::ORIENTATION_POSITIVE != aOrientation);
+
+ // init values for depth and compare point for
+ // inside test. Since the ordering makes only sense when assuming
+ // that there are no intersections, the inside test is done with
+ // any point of the candidate, so teke the first one.
+ sal_uInt32 nDepth(0L);
+ const ::basegfx::B2DPoint aTestPoint(aCandidate.getB2DPoint(0L));
+
+ // loop over other polygons and calculate depth
+ for(sal_uInt32 b(0L); b < nPolygonCount; b++)
{
- ::basegfx::vector::B2DVectorOrientation aOrientation =
- ::basegfx::polygon::tools::getOrientation(aCandidate);
- sal_Bool bDoFlip(::basegfx::vector::ORIENTATION_POSITIVE != aOrientation);
-
- // init values for depth and compare point for
- // inside test. Since the ordering makes only sense when assuming
- // that there are no intersections, the inside test is done with
- // any point of the candidate, so teke the first one.
- sal_uInt32 nDepth(0L);
- const ::basegfx::point::B2DPoint aTestPoint(aCandidate.getB2DPoint(0L));
-
- // loop over other polygons and calculate depth
- for(sal_uInt32 b(0L); b < nPolygonCount; b++)
+ if(b != a)
{
- if(b != a)
- {
- ::basegfx::polygon::B2DPolygon aComparePolygon = rCandidate.getB2DPolygon(b);
+ ::basegfx::B2DPolygon aComparePolygon = rCandidate.getB2DPolygon(b);
- if(::basegfx::polygon::tools::isInside(aComparePolygon, aTestPoint))
- {
- nDepth++;
- }
+ if(::basegfx::tools::isInside(aComparePolygon, aTestPoint))
+ {
+ nDepth++;
}
}
+ }
- // if nDepth is odd it is a hole
- sal_Bool bIsHole(1L == (nDepth & 0x00000001));
+ // if nDepth is odd it is a hole
+ sal_Bool bIsHole(1L == (nDepth & 0x00000001));
- // does polygon need to be flipped?
- if((bDoFlip && !bIsHole) || (!bDoFlip && bIsHole))
- {
- aCandidate.flip();
-
- // write back changed polygon
- rCandidate.setB2DPolygon(a, aCandidate);
- }
+ // does polygon need to be flipped?
+ if((bDoFlip && !bIsHole) || (!bDoFlip && bIsHole))
+ {
+ aCandidate.flip();
- // remember the index if it's the outmost polygon
- if(!bIndexOfOutmostPolygonSet && 0L == nDepth)
- {
- bIndexOfOutmostPolygonSet = sal_True;
- nIndexOfOutmostPolygon = a;
- }
+ // write back changed polygon
+ rCandidate.setB2DPolygon(a, aCandidate);
}
- }
- // if the outmost polygon is not the first, move it in front
- if(bIndexOfOutmostPolygonSet && nIndexOfOutmostPolygon > 0L)
- {
- ::basegfx::polygon::B2DPolygon aOutmostPolygon = rCandidate.getB2DPolygon(nIndexOfOutmostPolygon);
- rCandidate.remove(nIndexOfOutmostPolygon);
- rCandidate.insert(0L, aOutmostPolygon);
+ // remember the index if it's the outmost polygon
+ if(!bIndexOfOutmostPolygonSet && 0L == nDepth)
+ {
+ bIndexOfOutmostPolygonSet = sal_True;
+ nIndexOfOutmostPolygon = a;
+ }
}
}
- void removeIntersections(::basegfx::polygon::B2DPolyPolygon& rCandidate,
- sal_Bool bForceOrientation, sal_Bool bInvertRemove)
+ // if the outmost polygon is not the first, move it in front
+ if(bIndexOfOutmostPolygonSet && nIndexOfOutmostPolygon > 0L)
{
- ::basegfx::polygon::B2DPolyPolygonCutter aCutter;
-
- aCutter.addPolyPolygon(rCandidate, bForceOrientation);
- aCutter.removeSelfIntersections();
- aCutter.removeDoubleIntersections();
- aCutter.removeIncludedPolygons(!bInvertRemove);
- rCandidate.clear();
- aCutter.getPolyPolygon(rCandidate);
+ ::basegfx::B2DPolygon aOutmostPolygon = rCandidate.getB2DPolygon(nIndexOfOutmostPolygon);
+ rCandidate.remove(nIndexOfOutmostPolygon);
+ rCandidate.insert(0L, aOutmostPolygon);
}
+ }
+
+ void removeIntersections(::basegfx::B2DPolyPolygon& rCandidate,
+ sal_Bool bForceOrientation, sal_Bool bInvertRemove)
+ {
+ ::basegfx::B2DPolyPolygonCutter aCutter;
+
+ aCutter.addPolyPolygon(rCandidate, bForceOrientation);
+ aCutter.removeSelfIntersections();
+ aCutter.removeDoubleIntersections();
+ aCutter.removeIncludedPolygons(!bInvertRemove);
+ rCandidate.clear();
+ aCutter.getPolyPolygon(rCandidate);
+ }
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fDistanceBound)
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolyPolygon& rCandidate, double fDistanceBound)
+ {
+ ::basegfx::B2DPolyPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolyPolygon aRetval(rCandidate);
+ const sal_uInt32 nPolygonCount(aRetval.count());
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(aRetval.count());
+ ::basegfx::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
- for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
+ if(aCandidate.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
-
- if(aCandidate.areControlPointsUsed())
- {
- aCandidate = ::basegfx::polygon::tools::adaptiveSubdivideByDistance(aCandidate, fDistanceBound);
- aRetval.setB2DPolygon(a, aCandidate);
- }
+ aCandidate = ::basegfx::tools::adaptiveSubdivideByDistance(aCandidate, fDistanceBound);
+ aRetval.setB2DPolygon(a, aCandidate);
}
}
-
- return aRetval;
}
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fAngleBound)
+ return aRetval;
+ }
+
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolyPolygon& rCandidate, double fAngleBound)
+ {
+ ::basegfx::B2DPolyPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolyPolygon aRetval(rCandidate);
+ const sal_uInt32 nPolygonCount(aRetval.count());
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(aRetval.count());
+ ::basegfx::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
- for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
+ if(aCandidate.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
-
- if(aCandidate.areControlPointsUsed())
- {
- aCandidate = ::basegfx::polygon::tools::adaptiveSubdivideByAngle(aCandidate, fAngleBound);
- aRetval.setB2DPolygon(a, aCandidate);
- }
+ aCandidate = ::basegfx::tools::adaptiveSubdivideByAngle(aCandidate, fAngleBound);
+ aRetval.setB2DPolygon(a, aCandidate);
}
}
-
- return aRetval;
}
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolyPolygon& rCandidate)
+ return aRetval;
+ }