-
-
Notifications
You must be signed in to change notification settings - Fork 3k
/
qgsrectangle.h
205 lines (177 loc) · 6.37 KB
/
qgsrectangle.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/***************************************************************************
qgsrectangle.h - description
-------------------
begin : Sat Jun 22 2002
copyright : (C) 2002 by Gary E.Sherman
email : sherman at mrcc.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSRECT_H
#define QGSRECT_H
#include <iosfwd>
class QString;
#include "qgspoint.h"
/** \ingroup core
* A rectangle specified with double values.
*
* QgsRectangle is used to store a rectangle when double values are required.
* Examples are storing a layer extent or the current view extent of a map
*/
class CORE_EXPORT QgsRectangle
{
public:
//! Constructor
QgsRectangle( double xmin = 0, double ymin = 0, double xmax = 0, double ymax = 0 );
//! Construct a rectangle from two points. The rectangle is normalized after construction.
QgsRectangle( QgsPoint const & p1, QgsPoint const & p2 );
//! Copy constructor
QgsRectangle( const QgsRectangle &other );
//! Destructor
~QgsRectangle();
//! Set the rectangle from two QgsPoints. The rectangle is
//normalised after construction.
void set( const QgsPoint& p1, const QgsPoint& p2 );
//! Set the rectangle from four points. The rectangle is
// normalised after construction.
void set( double xmin, double ymin, double xmax, double ymax );
//! Set the minimum x value
void setXMinimum( double x );
//! Set the maximum x value
void setXMaximum( double x );
//! Set the minimum y value
void setYMinimum( double y );
//! Set the maximum y value
void setYMaximum( double y );
//! Set a rectangle so that min corner is at max
// and max corner is at min. It is NOT normalized.
void setMinimal();
//! Get the x maximum value (right side of rectangle)
double xMaximum() const;
//! Get the x minimum value (left side of rectangle)
double xMinimum() const;
//! Get the y maximum value (top side of rectangle)
double yMaximum() const;
//! Get the y minimum value (bottom side of rectangle)
double yMinimum() const;
//! Normalize the rectangle so it has non-negative width/height
void normalize();
//! Width of the rectangle
double width() const;
//! Height of the rectangle
double height() const;
//! Center point of the rectangle
QgsPoint center() const;
//! Scale the rectangle around its center point
void scale( double scaleFactor, const QgsPoint *c = 0 );
Q_DECL_DEPRECATED void expand( double scaleFactor, const QgsPoint *c = 0 ) { return scale( scaleFactor * 2.0, c ); }
//! return the intersection with the given rectangle
QgsRectangle intersect( const QgsRectangle *rect ) const;
//! returns true when rectangle intersects with other rectangle
bool intersects( const QgsRectangle& rect ) const;
//! return true when rectangle contains other rectangle
//! @note added in version 1.1
bool contains( const QgsRectangle& rect ) const;
//! return true when rectangle contains a point
//! @note added in version 1.3
bool contains( const QgsPoint &p ) const;
//! expand the rectangle so that covers both the original rectangle and the given rectangle
void combineExtentWith( QgsRectangle *rect );
//! expand the rectangle so that covers both the original rectangle and the given point
void combineExtentWith( double x, double y );
//! test if rectangle is empty
bool isEmpty() const;
//! returns string representation in Wkt form
QString asWktCoordinates() const;
//! returns string representation of form xmin,ymin xmax,ymax
QString toString( bool automaticPrecision = false ) const;
//! overloaded toString that allows precision of numbers to be set
QString toString( int thePrecision ) const;
//! returns rectangle s a polygon
QString asPolygon() const;
/*! Comparison operator
@return True if rectangles are equal
*/
bool operator==( const QgsRectangle &r1 ) const;
/*! Comparison operator
@return False if rectangles are equal
*/
bool operator!=( const QgsRectangle &r1 ) const;
/*! Assignment operator
* @param r1 QgsRectangle to assign from
*/
QgsRectangle & operator=( const QgsRectangle &r1 );
/** updates rectangle to include passed argument */
void unionRect( const QgsRectangle& rect );
/** Returns true if the rectangle has finite boundaries. Will
return false if any of the rectangle boundaries are NaN or Inf. */
bool isFinite() const;
//! swap x/y
//! @note added in 1.9
void invert();
protected:
// These are protected instead of private so that things like
// the QgsPostGisBox3d can get at them.
double xmin;
double ymin;
double xmax;
double ymax;
};
inline QgsRectangle::~QgsRectangle()
{
}
inline void QgsRectangle::setXMinimum( double x )
{
xmin = x;
}
inline void QgsRectangle::setXMaximum( double x )
{
xmax = x;
}
inline void QgsRectangle::setYMinimum( double y )
{
ymin = y;
}
inline void QgsRectangle::setYMaximum( double y )
{
ymax = y;
}
inline double QgsRectangle::xMaximum() const
{
return xmax;
}
inline double QgsRectangle::xMinimum() const
{
return xmin;
}
inline double QgsRectangle::yMaximum() const
{
return ymax;
}
inline double QgsRectangle::yMinimum() const
{
return ymin;
}
inline double QgsRectangle::width() const
{
return xmax - xmin;
}
inline double QgsRectangle::height() const
{
return ymax - ymin;
}
inline QgsPoint QgsRectangle::center() const
{
return QgsPoint( xmin + width() / 2, ymin + height() / 2 );
}
inline std::ostream& operator << ( std::ostream& os, const QgsRectangle &r )
{
return os << r.toString().toLocal8Bit().data();
}
#endif // QGSRECT_H