xref: /trunk/main/basegfx/inc/basegfx/range/b2drange.hxx (revision 914d351e5f5b84e4342a86d6ab8d4aca7308b9bd) 
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 #include <basegfx/basegfxdllapi.h>
33 
34 
35 namespace basegfx
36 {
37     // predeclarations
38     class B2IRange;
39     class B2DHomMatrix;
40 
41     class B2DRange
42     {
43     public:
44         typedef double          ValueType;
45         typedef DoubleTraits    TraitsType;
46 
B2DRange()47         B2DRange()
48         {
49         }
50 
B2DRange(const B2DTuple & rTuple)51         explicit B2DRange(const B2DTuple& rTuple)
52         :   maRangeX(rTuple.getX()),
53             maRangeY(rTuple.getY())
54         {
55         }
56 
B2DRange(double x1,double y1,double x2,double y2)57         B2DRange(double x1,
58                  double y1,
59                  double x2,
60                  double y2)
61         :   maRangeX(x1),
62             maRangeY(y1)
63         {
64             maRangeX.expand(x2);
65             maRangeY.expand(y2);
66         }
67 
B2DRange(const B2DTuple & rTuple1,const B2DTuple & rTuple2)68         B2DRange(const B2DTuple& rTuple1,
69                  const B2DTuple& rTuple2)
70         :   maRangeX(rTuple1.getX()),
71             maRangeY(rTuple1.getY())
72         {
73             expand( rTuple2 );
74         }
75 
B2DRange(const B2DRange & rRange)76         B2DRange(const B2DRange& rRange)
77         :   maRangeX(rRange.maRangeX),
78             maRangeY(rRange.maRangeY)
79         {
80         }
81 
82         BASEGFX_DLLPUBLIC explicit B2DRange(const B2IRange& rRange);
83 
isEmpty() const84         bool isEmpty() const
85         {
86             return (
87                 maRangeX.isEmpty()
88                 || maRangeY.isEmpty()
89                 );
90         }
91 
reset()92         void reset()
93         {
94             maRangeX.reset();
95             maRangeY.reset();
96         }
97 
operator ==(const B2DRange & rRange) const98         bool operator==( const B2DRange& rRange ) const
99         {
100             return (maRangeX == rRange.maRangeX
101                 && maRangeY == rRange.maRangeY);
102         }
103 
operator !=(const B2DRange & rRange) const104         bool operator!=( const B2DRange& rRange ) const
105         {
106             return (maRangeX != rRange.maRangeX
107                 || maRangeY != rRange.maRangeY);
108         }
109 
operator =(const B2DRange & rRange)110         B2DRange& operator=(const B2DRange& rRange)
111         {
112             maRangeX = rRange.maRangeX;
113             maRangeY = rRange.maRangeY;
114             return *this;
115         }
116 
equal(const B2DRange & rRange) const117         bool equal(const B2DRange& rRange) const
118         {
119             return (maRangeX.equal(rRange.maRangeX)
120                     && maRangeY.equal(rRange.maRangeY));
121         }
122 
getMinX() const123         double getMinX() const
124         {
125             return maRangeX.getMinimum();
126         }
127 
getMinY() const128         double getMinY() const
129         {
130             return maRangeY.getMinimum();
131         }
132 
getMaxX() const133         double getMaxX() const
134         {
135             return maRangeX.getMaximum();
136         }
137 
getMaxY() const138         double getMaxY() const
139         {
140             return maRangeY.getMaximum();
141         }
142 
getWidth() const143         double getWidth() const
144         {
145             return maRangeX.getRange();
146         }
147 
getHeight() const148         double getHeight() const
149         {
150             return maRangeY.getRange();
151         }
152 
getMinimum() const153         B2DPoint getMinimum() const
154         {
155             return B2DPoint(
156                 maRangeX.getMinimum(),
157                 maRangeY.getMinimum()
158                 );
159         }
160 
getMaximum() const161         B2DPoint getMaximum() const
162         {
163             return B2DPoint(
164                 maRangeX.getMaximum(),
165                 maRangeY.getMaximum()
166                 );
167         }
168 
getRange() const169         B2DVector getRange() const
170         {
171             return B2DVector(
172                 maRangeX.getRange(),
173                 maRangeY.getRange()
174                 );
175         }
176 
getCenter() const177         B2DPoint getCenter() const
178         {
179             return B2DPoint(
180                 maRangeX.getCenter(),
181                 maRangeY.getCenter()
182                 );
183         }
184 
getCenterX() const185         double getCenterX() const
186         {
187             return maRangeX.getCenter();
188         }
189 
getCenterY() const190         double getCenterY() const
191         {
192             return maRangeY.getCenter();
193         }
194 
isInside(const B2DTuple & rTuple) const195         bool isInside(const B2DTuple& rTuple) const
196         {
197             return (
198                 maRangeX.isInside(rTuple.getX())
199                 && maRangeY.isInside(rTuple.getY())
200                 );
201         }
202 
isInside(const B2DRange & rRange) const203         bool isInside(const B2DRange& rRange) const
204         {
205             return (
206                 maRangeX.isInside(rRange.maRangeX)
207                 && maRangeY.isInside(rRange.maRangeY)
208                 );
209         }
210 
overlaps(const B2DRange & rRange) const211         bool overlaps(const B2DRange& rRange) const
212         {
213             return (
214                 maRangeX.overlaps(rRange.maRangeX)
215                 && maRangeY.overlaps(rRange.maRangeY)
216                 );
217         }
218 
overlapsMore(const B2DRange & rRange) const219         bool overlapsMore(const B2DRange& rRange) const
220         {
221             return (
222                 maRangeX.overlapsMore(rRange.maRangeX)
223                 && maRangeY.overlapsMore(rRange.maRangeY)
224                 );
225         }
226 
expand(const B2DTuple & rTuple)227         void expand(const B2DTuple& rTuple)
228         {
229             maRangeX.expand(rTuple.getX());
230             maRangeY.expand(rTuple.getY());
231         }
232 
expand(const B2DRange & rRange)233         void expand(const B2DRange& rRange)
234         {
235             maRangeX.expand(rRange.maRangeX);
236             maRangeY.expand(rRange.maRangeY);
237         }
238 
intersect(const B2DRange & rRange)239         void intersect(const B2DRange& rRange)
240         {
241             maRangeX.intersect(rRange.maRangeX);
242             maRangeY.intersect(rRange.maRangeY);
243         }
244 
grow(double fValue)245         void grow(double fValue)
246         {
247             maRangeX.grow(fValue);
248             maRangeY.grow(fValue);
249         }
250 
251         BASEGFX_DLLPUBLIC void transform(const B2DHomMatrix& rMatrix);
252 
253     private:
254         typedef ::basegfx::BasicRange< ValueType, TraitsType >  MyBasicRange;
255 
256         MyBasicRange        maRangeX;
257         MyBasicRange        maRangeY;
258     };
259 
260     /** Round double to nearest integer for 2D range
261 
262         @return the nearest integer for this range
263     */
264     BASEGFX_DLLPUBLIC B2IRange fround(const B2DRange& rRange);
265 
266     /** Compute the set difference of the two given ranges
267 
268         This method calculates the symmetric difference (aka XOR)
269         between the two given ranges, and returning the resulting
270         ranges. Thus, the result will contain all areas where one, but
271         not both ranges lie.
272 
273         @param o_rResult
274         Result vector. The up to four difference ranges are returned
275         within this vector
276 
277         @param rFirst
278         The first range
279 
280         @param rSecond
281         The second range
282 
283         @return the input vector
284      */
285     BASEGFX_DLLPUBLIC ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >&   o_rResult,
286                                                      const B2DRange&            rFirst,
287                                                      const B2DRange&            rSecond );
288 
289 } // end of namespace basegfx
290 
291 
292 #endif /* _BGFX_RANGE_B2DRANGE_HXX */
293