b2dhompoint.cxx (09dbbe93) b2dhompoint.cxx (7024eca9)
1/**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance

--- 15 unchanged lines hidden (view full) ---

24// MARKER(update_precomp.py): autogen include statement, do not remove
25#include "precompiled_basegfx.hxx"
26#include <basegfx/point/b2dhompoint.hxx>
27#include <basegfx/matrix/b2dhommatrix.hxx>
28#include <basegfx/numeric/ftools.hxx>
29
30namespace basegfx
31{
1/**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance

--- 15 unchanged lines hidden (view full) ---

24// MARKER(update_precomp.py): autogen include statement, do not remove
25#include "precompiled_basegfx.hxx"
26#include <basegfx/point/b2dhompoint.hxx>
27#include <basegfx/matrix/b2dhommatrix.hxx>
28#include <basegfx/numeric/ftools.hxx>
29
30namespace basegfx
31{
32 bool B2DHomPoint::implIsHomogenized() const
33 {
34 const double fOne(1.0);
35 return ::basegfx::fTools::equal(fOne, mfW);
36 }
37
38 void B2DHomPoint::implHomogenize()
39 {
40 const double fFactor(1.0 / mfW);
41 maTuple.setX(maTuple.getX() * fFactor);
42 maTuple.setY(maTuple.getY() * fFactor);
43 mfW = 1.0;
44 }
45
32 void B2DHomPoint::implHomogenize()
33 {
34 const double fFactor(1.0 / mfW);
35 maTuple.setX(maTuple.getX() * fFactor);
36 maTuple.setY(maTuple.getY() * fFactor);
37 mfW = 1.0;
38 }
39
46 void B2DHomPoint::implTestAndHomogenize() const
47 {
48 if(!implIsHomogenized())
49 ((B2DHomPoint*)this)->implHomogenize();
50 }
51
52 B2DPoint B2DHomPoint::getB2DPoint() const
53 {
54 implTestAndHomogenize();
55 return B2DPoint(maTuple.getX(), maTuple.getY());
56 }
57
58 double B2DHomPoint::getX() const
59 {
60 implTestAndHomogenize();
61 return maTuple.getX();
62 }
63
64 double B2DHomPoint::getY() const
65 {
66 implTestAndHomogenize();
67 return maTuple.getY();
68 }
69
70 void B2DHomPoint::setX(double fX)
71 {
72 maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
73 }
74
75 void B2DHomPoint::setY(double fY)
76 {
77 maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
78 }
79
80 B2DHomPoint& B2DHomPoint::operator+=( const B2DHomPoint& rPnt )
81 {
82 maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
83 maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
84 mfW = mfW * rPnt.mfW;
85
86 return *this;
87 }
88
89 B2DHomPoint& B2DHomPoint::operator-=( const B2DHomPoint& rPnt )
90 {
91 maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
92 maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
93 mfW = mfW * rPnt.mfW;
94
95 return *this;
96 }
97
98 B2DHomPoint& B2DHomPoint::operator*=(double t)
99 {
100 if(!::basegfx::fTools::equalZero(t))
101 {
102 mfW /= t;
103 }
104
105 return *this;
106 }
107
108 B2DHomPoint& B2DHomPoint::operator*=( const B2DHomMatrix& rMat )
109 {
110 const double fTempX( rMat.get(0,0)*maTuple.getX() +
111 rMat.get(0,1)*maTuple.getY() +
112 rMat.get(0,2)*mfW );
113
114 const double fTempY( rMat.get(1,0)*maTuple.getX() +
115 rMat.get(1,1)*maTuple.getY() +
116 rMat.get(1,2)*mfW );
117
118 const double fTempZ( rMat.get(2,0)*maTuple.getX() +
119 rMat.get(2,1)*maTuple.getY() +
120 rMat.get(2,2)*mfW );
121 maTuple.setX( fTempX );
122 maTuple.setY( fTempY );
123 mfW = fTempZ;
124
125 return *this;
126 }
40 B2DHomPoint& B2DHomPoint::operator*=( const B2DHomMatrix& rMat )
41 {
42 const double fTempX( rMat.get(0,0)*maTuple.getX() +
43 rMat.get(0,1)*maTuple.getY() +
44 rMat.get(0,2)*mfW );
45
46 const double fTempY( rMat.get(1,0)*maTuple.getX() +
47 rMat.get(1,1)*maTuple.getY() +
48 rMat.get(1,2)*mfW );
49
50 const double fTempZ( rMat.get(2,0)*maTuple.getX() +
51 rMat.get(2,1)*maTuple.getY() +
52 rMat.get(2,2)*mfW );
53 maTuple.setX( fTempX );
54 maTuple.setY( fTempY );
55 mfW = fTempZ;
56
57 return *this;
58 }
127
128 B2DHomPoint& B2DHomPoint::operator/=(double t)
129 {
130 mfW *= t;
131 return *this;
132 }
133
134 B2DHomPoint& B2DHomPoint::operator-(void)
135 {
136 mfW = -mfW;
137 return *this;
138 }
139
140 bool B2DHomPoint::operator==( const B2DHomPoint& rPnt ) const
141 {
142 implTestAndHomogenize();
143 return (maTuple == rPnt.maTuple);
144 }
145
146 bool B2DHomPoint::operator!=( const B2DHomPoint& rPnt ) const
147 {
148 implTestAndHomogenize();
149 return (maTuple != rPnt.maTuple);
150 }
151
152 B2DHomPoint& B2DHomPoint::operator=( const B2DHomPoint& rPnt )
153 {
154 maTuple = rPnt.maTuple;
155 mfW = rPnt.mfW;
156 return *this;
157 }
158
159 B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
160 {
161 B2DHomPoint aMin(
162 (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
163 (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY());
164 return aMin;
165 }
166
167 B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
168 {
169 B2DHomPoint aMax(
170 (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
171 (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY());
172 return aMax;
173 }
174 B2DHomPoint absolute(const B2DHomPoint& rVec)
175 {
176 B2DHomPoint aAbs(
177 (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
178 (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY());
179 return aAbs;
180 }
181
182 B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t)
183 {
184 B2DHomPoint aInt(
185 ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
186 ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
187 return aInt;
188 }
189
190 B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2)
191 {
192 B2DHomPoint aAvg(
193 (rOld1.getX() + rOld2.getX()) * 0.5,
194 (rOld1.getY() + rOld2.getY()) * 0.5);
195 return aAvg;
196 }
197
198 B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3)
199 {
200 B2DHomPoint aAvg(
201 (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
202 (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
203 return aAvg;
204 }
205
206 B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
207 {
208 B2DHomPoint aSum(rVecA);
209 aSum += rVecB;
210 return aSum;
211 }
212
213 B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
214 {
215 B2DHomPoint aSub(rVecA);
216 aSub -= rVecB;
217 return aSub;
218 }
219
220 B2DHomPoint operator*(const B2DHomPoint& rVec, double t)
221 {
222 B2DHomPoint aNew(rVec);
223 aNew *= t;
224 return aNew;
225 }
226
227 B2DHomPoint operator*(double t, const B2DHomPoint& rVec)
228 {
229 B2DHomPoint aNew(rVec);
230 aNew *= t;
231 return aNew;
232 }
233
234 B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint )
235 {
236 B2DHomPoint aNew(rPoint);
237 return aNew*=rMat;
238 }
239
240 B2DHomPoint operator/(const B2DHomPoint& rVec, double t)
241 {
242 B2DHomPoint aNew(rVec);
243 aNew /= t;
244 return aNew;
245 }
246
247 B2DHomPoint operator/(double t, const B2DHomPoint& rVec)
248 {
249 B2DHomPoint aNew(rVec);
250 aNew /= t;
251 return aNew;
252 }
253} // end of namespace basegfx
254
255// eof
59} // end of namespace basegfx
60
61// eof