32 : mSimplifyFlags( simplifyFlags )
33 , mSimplifyAlgorithm( simplifyAlgorithm )
34 , mTolerance( tolerance )
43 const float vx =
static_cast< float >( x2 - x1 );
44 const float vy =
static_cast< float >( y2 - y1 );
46 return ( vx * vx ) + ( vy * vy );
51 const int grid_x1 = std::round( ( x1 - gridOriginX ) * gridInverseSizeXY );
52 const int grid_x2 = std::round( ( x2 - gridOriginX ) * gridInverseSizeXY );
53 if ( grid_x1 != grid_x2 )
return false;
55 const int grid_y1 = std::round( ( y1 - gridOriginY ) * gridInverseSizeXY );
56 const int grid_y2 = std::round( ( y2 - gridOriginY ) * gridInverseSizeXY );
57 return grid_y1 == grid_y2;
67 #include "simplify/effectivearea.h"
72 static std::unique_ptr< QgsAbstractGeometry > generalizeWkbGeometryByBoundingBox(
85 return std::unique_ptr< QgsAbstractGeometry >( geometry.
clone() );
88 const double x1 = envelope.
xMinimum();
89 const double y1 = envelope.
yMinimum();
90 const double x2 = envelope.
xMaximum();
91 const double y2 = envelope.
yMaximum();
96 return std::make_unique< QgsLineString >( QVector<double>() << x1 << x2, QVector<double>() << y1 << y2 );
100 std::unique_ptr< QgsLineString > ext = std::make_unique< QgsLineString >(
101 QVector< double >() << x1
106 QVector< double >() << y1
112 return std::move( ext );
115 std::unique_ptr< QgsPolygon > polygon = std::make_unique< QgsPolygon >();
116 polygon->setExteriorRing( ext.release() );
117 return std::move( polygon );
122 std::unique_ptr< QgsAbstractGeometry > QgsMapToPixelSimplifier::simplifyGeometry(
int simplifyFlags,
123 SimplifyAlgorithm simplifyAlgorithm,
127 bool isGeneralizable =
true;
135 return generalizeWkbGeometryByBoundingBox( wkbType, geometry, envelope, isaLinearRing );
139 isGeneralizable =
false;
147 const int numPoints = srcCurve.
numPoints();
149 std::unique_ptr<QgsCurve> output;
151 QVector< double > lineStringX;
152 QVector< double > lineStringY;
157 lineStringX.reserve( numPoints );
158 lineStringY.reserve( numPoints );
165 double x = 0.0, y = 0.0, lastX = 0.0, lastY = 0.0;
167 if ( numPoints <= ( isaLinearRing ? 4 : 2 ) )
168 isGeneralizable =
false;
171 bool hasLongSegments =
false;
185 const double gridOriginX = envelope.
xMinimum();
186 const double gridOriginY = envelope.
yMinimum();
189 const float gridInverseSizeXY = map2pixelTol != 0 ? ( float )( 1.0f / ( 0.8 * map2pixelTol ) ) : 0.0f;
191 const double *xData =
nullptr;
192 const double *yData =
nullptr;
195 xData = qgsgeometry_cast< const QgsLineString * >( &srcCurve )->xData();
196 yData = qgsgeometry_cast< const QgsLineString * >( &srcCurve )->yData();
199 for (
int i = 0; i < numPoints; ++i )
201 if ( xData && yData )
208 x = srcCurve.
xAt( i );
209 y = srcCurve.
yAt( i );
214 !
equalSnapToGrid( x, y, lastX, lastY, gridOriginX, gridOriginY, gridInverseSizeXY ) ||
215 ( !isaLinearRing && ( i == 1 || i >= numPoints - 2 ) ) )
221 lineStringX.append( x );
222 lineStringY.append( y );
233 output.reset( qgsgeometry_cast< QgsCurve * >( srcCurve.
snappedToGrid( map2pixelTol, map2pixelTol ) ) );
239 map2pixelTol *= map2pixelTol;
241 EFFECTIVE_AREAS ea( srcCurve );
243 const int set_area = 0;
244 ptarray_calc_areas( &ea, isaLinearRing ? 4 : 2, set_area, map2pixelTol );
246 for (
int i = 0; i < numPoints; ++i )
248 if ( ea.res_arealist[ i ] > map2pixelTol )
251 output->insertVertex(
QgsVertexId( 0, 0, output->numPoints() ), ea.inpts.at( i ) );
254 lineStringX.append( ea.inpts.at( i ).x() );
255 lineStringY.append( ea.inpts.at( i ).y() );
264 map2pixelTol *= map2pixelTol;
266 const double *xData =
nullptr;
267 const double *yData =
nullptr;
270 xData = qgsgeometry_cast< const QgsLineString * >( &srcCurve )->xData();
271 yData = qgsgeometry_cast< const QgsLineString * >( &srcCurve )->yData();
274 for (
int i = 0; i < numPoints; ++i )
276 if ( xData && yData )
283 x = srcCurve.
xAt( i );
284 y = srcCurve.
yAt( i );
287 isLongSegment =
false;
292 ( !isaLinearRing && ( i == 1 || i >= numPoints - 2 ) ) )
298 lineStringX.append( x );
299 lineStringY.append( y );
304 hasLongSegments |= isLongSegment;
312 output = std::make_unique< QgsLineString >( lineStringX, lineStringY );
314 if ( output->numPoints() < ( isaLinearRing ? 4 : 2 ) )
317 if ( !hasLongSegments )
321 return generalizeWkbGeometryByBoundingBox( wkbType, geometry, envelope, isaLinearRing );
328 return std::unique_ptr< QgsAbstractGeometry >( geometry.
clone() );
337 output->insertVertex(
QgsVertexId( 0, 0, output->numPoints() ),
QgsPoint( output->xAt( 0 ), output->yAt( 0 ) ) );
341 return std::move( output );
346 std::unique_ptr<QgsPolygon> polygon(
new QgsPolygon() );
348 polygon->setExteriorRing( qgsgeometry_cast<QgsCurve *>( extRing.release() ) );
353 polygon->addInteriorRing( qgsgeometry_cast<QgsCurve *>( ring.release() ) );
355 return std::move( polygon );
362 collection->reserve( numGeoms );
363 for (
int i = 0; i < numGeoms; ++i )
367 collection->addGeometry( part.release() );
369 return std::move( collection );
371 return std::unique_ptr< QgsAbstractGeometry >( geometry.
clone() );
379 return envelope.
width() < map2pixelTol && envelope.
height() < map2pixelTol;
404 if ( numPoints <= ( isaLinearRing ? 6 : 3 ) )
448 if ( numPoints <= ( isaLinearRing ? 6 : 3 ) )
Abstract base class for all geometries.
virtual QgsRectangle boundingBox() const =0
Returns the minimal bounding box for the geometry.
virtual QgsAbstractGeometry * createEmptyWithSameType() const =0
Creates a new geometry with the same class and same WKB type as the original and transfers ownership.
virtual int nCoordinates() const
Returns the number of nodes contained in the geometry.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
virtual QgsAbstractGeometry * snappedToGrid(double hSpacing, double vSpacing, double dSpacing=0, double mSpacing=0) const =0
Makes a new geometry with all the points or vertices snapped to the closest point of the grid.
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns the WKB type of the geometry.
const QgsCurve * interiorRing(int i) const SIP_HOLDGIL
Retrieves an interior ring from the curve polygon.
const QgsCurve * exteriorRing() const SIP_HOLDGIL
Returns the curve polygon's exterior ring.
int numInteriorRings() const SIP_HOLDGIL
Returns the number of interior rings contained with the curve polygon.
Abstract base class for curved geometry type.
virtual int numPoints() const =0
Returns the number of points in the curve.
virtual double xAt(int index) const =0
Returns the x-coordinate of the specified node in the line string.
virtual double yAt(int index) const =0
Returns the y-coordinate of the specified node in the line string.
int numGeometries() const SIP_HOLDGIL
Returns the number of geometries within the collection.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
QgsGeometryCollection * createEmptyWithSameType() const override
Creates a new geometry with the same class and same WKB type as the original and transfers ownership.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
double mTolerance
Distance tolerance for the simplification.
static float calculateLengthSquared2D(double x1, double y1, double x2, double y2)
Returns the squared 2D-distance of the vector defined by the two points specified.
SimplifyAlgorithm
Types of simplification algorithms that can be used.
@ Visvalingam
The simplification gives each point in a line an importance weighting, so that least important points...
@ SnapToGrid
The simplification uses a grid (similar to ST_SnapToGrid) to remove duplicate points.
@ Distance
The simplification uses the distance between points to remove duplicate points.
@ SnappedToGridGlobal
Snap to a global grid based on the tolerance. Good for consistent results for incoming vertices,...
static bool isGeneralizableByMapBoundingBox(const QgsRectangle &envelope, double map2pixelTol)
Returns whether the envelope can be replaced by its BBOX when is applied the specified map2pixel cont...
int simplifyFlags() const
Gets the simplification hints of the vector layer managed.
QgsMapToPixelSimplifier(int simplifyFlags, double tolerance, SimplifyAlgorithm simplifyAlgorithm=Distance)
Constructor.
SimplifyAlgorithm simplifyAlgorithm() const
Gets the local simplification algorithm of the vector layer managed.
@ NoFlags
No simplification can be applied.
@ SimplifyEnvelope
The geometries can be fully simplified by its BoundingBox.
@ SimplifyGeometry
The geometries can be simplified using the current map2pixel context state.
int mSimplifyFlags
Current simplification flags.
static bool equalSnapToGrid(double x1, double y1, double x2, double y2, double gridOriginX, double gridOriginY, float gridInverseSizeXY)
Returns whether the points belong to the same grid.
QgsGeometry simplify(const QgsGeometry &geometry) const override
Returns a simplified version the specified geometry.
SimplifyAlgorithm mSimplifyAlgorithm
Current algorithm.
Point geometry type, with support for z-dimension and m-values.
A rectangle specified with double values.
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
static bool isMultiType(Type type) SIP_HOLDGIL
Returns true if the WKB type is a multi type.
Type
The WKB type describes the number of dimensions a geometry has.
static Type singleType(Type type) SIP_HOLDGIL
Returns the single type for a WKB type.
static Type flatType(Type type) SIP_HOLDGIL
Returns the flat type for a WKB type.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Utility class for identifying a unique vertex within a geometry.