xref: /AOO41X/main/basegfx/inc/basegfx/range/b2drange.hxx (revision ce9c7ef7bd056b6da7d6eeebb749fbf2160d647b) 
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
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #ifndef _BGFX_RANGE_B2DRANGE_HXX
25 #define _BGFX_RANGE_B2DRANGE_HXX
26 
27 #include <basegfx/vector/b2dvector.hxx>
28 #include <basegfx/point/b2dpoint.hxx>
29 #include <basegfx/tuple/b2dtuple.hxx>
30 #include <basegfx/range/basicrange.hxx>
31 #include <vector>
32 
33 
34 namespace basegfx
35 {
36     // predeclarations
37     class B2IRange;
38     class B2DHomMatrix;
39 
40     class B2DRange
41     {
42     public:
43         typedef double          ValueType;
44         typedef DoubleTraits    TraitsType;
45 
B2DRange()46         B2DRange()
47         {
48         }
49 
B2DRange(const B2DTuple & rTuple)50         explicit B2DRange(const B2DTuple& rTuple)
51         :   maRangeX(rTuple.getX()),
52             maRangeY(rTuple.getY())
53         {
54         }
55 
B2DRange(double x1,double y1,double x2,double y2)56         B2DRange(double x1,
57                  double y1,
58                  double x2,
59                  double y2)
60         :   maRangeX(x1),
61             maRangeY(y1)
62         {
63             maRangeX.expand(x2);
64             maRangeY.expand(y2);
65         }
66 
B2DRange(const B2DTuple & rTuple1,const B2DTuple & rTuple2)67         B2DRange(const B2DTuple& rTuple1,
68                  const B2DTuple& rTuple2)
69         :   maRangeX(rTuple1.getX()),
70             maRangeY(rTuple1.getY())
71         {
72             expand( rTuple2 );
73         }
74 
B2DRange(const B2DRange & rRange)75         B2DRange(const B2DRange& rRange)
76         :   maRangeX(rRange.maRangeX),
77             maRangeY(rRange.maRangeY)
78         {
79         }
80 
81         explicit B2DRange(const B2IRange& rRange);
82 
isEmpty() const83         bool isEmpty() const
84         {
85             return (
86                 maRangeX.isEmpty()
87                 || maRangeY.isEmpty()
88                 );
89         }
90 
reset()91         void reset()
92         {
93             maRangeX.reset();
94             maRangeY.reset();
95         }
96 
operator ==(const B2DRange & rRange) const97         bool operator==( const B2DRange& rRange ) const
98         {
99             return (maRangeX == rRange.maRangeX
100                 && maRangeY == rRange.maRangeY);
101         }
102 
operator !=(const B2DRange & rRange) const103         bool operator!=( const B2DRange& rRange ) const
104         {
105             return (maRangeX != rRange.maRangeX
106                 || maRangeY != rRange.maRangeY);
107         }
108 
operator =(const B2DRange & rRange)109         B2DRange& operator=(const B2DRange& rRange)
110         {
111             maRangeX = rRange.maRangeX;
112             maRangeY = rRange.maRangeY;
113             return *this;
114         }
115 
equal(const B2DRange & rRange) const116         bool equal(const B2DRange& rRange) const
117         {
118             return (maRangeX.equal(rRange.maRangeX)
119                     && maRangeY.equal(rRange.maRangeY));
120         }
121 
getMinX() const122         double getMinX() const
123         {
124             return maRangeX.getMinimum();
125         }
126 
getMinY() const127         double getMinY() const
128         {
129             return maRangeY.getMinimum();
130         }
131 
getMaxX() const132         double getMaxX() const
133         {
134             return maRangeX.getMaximum();
135         }
136 
getMaxY() const137         double getMaxY() const
138         {
139             return maRangeY.getMaximum();
140         }
141 
getWidth() const142         double getWidth() const
143         {
144             return maRangeX.getRange();
145         }
146 
getHeight() const147         double getHeight() const
148         {
149             return maRangeY.getRange();
150         }
151 
getMinimum() const152         B2DPoint getMinimum() const
153         {
154             return B2DPoint(
155                 maRangeX.getMinimum(),
156                 maRangeY.getMinimum()
157                 );
158         }
159 
getMaximum() const160         B2DPoint getMaximum() const
161         {
162             return B2DPoint(
163                 maRangeX.getMaximum(),
164                 maRangeY.getMaximum()
165                 );
166         }
167 
getRange() const168         B2DVector getRange() const
169         {
170             return B2DVector(
171                 maRangeX.getRange(),
172                 maRangeY.getRange()
173                 );
174         }
175 
getCenter() const176         B2DPoint getCenter() const
177         {
178             return B2DPoint(
179                 maRangeX.getCenter(),
180                 maRangeY.getCenter()
181                 );
182         }
183 
getCenterX() const184         double getCenterX() const
185         {
186             return maRangeX.getCenter();
187         }
188 
getCenterY() const189         double getCenterY() const
190         {
191             return maRangeY.getCenter();
192         }
193 
isInside(const B2DTuple & rTuple) const194         bool isInside(const B2DTuple& rTuple) const
195         {
196             return (
197                 maRangeX.isInside(rTuple.getX())
198                 && maRangeY.isInside(rTuple.getY())
199                 );
200         }
201 
isInside(const B2DRange & rRange) const202         bool isInside(const B2DRange& rRange) const
203         {
204             return (
205                 maRangeX.isInside(rRange.maRangeX)
206                 && maRangeY.isInside(rRange.maRangeY)
207                 );
208         }
209 
overlaps(const B2DRange & rRange) const210         bool overlaps(const B2DRange& rRange) const
211         {
212             return (
213                 maRangeX.overlaps(rRange.maRangeX)
214                 && maRangeY.overlaps(rRange.maRangeY)
215                 );
216         }
217 
overlapsMore(const B2DRange & rRange) const218         bool overlapsMore(const B2DRange& rRange) const
219         {
220             return (
221                 maRangeX.overlapsMore(rRange.maRangeX)
222                 && maRangeY.overlapsMore(rRange.maRangeY)
223                 );
224         }
225 
expand(const B2DTuple & rTuple)226         void expand(const B2DTuple& rTuple)
227         {
228             maRangeX.expand(rTuple.getX());
229             maRangeY.expand(rTuple.getY());
230         }
231 
expand(const B2DRange & rRange)232         void expand(const B2DRange& rRange)
233         {
234             maRangeX.expand(rRange.maRangeX);
235             maRangeY.expand(rRange.maRangeY);
236         }
237 
intersect(const B2DRange & rRange)238         void intersect(const B2DRange& rRange)
239         {
240             maRangeX.intersect(rRange.maRangeX);
241             maRangeY.intersect(rRange.maRangeY);
242         }
243 
grow(double fValue)244         void grow(double fValue)
245         {
246             maRangeX.grow(fValue);
247             maRangeY.grow(fValue);
248         }
249 
250         void transform(const B2DHomMatrix& rMatrix);
251 
252     private:
253         typedef ::basegfx::BasicRange< ValueType, TraitsType >  MyBasicRange;
254 
255         MyBasicRange        maRangeX;
256         MyBasicRange        maRangeY;
257     };
258 
259     /** Round double to nearest integer for 2D range
260 
261         @return the nearest integer for this range
262     */
263     B2IRange fround(const B2DRange& rRange);
264 
265     /** Compute the set difference of the two given ranges
266 
267         This method calculates the symmetric difference (aka XOR)
268         between the two given ranges, and returning the resulting
269         ranges. Thus, the result will contain all areas where one, but
270         not both ranges lie.
271 
272         @param o_rResult
273         Result vector. The up to four difference ranges are returned
274         within this vector
275 
276         @param rFirst
277         The first range
278 
279         @param rSecond
280         The second range
281 
282         @return the input vector
283      */
284     ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult,
285                                                      const B2DRange&            rFirst,
286                                                      const B2DRange&            rSecond );
287 
288 } // end of namespace basegfx
289 
290 
291 #endif /* _BGFX_RANGE_B2DRANGE_HXX */
292