Skip to content

Commit edadcb7

Browse files
lbartolettinyalldawson
lbartoletti
authored and
nyalldawson
committedJan 14, 2019
Refactoring of rectangle maptools
Adds a new geometry class QgsQuadrilateral, for 4 sided geometries.
·
ltr-3_40final-3_6_0
1 parent 046bec4 commit edadcb7

15 files changed

+1179
-186
lines changed
 

Diff for: ‎python/core/auto_generated/geometry/qgsquadrilateral.sip.in

+201
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,201 @@
1+
/************************************************************************
2+
* This file has been generated automatically from *
3+
* *
4+
* src/core/geometry/qgsquadrilateral.h *
5+
* *
6+
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
7+
************************************************************************/
8+
9+
10+
11+
12+
13+
class QgsQuadrilateral
14+
{
15+
%Docstring
16+
Quadrilateral geometry type.
17+
A quadrilateral is a polygon with four edges (or sides) and four vertices or corners.
18+
This class allows the creation of simple quadrilateral (which does not self-intersect).
19+
20+
.. versionadded:: 3.6
21+
%End
22+
23+
%TypeHeaderCode
24+
#include "qgsquadrilateral.h"
25+
%End
26+
public:
27+
QgsQuadrilateral();
28+
29+
QgsQuadrilateral( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, const QgsPoint &p4 );
30+
%Docstring
31+
Construct a QgsQuadrilateral from four :py:class:`QgsPoint`.
32+
33+
:param p1: first point
34+
:param p2: second point
35+
:param p3: third point
36+
:param p4: fourth point
37+
38+
.. seealso:: :py:func:`setPoints`
39+
%End
40+
41+
explicit QgsQuadrilateral( const QgsPointXY &p1, const QgsPointXY &p2, const QgsPointXY &p3, const QgsPointXY &p4 );
42+
%Docstring
43+
Construct a QgsQuadrilateral from four :py:class:`QgsPointXY`.
44+
45+
:param p1: first point
46+
:param p2: second point
47+
:param p3: third point
48+
:param p4: fourth point
49+
50+
.. seealso:: :py:func:`setPoints`
51+
%End
52+
53+
54+
enum ConstructionOption
55+
{
56+
Distance,
57+
Projected,
58+
};
59+
60+
static QgsQuadrilateral rectangleFrom3Points( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, ConstructionOption mode );
61+
%Docstring
62+
Construct a QgsQuadrilateral as a Rectangle from 3 points.
63+
In the case where one of the points is of type PointZ. The other points
64+
will also be of type Z, even if they are of type Point. In addition,
65+
the z used will be the one of the first point with a Z.
66+
This ensures consistency in point types and the ability to export to a
67+
Polygon or LineString.
68+
69+
:param p1: first point
70+
:param p2: second point
71+
:param p3: third point
72+
:param mode: Construction mode to construct the rectangle from 3 points
73+
74+
.. seealso:: ConstructionOption
75+
%End
76+
77+
static QgsQuadrilateral rectangleFromExtent( const QgsPoint &p1, const QgsPoint &p2 );
78+
%Docstring
79+
Construct a QgsQuadrilateral as a rectangle from an extent, defined by
80+
two opposite corner points.
81+
Z is taken from point ``p1``.
82+
83+
:param p1: first point
84+
:param p2: second point
85+
%End
86+
87+
88+
static QgsQuadrilateral squareFromDiagonal( const QgsPoint &p1, const QgsPoint &p2 );
89+
%Docstring
90+
Construct a QgsQuadrilateral as a square from a diagonal.
91+
Z is taken from point ``p1``.
92+
93+
:param p1: first point
94+
:param p2: second point
95+
%End
96+
97+
static QgsQuadrilateral rectangleFromCenterPoint( const QgsPoint &center, const QgsPoint &point );
98+
%Docstring
99+
Construct a QgsQuadrilateral as a rectangle from center point ``center``
100+
and another point ``point``.
101+
Z is taken from ``center`` point.
102+
103+
:param center: center point
104+
:param point: corner point
105+
%End
106+
107+
static QgsQuadrilateral fromRectangle( const QgsRectangle &rectangle );
108+
%Docstring
109+
Construct a QgsQuadrilateral as a rectangle from a :py:class:`QgsRectangle`.
110+
111+
:param rectangle: rectangle
112+
%End
113+
114+
115+
bool equals( const QgsQuadrilateral &other, double epsilon = 4 * DBL_EPSILON ) const;
116+
%Docstring
117+
Compares two QgsQuadrilateral, allowing specification of the maximum allowable difference between points.
118+
119+
:param other: the QgsQuadrilateral to compare
120+
:param epsilon: the maximum difference allowed / tolerance
121+
%End
122+
bool operator==( const QgsQuadrilateral &other ) const;
123+
bool operator!=( const QgsQuadrilateral &other ) const;
124+
125+
bool isValid() const;
126+
%Docstring
127+
Convenient method to determine if a QgsQuadrilateral is valid.
128+
A QgsQuadrilateral must be simple (not self-intersecting) and
129+
cannot have collinear points.
130+
%End
131+
132+
enum Point
133+
{
134+
Point1,
135+
Point2,
136+
Point3,
137+
Point4,
138+
};
139+
140+
bool setPoint( const QgsPoint &newPoint, Point index );
141+
%Docstring
142+
Sets the point ``newPoint`` at the ``index``.
143+
Returns false if the QgsQuadrilateral is not valid.
144+
145+
.. seealso:: Point
146+
%End
147+
148+
bool setPoints( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, const QgsPoint &p4 );
149+
%Docstring
150+
Set all points
151+
Returns false if the QgsQuadrilateral is not valid:
152+
- The points do not have the same type
153+
- The quadrilateral would have auto intersections
154+
- The quadrilateral has double points
155+
- The quadrilateral has collinear points
156+
%End
157+
158+
QgsPointSequence points() const;
159+
%Docstring
160+
Returns a list including the vertices of the quadrilateral.
161+
%End
162+
163+
QgsPolygon *toPolygon( bool force2D = false ) const /Factory/;
164+
%Docstring
165+
Returns the quadrilateral as a new polygon. Ownership is transferred to the caller.
166+
%End
167+
168+
QgsLineString *toLineString( bool force2D = false ) const /Factory/;
169+
%Docstring
170+
Returns the quadrilateral as a new linestring. Ownership is transferred to the caller.
171+
%End
172+
173+
QString toString( int pointPrecision = 17 ) const;
174+
%Docstring
175+
Returns a string representation of the quadrilateral.
176+
Members will be truncated to the specified precision.
177+
%End
178+
179+
double area() const;
180+
%Docstring
181+
Returns the area of the quadrilateral, or 0 if the quadrilateral is empty.
182+
%End
183+
184+
double perimeter() const;
185+
%Docstring
186+
Returns the perimeter of the quadrilateral, or 0 if the quadrilateral is empty.
187+
%End
188+
SIP_PYOBJECT __repr__();
189+
%MethodCode
190+
QString str = QStringLiteral( "<QgsQuadrilateral: %1>" ).arg( sipCpp->toString() );
191+
sipRes = PyUnicode_FromString( str.toUtf8().constData() );
192+
%End
193+
};
194+
195+
/************************************************************************
196+
* This file has been generated automatically from *
197+
* *
198+
* src/core/geometry/qgsquadrilateral.h *
199+
* *
200+
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
201+
************************************************************************/

Diff for: ‎python/core/auto_generated/qgsvector3d.sip.in

+20
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,27 @@ Returns the length of the vector
8989
Normalizes the current vector in place.
9090
%End
9191

92+
double distance( const QgsVector3D &other ) const;
93+
%Docstring
94+
Returns the distance with the ``other`` :py:class:`QgsVector3`
95+
%End
96+
97+
static QgsVector3D perpendicularPoint( const QgsVector3D &v1, const QgsVector3D &v2, const QgsVector3D &vp );
98+
%Docstring
99+
Returns the perpendicular point of vector ``vp`` from [``v1`` - ``v2``]
100+
%End
92101

102+
QString toString( int precision = 17 ) const;
103+
%Docstring
104+
Returns a string representation of the 3D vector.
105+
Members will be truncated to the specified ``precision``.
106+
%End
107+
108+
SIP_PYOBJECT __repr__();
109+
%MethodCode
110+
QString str = QStringLiteral( "<QgsVector3D: %1>" ).arg( sipCpp->toString() );
111+
sipRes = PyUnicode_FromString( str.toUtf8().constData() );
112+
%End
93113
};
94114

95115
/************************************************************************

Diff for: ‎python/core/core_auto.sip

+1
Original file line numberDiff line numberDiff line change
@@ -288,6 +288,7 @@
288288
%Include auto_generated/geometry/qgsmultipolygon.sip
289289
%Include auto_generated/geometry/qgsmultisurface.sip
290290
%Include auto_generated/geometry/qgspolygon.sip
291+
%Include auto_generated/geometry/qgsquadrilateral.sip
291292
%Include auto_generated/geometry/qgsrectangle.sip
292293
%Include auto_generated/geometry/qgsreferencedgeometry.sip
293294
%Include auto_generated/geometry/qgsregularpolygon.sip

Diff for: ‎src/app/qgsmaptooladdrectangle.cpp

+4-90
Original file line numberDiff line numberDiff line change
@@ -35,26 +35,6 @@ QgsMapToolAddRectangle::QgsMapToolAddRectangle( QgsMapToolCapture *parentTool, Q
3535
connect( QgisApp::instance(), &QgisApp::projectRead, this, &QgsMapToolAddRectangle::stopCapturing );
3636
}
3737

38-
void QgsMapToolAddRectangle::setAzimuth( const double azimuth )
39-
{
40-
mAzimuth = azimuth;
41-
}
42-
43-
void QgsMapToolAddRectangle::setDistance1( const double distance1 )
44-
{
45-
mDistance1 = distance1;
46-
}
47-
48-
void QgsMapToolAddRectangle::setDistance2( const double distance2 )
49-
{
50-
mDistance2 = distance2;
51-
}
52-
53-
void QgsMapToolAddRectangle::setSide( const int side )
54-
{
55-
mSide = side;
56-
}
57-
5838
QgsMapToolAddRectangle::~QgsMapToolAddRectangle()
5939
{
6040
clean();
@@ -83,81 +63,15 @@ void QgsMapToolAddRectangle::keyReleaseEvent( QKeyEvent *e )
8363
}
8464
}
8565

86-
QgsLineString *QgsMapToolAddRectangle::rectangleToLinestring( const bool isOriented ) const
87-
{
88-
std::unique_ptr<QgsLineString> ext( new QgsLineString() );
89-
if ( mRectangle.toRectangle().isEmpty() )
90-
{
91-
return ext.release();
92-
}
93-
94-
QgsPoint x0( mRectangle.xMinimum(), mRectangle.yMinimum() );
95-
96-
QgsPoint x1, x2, x3;
97-
if ( isOriented )
98-
{
99-
const double perpendicular = 90.0 * mSide;
100-
x1 = x0.project( mDistance1, mAzimuth );
101-
x3 = x0.project( mDistance2, mAzimuth + perpendicular );
102-
x2 = x1.project( mDistance2, mAzimuth + perpendicular );
103-
}
104-
else
105-
{
106-
x1 = QgsPoint( mRectangle.xMinimum(), mRectangle.yMaximum() );
107-
x2 = QgsPoint( mRectangle.xMaximum(), mRectangle.yMaximum() );
108-
x3 = QgsPoint( mRectangle.xMaximum(), mRectangle.yMinimum() );
109-
}
110-
111-
ext->addVertex( x0 );
112-
ext->addVertex( x1 );
113-
ext->addVertex( x2 );
114-
ext->addVertex( x3 );
115-
ext->addVertex( x0 );
116-
117-
// keep z value from the first snapped point
118-
for ( const QgsPoint point : qgis::as_const( mPoints ) )
119-
{
120-
if ( QgsWkbTypes::hasZ( point.wkbType() ) )
121-
{
122-
if ( point.z() != defaultZValue() )
123-
{
124-
ext->dropZValue();
125-
ext->addZValue( point.z() );
126-
break;
127-
}
128-
else
129-
{
130-
ext->dropZValue();
131-
ext->addZValue( defaultZValue() );
132-
}
133-
}
134-
}
135-
136-
return ext.release();
137-
}
138-
139-
QgsPolygon *QgsMapToolAddRectangle::rectangleToPolygon( const bool isOriented ) const
140-
{
141-
std::unique_ptr<QgsPolygon> polygon( new QgsPolygon() );
142-
if ( mRectangle.toRectangle().isEmpty() )
143-
{
144-
return polygon.release();
145-
}
146-
147-
polygon->setExteriorRing( rectangleToLinestring( isOriented ) );
148-
149-
return polygon.release();
150-
}
151-
152-
void QgsMapToolAddRectangle::deactivate( const bool isOriented )
66+
void QgsMapToolAddRectangle::deactivate( )
15367
{
154-
if ( !mParentTool || mRectangle.toRectangle().isEmpty() )
68+
if ( !mParentTool || !mRectangle.isValid() )
15569
{
15670
return;
15771
}
15872

15973
mParentTool->clearCurve( );
160-
mParentTool->addCurve( rectangleToLinestring( isOriented ) );
74+
mParentTool->addCurve( mRectangle.toLineString( !QgsWkbTypes::hasZ( qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() )->wkbType() ) ) );
16175
clean();
16276

16377
QgsMapToolCapture::deactivate();
@@ -184,7 +98,7 @@ void QgsMapToolAddRectangle::clean()
18498
mParentTool->deleteTempRubberBand();
18599
}
186100

187-
mRectangle = QgsBox3d();
101+
mRectangle = QgsQuadrilateral();
188102

189103
QgsVectorLayer *vLayer = static_cast<QgsVectorLayer *>( QgisApp::instance()->activeLayer() );
190104
if ( vLayer )

Diff for: ‎src/app/qgsmaptooladdrectangle.h

+3-36
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@
1818

1919
#include "qgspolygon.h"
2020
#include "qgsmaptoolcapture.h"
21-
#include "qgsbox3d.h"
21+
#include "qgsquadrilateral.h"
2222
#include "qgis_app.h"
2323

2424
class QgsPolygon;
@@ -35,7 +35,7 @@ class APP_EXPORT QgsMapToolAddRectangle: public QgsMapToolCapture
3535
void keyPressEvent( QKeyEvent *e ) override;
3636
void keyReleaseEvent( QKeyEvent *e ) override;
3737

38-
void deactivate( bool isOriented = false );
38+
void deactivate( ) override;
3939

4040
void activate() override;
4141
void clean() override;
@@ -53,46 +53,13 @@ class APP_EXPORT QgsMapToolAddRectangle: public QgsMapToolCapture
5353
//! The rubberband to show the rectangle currently working on
5454
QgsGeometryRubberBand *mTempRubberBand = nullptr;
5555
//! Rectangle
56-
QgsBox3d mRectangle;
57-
58-
//! Convenient method to export a QgsRectangle to a LineString
59-
QgsLineString *rectangleToLinestring( bool isOriented = false ) const;
60-
//! Convenient method to export a QgsRectangle to a Polygon
61-
QgsPolygon *rectangleToPolygon( bool isOriented = false ) const;
62-
63-
//! Sets the azimuth. \see mAzimuth
64-
void setAzimuth( double azimuth );
65-
//! Sets the first distance. \see mDistance1
66-
void setDistance1( double distance1 );
67-
//! Sets the second distance. \see mDistance2
68-
void setDistance2( double distance2 );
69-
//! Sets the side. \see mSide
70-
void setSide( int side );
71-
72-
//! Returns the azimuth. \see mAzimuth
73-
double azimuth( ) const { return mAzimuth; }
74-
//! Returns the first distance. \see mDistance1
75-
double distance1( ) const { return mDistance1; }
76-
//! Returns the second distance. \see mDistance2
77-
double distance2( ) const { return mDistance2; }
78-
//! Returns the side. \see mSide
79-
int side( ) const { return mSide; }
56+
QgsQuadrilateral mRectangle;
8057

8158
//! Layer type which will be used for rubberband
8259
QgsWkbTypes::GeometryType mLayerType = QgsWkbTypes::LineGeometry;
8360

8461
//! Snapping indicators
8562
std::unique_ptr<QgsSnapIndicator> mSnapIndicator;
86-
87-
private:
88-
//! Convenient member for the azimuth of the rotated rectangle or when map is rotated.
89-
double mAzimuth = 0.0;
90-
//! Convenient member for the first distance of the rotated rectangle or when map is rotated.
91-
double mDistance1 = 0.0;
92-
//! Convenient member for the second distance of the rotated rectangle or when map is rotated.
93-
double mDistance2 = 0.0;
94-
//! Convenient member for the side where the second distance is drawn or when map is rotated.
95-
int mSide = 1;
9663
};
9764

9865
#endif // QGSMAPTOOLADDRECTANGLE_H

Diff for: ‎src/app/qgsmaptoolrectangle3points.cpp

+17-26
Original file line numberDiff line numberDiff line change
@@ -37,18 +37,27 @@ void QgsMapToolRectangle3Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
3737

3838
if ( e->button() == Qt::LeftButton )
3939
{
40+
if ( !point.is3D() )
41+
point.addZValue( defaultZValue() );
4042
if ( mPoints.size() < 2 )
43+
{
4144
mPoints.append( point );
45+
}
4246

4347
if ( !mPoints.isEmpty() && !mTempRubberBand )
4448
{
4549
mTempRubberBand = createGeometryRubberBand( mLayerType, true );
4650
mTempRubberBand->show();
4751
}
52+
if ( mPoints.size() == 3 )
53+
{
54+
delete mTempRubberBand;
55+
mTempRubberBand = createGeometryRubberBand( mLayerType, true ); // recreate rubberband for polygon
56+
}
4857
}
4958
else if ( e->button() == Qt::RightButton )
5059
{
51-
deactivate( true );
60+
deactivate( );
5261
if ( mParentTool )
5362
{
5463
mParentTool->canvasReleaseEvent( e );
@@ -72,43 +81,25 @@ void QgsMapToolRectangle3Points::cadCanvasMoveEvent( QgsMapMouseEvent *e )
7281
line->addVertex( mPoints.at( 0 ) );
7382
line->addVertex( point );
7483
mTempRubberBand->setGeometry( line.release() );
75-
setAzimuth( mPoints.at( 0 ).azimuth( point ) );
76-
setDistance1( mPoints.at( 0 ).distance( point ) );
84+
break;
7785
}
78-
break;
7986
case 2:
8087
{
88+
if ( !point.is3D() )
89+
point.addZValue( defaultZValue() );
8190
switch ( mCreateMode )
8291
{
8392
case DistanceMode:
84-
setDistance2( mPoints.at( 1 ).distance( point ) );
93+
mRectangle = QgsQuadrilateral::rectangleFrom3Points( mPoints.at( 0 ), mPoints.at( 1 ), point, QgsQuadrilateral::Distance );
8594
break;
8695
case ProjectedMode:
87-
setDistance2( QgsGeometryUtils::perpendicularSegment( point, mPoints.at( 0 ), mPoints.at( 1 ) ).length() );
96+
mRectangle = QgsQuadrilateral::rectangleFrom3Points( mPoints.at( 0 ), mPoints.at( 1 ), point, QgsQuadrilateral::Projected );
8897
break;
8998
}
90-
int side = QgsGeometryUtils::leftOfLine( point.x(), point.y(),
91-
mPoints.at( 0 ).x(), mPoints.at( 0 ).y(),
92-
mPoints.at( 1 ).x(), mPoints.at( 1 ).y() );
93-
94-
setSide( side < 0 ? -1 : 1 );
95-
96-
const double xMin = mPoints.at( 0 ).x();
97-
const double xMax = mPoints.at( 0 ).x() + distance2( );
9899

99-
const double yMin = mPoints.at( 0 ).y();
100-
const double yMax = mPoints.at( 0 ).y() + distance1();
101-
102-
const double z = mPoints.at( 0 ).z();
103-
104-
mRectangle = QgsBox3d( xMin, yMin, z, xMax, yMax, z );
105-
106-
107-
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon( true ) );
108-
}
109-
break;
110-
default:
100+
mTempRubberBand->setGeometry( mRectangle.toPolygon() );
111101
break;
102+
}
112103
}
113104
}
114105
}

Diff for: ‎src/app/qgsmaptoolrectanglecenter.cpp

+5-14
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include "qgspoint.h"
2323
#include "qgsmapmouseevent.h"
2424
#include "qgssnapindicator.h"
25+
#include "qgsquadrilateral.h"
2526

2627
#include <memory>
2728

@@ -69,23 +70,13 @@ void QgsMapToolRectangleCenter::cadCanvasMoveEvent( QgsMapMouseEvent *e )
6970
{
7071
case 1:
7172
{
72-
if ( qgsDoubleNear( mCanvas->rotation(), 0.0 ) )
73-
{
74-
double xOffset = fabs( point.x() - mPoints.at( 0 ).x() );
75-
double yOffset = fabs( point.y() - mPoints.at( 0 ).y() );
7673

77-
mRectangle = QgsBox3d( QgsPoint( mPoints.at( 0 ).x() - xOffset, mPoints.at( 0 ).y() - yOffset, mPoints.at( 0 ).z() ), QgsPoint( mPoints.at( 0 ).x() + xOffset, mPoints.at( 0 ).y() + yOffset, mPoints.at( 0 ).z() ) );
74+
double dist = mPoints.at( 0 ).distance( point );
75+
double angle = mPoints.at( 0 ).azimuth( point );
7876

79-
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon() );
80-
}
81-
else
82-
{
83-
double dist = mPoints.at( 0 ).distance( point );
84-
double angle = mPoints.at( 0 ).azimuth( point );
77+
mRectangle = QgsQuadrilateral::rectangleFromExtent( mPoints.at( 0 ).project( -dist, angle ), mPoints.at( 0 ).project( dist, angle ) );
78+
mTempRubberBand->setGeometry( mRectangle.toPolygon() );
8579

86-
mRectangle = QgsBox3d( mPoints.at( 0 ).project( -dist, angle ), mPoints.at( 0 ).project( dist, angle ) );
87-
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon() );
88-
}
8980
}
9081
break;
9182
default:

Diff for: ‎src/app/qgsmaptoolrectangleextent.cpp

+4-12
Original file line numberDiff line numberDiff line change
@@ -68,19 +68,11 @@ void QgsMapToolRectangleExtent::cadCanvasMoveEvent( QgsMapMouseEvent *e )
6868
{
6969
case 1:
7070
{
71-
if ( qgsDoubleNear( mCanvas->rotation(), 0.0 ) )
72-
{
73-
mRectangle = QgsBox3d( mPoints.at( 0 ), point );
74-
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon( ) );
75-
}
76-
else
77-
{
78-
double dist = mPoints.at( 0 ).distance( point );
79-
double angle = mPoints.at( 0 ).azimuth( point );
71+
double dist = mPoints.at( 0 ).distance( point );
72+
double angle = mPoints.at( 0 ).azimuth( point );
8073

81-
mRectangle = QgsBox3d( mPoints.at( 0 ), mPoints.at( 0 ).project( dist, angle ) );
82-
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon() );
83-
}
74+
mRectangle = QgsQuadrilateral::rectangleFromExtent( mPoints.at( 0 ), mPoints.at( 0 ).project( dist, angle ) );
75+
mTempRubberBand->setGeometry( mRectangle.toPolygon() );
8476
}
8577
break;
8678
default:

Diff for: ‎src/core/CMakeLists.txt

+2
Original file line numberDiff line numberDiff line change
@@ -505,6 +505,7 @@ SET(QGIS_CORE_SRCS
505505
geometry/qgsmultisurface.cpp
506506
geometry/qgspoint.cpp
507507
geometry/qgspolygon.cpp
508+
geometry/qgsquadrilateral.cpp
508509
geometry/qgsrectangle.cpp
509510
geometry/qgsreferencedgeometry.cpp
510511
geometry/qgsregularpolygon.cpp
@@ -1167,6 +1168,7 @@ SET(QGIS_CORE_HDRS
11671168
geometry/qgsmultipolygon.h
11681169
geometry/qgsmultisurface.h
11691170
geometry/qgspolygon.h
1171+
geometry/qgsquadrilateral.h
11701172
geometry/qgsrectangle.h
11711173
geometry/qgsreferencedgeometry.h
11721174
geometry/qgsregularpolygon.h

Diff for: ‎src/core/geometry/qgsquadrilateral.cpp

+424
Large diffs are not rendered by default.

Diff for: ‎src/core/geometry/qgsquadrilateral.h

+214
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,214 @@
1+
/***************************************************************************
2+
qgsquadrilateral.h
3+
-------------------
4+
begin : November 2018
5+
copyright : (C) 2018 by Loïc Bartoletti
6+
email : loic dot bartoletti at oslandia dot com
7+
***************************************************************************/
8+
9+
/***************************************************************************
10+
* *
11+
* This program is free software; you can redistribute it and/or modify *
12+
* it under the terms of the GNU General Public License as published by *
13+
* the Free Software Foundation; either version 2 of the License, or *
14+
* (at your option) any later version. *
15+
* *
16+
***************************************************************************/
17+
18+
#ifndef QGSQUADRILATERAL_H
19+
#define QGSQUADRILATERAL_H
20+
21+
22+
#include "qgis_core.h"
23+
#include "qgspoint.h"
24+
#include "qgspolygon.h"
25+
#include "qgslinestring.h"
26+
27+
/**
28+
* \ingroup core
29+
* \class QgsQuadrilateral
30+
* \brief Quadrilateral geometry type.
31+
* A quadrilateral is a polygon with four edges (or sides) and four vertices or corners.
32+
* This class allows the creation of simple quadrilateral (which does not self-intersect).
33+
* \since QGIS 3.6
34+
*/
35+
class CORE_EXPORT QgsQuadrilateral
36+
{
37+
public:
38+
QgsQuadrilateral();
39+
40+
/**
41+
* Construct a QgsQuadrilateral from four QgsPoint.
42+
* \param p1 first point
43+
* \param p2 second point
44+
* \param p3 third point
45+
* \param p4 fourth point
46+
* \see setPoints
47+
*/
48+
QgsQuadrilateral( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, const QgsPoint &p4 );
49+
50+
/**
51+
* Construct a QgsQuadrilateral from four QgsPointXY.
52+
* \param p1 first point
53+
* \param p2 second point
54+
* \param p3 third point
55+
* \param p4 fourth point
56+
* \see setPoints
57+
*/
58+
explicit QgsQuadrilateral( const QgsPointXY &p1, const QgsPointXY &p2, const QgsPointXY &p3, const QgsPointXY &p4 );
59+
60+
61+
/**
62+
* A quadrilateral can be constructed from 3 points where the second distance can be determined by the third point.
63+
*
64+
*/
65+
enum ConstructionOption
66+
{
67+
Distance, //<! Second distance is equal to the distance between 2nd and 3rd point
68+
Projected, //<! Second distance is equal to the distance of the perpendicualr projection of the 3rd point on the segment or its extension.
69+
};
70+
71+
/**
72+
* Construct a QgsQuadrilateral as a Rectangle from 3 points.
73+
* In the case where one of the points is of type PointZ. The other points
74+
* will also be of type Z, even if they are of type Point. In addition,
75+
* the z used will be the one of the first point with a Z.
76+
* This ensures consistency in point types and the ability to export to a
77+
* Polygon or LineString.
78+
* \param p1 first point
79+
* \param p2 second point
80+
* \param p3 third point
81+
* \param mode Construction mode to construct the rectangle from 3 points
82+
* \see ConstructionOption
83+
*/
84+
static QgsQuadrilateral rectangleFrom3Points( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, ConstructionOption mode );
85+
86+
/**
87+
* Construct a QgsQuadrilateral as a rectangle from an extent, defined by
88+
* two opposite corner points.
89+
* Z is taken from point \a p1.
90+
* \param p1 first point
91+
* \param p2 second point
92+
*/
93+
static QgsQuadrilateral rectangleFromExtent( const QgsPoint &p1, const QgsPoint &p2 );
94+
95+
#ifndef SIP_RUN
96+
97+
/**
98+
* Alias for rectangleFromDiagonal
99+
*/
100+
static constexpr auto &rectangleFromDiagonal = rectangleFromExtent;
101+
#endif
102+
103+
/**
104+
* Construct a QgsQuadrilateral as a square from a diagonal.
105+
* Z is taken from point \a p1.
106+
* \param p1 first point
107+
* \param p2 second point
108+
*/
109+
static QgsQuadrilateral squareFromDiagonal( const QgsPoint &p1, const QgsPoint &p2 );
110+
111+
/**
112+
* Construct a QgsQuadrilateral as a rectangle from center point \a center
113+
* and another point \a point.
114+
* Z is taken from \a center point.
115+
* \param center center point
116+
* \param point corner point
117+
*/
118+
static QgsQuadrilateral rectangleFromCenterPoint( const QgsPoint &center, const QgsPoint &point );
119+
120+
/**
121+
* Construct a QgsQuadrilateral as a rectangle from a QgsRectangle.
122+
* \param rectangle rectangle
123+
*/
124+
static QgsQuadrilateral fromRectangle( const QgsRectangle &rectangle );
125+
126+
// TODO:
127+
// Rhombus
128+
129+
/**
130+
* Compares two QgsQuadrilateral, allowing specification of the maximum allowable difference between points.
131+
* \param other the QgsQuadrilateral to compare
132+
* \param epsilon the maximum difference allowed / tolerance
133+
*/
134+
bool equals( const QgsQuadrilateral &other, double epsilon = 4 * std::numeric_limits<double>::epsilon() ) const;
135+
bool operator==( const QgsQuadrilateral &other ) const;
136+
bool operator!=( const QgsQuadrilateral &other ) const;
137+
138+
/**
139+
* Convenient method to determine if a QgsQuadrilateral is valid.
140+
* A QgsQuadrilateral must be simple (not self-intersecting) and
141+
* cannot have collinear points.
142+
*/
143+
bool isValid() const;
144+
145+
/**
146+
* Simple enumeration to ensure indices in setPoint
147+
*/
148+
enum Point
149+
{
150+
Point1,
151+
Point2,
152+
Point3,
153+
Point4,
154+
};
155+
156+
/**
157+
* Sets the point \a newPoint at the \a index.
158+
* Returns false if the QgsQuadrilateral is not valid.
159+
* \see Point
160+
*/
161+
bool setPoint( const QgsPoint &newPoint, Point index );
162+
163+
/**
164+
* Set all points
165+
* Returns false if the QgsQuadrilateral is not valid:
166+
* - The points do not have the same type
167+
* - The quadrilateral would have auto intersections
168+
* - The quadrilateral has double points
169+
* - The quadrilateral has collinear points
170+
*/
171+
bool setPoints( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, const QgsPoint &p4 );
172+
173+
/**
174+
* Returns a list including the vertices of the quadrilateral.
175+
*/
176+
QgsPointSequence points() const;
177+
178+
/**
179+
* Returns the quadrilateral as a new polygon. Ownership is transferred to the caller.
180+
*/
181+
QgsPolygon *toPolygon( bool force2D = false ) const SIP_FACTORY;
182+
183+
/**
184+
* Returns the quadrilateral as a new linestring. Ownership is transferred to the caller.
185+
*/
186+
QgsLineString *toLineString( bool force2D = false ) const SIP_FACTORY;
187+
188+
/**
189+
* Returns a string representation of the quadrilateral.
190+
* Members will be truncated to the specified precision.
191+
*/
192+
QString toString( int pointPrecision = 17 ) const;
193+
194+
/**
195+
* Returns the area of the quadrilateral, or 0 if the quadrilateral is empty.
196+
*/
197+
double area() const;
198+
199+
/**
200+
* Returns the perimeter of the quadrilateral, or 0 if the quadrilateral is empty.
201+
*/
202+
double perimeter() const;
203+
#ifdef SIP_RUN
204+
SIP_PYOBJECT __repr__();
205+
% MethodCode
206+
QString str = QStringLiteral( "<QgsQuadrilateral: %1>" ).arg( sipCpp->toString() );
207+
sipRes = PyUnicode_FromString( str.toUtf8().constData() );
208+
% End
209+
#endif
210+
private:
211+
QgsPoint mPoint1, mPoint2, mPoint3, mPoint4;
212+
};
213+
214+
#endif // QGSQUADRILATERAL_H

Diff for: ‎src/core/qgsvector3d.h

+40
Original file line numberDiff line numberDiff line change
@@ -126,7 +126,47 @@ class CORE_EXPORT QgsVector3D
126126
}
127127
}
128128

129+
//! Returns the distance with the \a other QgsVector3
130+
double distance( const QgsVector3D &other ) const
131+
{
132+
return std::sqrt( ( mX - other.x() ) * ( mX - other.x() ) +
133+
( mY - other.y() ) * ( mY - other.y() ) +
134+
( mZ - other.z() ) * ( mZ - other.z() ) );
135+
}
136+
137+
//! Returns the perpendicular point of vector \a vp from [\a v1 - \a v2]
138+
static QgsVector3D perpendicularPoint( const QgsVector3D &v1, const QgsVector3D &v2, const QgsVector3D &vp )
139+
{
140+
QgsVector3D d = ( v2 - v1 ) / v2.distance( v1 );
141+
QgsVector3D v = vp - v2;
142+
double t = dotProduct( v, d );
143+
QgsVector3D P = v2 + ( d * t );
144+
return P;
145+
}
146+
147+
/**
148+
* Returns a string representation of the 3D vector.
149+
* Members will be truncated to the specified \a precision.
150+
*/
151+
QString toString( int precision = 17 ) const
152+
{
153+
QString str = "QgsVector3D (";
154+
str += qgsDoubleToString( mX, precision );
155+
str += ' ';
156+
str += qgsDoubleToString( mY, precision );
157+
str += ' ';
158+
str += qgsDoubleToString( mZ, precision );
159+
str += ')';
160+
return str;
161+
}
129162

163+
#ifdef SIP_RUN
164+
SIP_PYOBJECT __repr__();
165+
% MethodCode
166+
QString str = QStringLiteral( "<QgsVector3D: %1>" ).arg( sipCpp->toString() );
167+
sipRes = PyUnicode_FromString( str.toUtf8().constData() );
168+
% End
169+
#endif
130170
private:
131171
double mX = 0, mY = 0, mZ = 0;
132172
};

Diff for: ‎tests/src/app/testqgsmaptoolrectangle.cpp

+16-8
Original file line numberDiff line numberDiff line change
@@ -97,11 +97,13 @@ void TestQgsMapToolRectangle::testRectangleFromCenter()
9797
utils.mouseClick( 2, 1, Qt::RightButton );
9898
QgsFeatureId newFid = utils.newFeatureId();
9999

100-
QCOMPARE( mLayer->featureCount(), ( long )1 );
100+
// QCOMPARE( mLayer->featureCount(), ( long )1 );
101101
QgsFeature f = mLayer->getFeature( newFid );
102102

103103
QString wkt = "LineStringZ (-2 -1 333, -2 1 333, 2 1 333, 2 -1 333, -2 -1 333)";
104-
QCOMPARE( f.geometry().asWkt(), wkt );
104+
QgsLineString line;
105+
line.fromWkt( wkt );
106+
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
105107

106108
mLayer->rollBack();
107109
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
@@ -121,11 +123,13 @@ void TestQgsMapToolRectangle::testRectangleFromExtent()
121123
utils.mouseClick( 2, 1, Qt::RightButton );
122124
QgsFeatureId newFid = utils.newFeatureId();
123125

124-
QCOMPARE( mLayer->featureCount(), ( long )1 );
126+
// QCOMPARE( mLayer->featureCount(), ( long )1 );
125127
QgsFeature f = mLayer->getFeature( newFid );
126128

127129
QString wkt = "LineStringZ (0 0 222, 0 1 222, 2 1 222, 2 0 222, 0 0 222)";
128-
QCOMPARE( f.geometry().asWkt(), wkt );
130+
QgsLineString line;
131+
line.fromWkt( wkt );
132+
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
129133

130134
mLayer->rollBack();
131135
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
@@ -147,11 +151,13 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsDistance()
147151
utils.mouseClick( 2, 1, Qt::RightButton );
148152
QgsFeatureId newFid = utils.newFeatureId();
149153

150-
QCOMPARE( mLayer->featureCount(), ( long )1 );
154+
// QCOMPARE( mLayer->featureCount(), ( long )1 );
151155
QgsFeature f = mLayer->getFeature( newFid );
152156

153157
QString wkt = "LineStringZ (0 0 111, 2 0 111, 2 1 111, 0 1 111, 0 0 111)";
154-
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
158+
QgsLineString line;
159+
line.fromWkt( wkt );
160+
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
155161

156162
mLayer->rollBack();
157163
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
@@ -173,11 +179,13 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsProjected()
173179
utils.mouseClick( 2, 1, Qt::RightButton );
174180
QgsFeatureId newFid = utils.newFeatureId();
175181

176-
QCOMPARE( mLayer->featureCount(), ( long )1 );
182+
// QCOMPARE( mLayer->featureCount(), ( long )1 );
177183
QgsFeature f = mLayer->getFeature( newFid );
178184

179185
QString wkt = "LineStringZ (0 0 111, 2 0 111, 2 1 111, 0 1 111, 0 0 111)";
180-
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
186+
QgsLineString line;
187+
line.fromWkt( wkt );
188+
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
181189

182190
mLayer->rollBack();
183191
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );

Diff for: ‎tests/src/core/testqgsgeometry.cpp

+211
Large diffs are not rendered by default.

Diff for: ‎tests/src/core/testqgsvector.cpp

+17
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,11 @@ void TestQgsVector::cleanupTestCase()
4747

4848
void TestQgsVector::vector3d()
4949
{
50+
//string
51+
QCOMPARE( QgsVector3D().toString(), QString( "QgsVector3D (0 0 0)" ) );
52+
QCOMPARE( QgsVector3D( 0, 1, 2 ).toString(), QString( "QgsVector3D (0 1 2)" ) );
53+
QCOMPARE( QgsVector3D( 0.12, 1.234, 2.3456789 ).toString( 1 ), QString( "QgsVector3D (0.1 1.2 2.3)" ) );
54+
5055
QgsVector3D p0( 0.0, 0.0, 0.0 );
5156
QgsVector3D p1( 1.0, 2.0, 3.0 );
5257
QgsVector3D p2( 4.0, 5.0, 6.0 );
@@ -66,6 +71,18 @@ void TestQgsVector::vector3d()
6671
QCOMPARE( p3, QgsVector3D( 0.0, -1.0, 0.0 ) );
6772
QCOMPARE( p4, QgsVector3D( 1.0 / 3.0, 2.0 / 3.0, -2.0 / 3.0 ) );
6873

74+
// distance
75+
QCOMPARE( p0.distance( p0 ), 0.0 );
76+
QCOMPARE( p0.distance( QgsVector3D( 5.0, 0.0, 0.0 ) ), 5.0 );
77+
QCOMPARE( p0.distance( QgsVector3D( 0.0, 5.0, 0.0 ) ), 5.0 );
78+
QCOMPARE( p0.distance( QgsVector3D( 0.0, 0.0, 5.0 ) ), 5.0 );
79+
QCOMPARE( p0.distance( QgsVector3D( 1.0, 1.0, 0.0 ) ), sqrt( 2 ) );
80+
QCOMPARE( p0.distance( QgsVector3D( 1.0, 1.0, 1.0 ) ), sqrt( 3 ) );
81+
82+
// perpendicular point
83+
QCOMPARE( QgsVector3D::perpendicularPoint( QgsVector3D( 0.0, 0.0, 0.0 ), QgsVector3D( 0.0, 5.0, 0.0 ), QgsVector3D( 1.0, 4.0, 0.0 ) ), QgsVector3D( 0.0, 4.0, 0.0 ) );
84+
QCOMPARE( QgsVector3D::perpendicularPoint( QgsVector3D( 0.0, 0.0, 5.0 ), QgsVector3D( 0.0, 0.0, 10.0 ), QgsVector3D( 2.0, 4.0, 7 ) ), QgsVector3D( 0.0, 0.0, 7.0 ) );
85+
QCOMPARE( QgsVector3D::perpendicularPoint( QgsVector3D( 0.0, 0.0, 5.0 ), QgsVector3D( 0.0, 5.0, 10.0 ), QgsVector3D( 1.0, 4.0, 5.0 ) ).toString( 2 ), QgsVector3D( 0.0, 2.0, 7.0 ).toString( 2 ) );
6986
}
7087

7188
QGSTEST_MAIN( TestQgsVector )

0 commit comments

Comments
 (0)
Please sign in to comment.