QgsConstWkbPtr QgsClipper::clippedLineWKB( QgsConstWkbPtr wkbPtr, const QgsRectangle& clipExtent, QPolygonF& line )
{
QgsWKBTypes::Type wkbType = wkbPtr.readHeader();
int nPoints;
wkbPtr >> nPoints;
int skipZM = ( QgsWKBTypes::coordDimensions( wkbType ) - 2 ) * sizeof( double );
if ( static_cast<int>( nPoints * ( 2 * sizeof( double ) + skipZM ) ) > wkbPtr.remaining() )
{
QgsDebugMsg( QString( "%1 points exceed wkb length (%2>%3)" ).arg( nPoints ).arg( nPoints * ( 2 * sizeof( double ) + skipZM ) ).arg( wkbPtr.remaining() ) );
return QgsConstWkbPtr( nullptr, 0 );
}
double p0x, p0y, p1x = 0.0, p1y = 0.0; //original coordinates
double p1x_c, p1y_c; //clipped end coordinates
double lastClipX = 0.0, lastClipY = 0.0; //last successfully clipped coords
line.clear();
line.reserve( nPoints + 1 );
for ( int i = 0; i < nPoints; ++i )
{
if ( i == 0 )
{
wkbPtr >> p1x >> p1y;
wkbPtr += skipZM;
continue;
}
else
{
const unsigned char* QgsSymbolV2::_getLineString( QPolygonF& pts, QgsRenderContext& context, const unsigned char* wkb, bool clipToExtent )
{
QgsConstWkbPtr wkbPtr( wkb + 1 );
unsigned int wkbType, nPoints;
wkbPtr >> wkbType >> nPoints;
bool hasZValue = QgsWKBTypes::hasZ( static_cast< QgsWKBTypes::Type >( wkbType ) );
bool hasMValue = QgsWKBTypes::hasM( static_cast< QgsWKBTypes::Type >( wkbType ) );
double x = 0.0;
double y = 0.0;
const QgsCoordinateTransform* ct = context.coordinateTransform();
const QgsMapToPixel& mtp = context.mapToPixel();
//apply clipping for large lines to achieve a better rendering performance
if ( clipToExtent && nPoints > 1 )
{
const QgsRectangle& e = context.extent();
double cw = e.width() / 10;
double ch = e.height() / 10;
QgsRectangle clipRect( e.xMinimum() - cw, e.yMinimum() - ch, e.xMaximum() + cw, e.yMaximum() + ch );
wkbPtr = QgsConstWkbPtr( QgsClipper::clippedLineWKB( wkb, clipRect, pts ) );
}
else
{
pts.resize( nPoints );
QPointF* ptr = pts.data();
for ( unsigned int i = 0; i < nPoints; ++i, ++ptr )
{
wkbPtr >> x >> y;
if ( hasZValue )
wkbPtr += sizeof( double );
if ( hasMValue )
wkbPtr += sizeof( double );
*ptr = QPointF( x, y );
}
}
//transform the QPolygonF to screen coordinates
if ( ct )
{
ct->transformPolygon( pts );
}
QPointF* ptr = pts.data();
for ( int i = 0; i < pts.size(); ++i, ++ptr )
{
mtp.transformInPlace( ptr->rx(), ptr->ry() );
}
return wkbPtr;
}
QgsConstWkbPtr QgsClipper::clippedLineWKB( QgsConstWkbPtr& wkbPtr, const QgsRectangle& clipExtent, QPolygonF& line )
{
QgsWKBTypes::Type wkbType = wkbPtr.readHeader();
int nPoints;
wkbPtr >> nPoints;
int skipZM = ( QgsWKBTypes::coordDimensions( wkbType ) - 2 ) * sizeof( double );
if ( static_cast<int>( nPoints * ( 2 * sizeof( double ) + skipZM ) ) > wkbPtr.remaining() )
{
QgsDebugMsg( QString( "%1 points exceed wkb length (%2>%3)" ).arg( nPoints ).arg( nPoints * ( 2 * sizeof( double ) + skipZM ) ).arg( wkbPtr.remaining() ) );
return QgsConstWkbPtr( nullptr, 0 );
}
double p0x, p0y, p1x = 0.0, p1y = 0.0; //original coordinates
double p1x_c, p1y_c; //clipped end coordinates
double lastClipX = 0.0, lastClipY = 0.0; //last successfully clipped coords
QPolygonF pts;
wkbPtr -= sizeof( unsigned int );
wkbPtr >> pts;
nPoints = pts.size();
line.clear();
line.reserve( nPoints + 1 );
QPointF *ptr = pts.data();
for ( int i = 0; i < nPoints; ++i, ++ptr )
{
if ( i == 0 )
{
p1x = ptr->rx();
p1y = ptr->ry();
continue;
}
else
{
p0x = p1x;
p0y = p1y;
p1x = ptr->rx();
p1y = ptr->ry();
p1x_c = p1x;
p1y_c = p1y;
if ( clipLineSegment( clipExtent.xMinimum(), clipExtent.xMaximum(), clipExtent.yMinimum(), clipExtent.yMaximum(),
p0x, p0y, p1x_c, p1y_c ) )
{
bool newLine = !line.isEmpty() && ( !qgsDoubleNear( p0x, lastClipX ) || !qgsDoubleNear( p0y, lastClipY ) );
if ( newLine )
{
//add edge points to connect old and new line
connectSeparatedLines( lastClipX, lastClipY, p0x, p0y, clipExtent, line );
}
if ( line.size() < 1 || newLine )
{
//add first point
line << QPointF( p0x, p0y );
}
//add second point
lastClipX = p1x_c;
lastClipY = p1y_c;
line << QPointF( p1x_c, p1y_c );
}
}
}
return wkbPtr;
}
QgsConstWkbPtr QgsDistanceArea::measurePolygon( QgsConstWkbPtr wkbPtr, double* area, double* perimeter, bool hasZptr ) const
{
if ( !wkbPtr )
{
QgsDebugMsg( "no feature to measure" );
return wkbPtr;
}
wkbPtr.readHeader();
// get number of rings in the polygon
int numRings;
wkbPtr >> numRings;
if ( numRings == 0 )
{
QgsDebugMsg( "no rings to measure" );
return QgsConstWkbPtr( nullptr, 0 );
}
// Set pointer to the first ring
QList<QgsPoint> points;
QgsPoint pnt;
double x, y;
if ( area )
*area = 0;
if ( perimeter )
*perimeter = 0;
try
{
for ( int idx = 0; idx < numRings; idx++ )
{
int nPoints;
wkbPtr >> nPoints;
// Extract the points from the WKB and store in a pair of
// vectors.
for ( int jdx = 0; jdx < nPoints; jdx++ )
{
wkbPtr >> x >> y;
if ( hasZptr )
{
// totally ignore Z value
wkbPtr += sizeof( double );
}
pnt = QgsPoint( x, y );
if ( mEllipsoidalMode && ( mEllipsoid != GEO_NONE ) )
{
pnt = mCoordTransform.transform( pnt );
}
points.append( pnt );
}
if ( points.size() > 2 )
{
if ( area )
{
double areaTmp = computePolygonArea( points );
if ( idx == 0 )
{
// exterior ring
*area += areaTmp;
}
else
{
*area -= areaTmp; // interior rings
}
}
if ( perimeter )
{
if ( idx == 0 )
{
// exterior ring
*perimeter += computeDistance( points );
}
}
}
points.clear();
}
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsMessageLog::logMessage( QObject::tr( "Caught a coordinate system exception while trying to transform a point. Unable to calculate polygon area or perimeter." ) );
}
return wkbPtr;
}
void QgsFeatureRendererV2::renderFeatureWithSymbol( QgsFeature& feature, QgsSymbolV2* symbol, QgsRenderContext& context, int layer, bool selected, bool drawVertexMarker )
{
QgsSymbolV2::SymbolType symbolType = symbol->type();
const QgsGeometry* geom = feature.constGeometry();
if ( !geom || !geom->geometry() )
{
return;
}
const QgsGeometry* segmentizedGeometry = geom;
bool deleteSegmentizedGeometry = false;
context.setGeometry( geom->geometry() );
//convert curve types to normal point/line/polygon ones
switch ( QgsWKBTypes::flatType( geom->geometry()->wkbType() ) )
{
case QgsWKBTypes::CurvePolygon:
case QgsWKBTypes::CircularString:
case QgsWKBTypes::CompoundCurve:
case QgsWKBTypes::MultiSurface:
case QgsWKBTypes::MultiCurve:
{
QgsAbstractGeometryV2* g = geom->geometry()->segmentize();
if ( !g )
{
return;
}
segmentizedGeometry = new QgsGeometry( g );
deleteSegmentizedGeometry = true;
break;
}
default:
break;
}
switch ( QgsWKBTypes::flatType( segmentizedGeometry->geometry()->wkbType() ) )
{
case QgsWKBTypes::Point:
{
if ( symbolType != QgsSymbolV2::Marker )
{
QgsDebugMsg( "point can be drawn only with marker symbol!" );
break;
}
QPointF pt;
_getPoint( pt, context, segmentizedGeometry->asWkb() );
(( QgsMarkerSymbolV2* )symbol )->renderPoint( pt, &feature, context, layer, selected );
if ( context.testFlag( QgsRenderContext::DrawSymbolBounds ) )
{
//draw debugging rect
context.painter()->setPen( Qt::red );
context.painter()->setBrush( QColor( 255, 0, 0, 100 ) );
context.painter()->drawRect((( QgsMarkerSymbolV2* )symbol )->bounds( pt, context ) );
}
}
break;
case QgsWKBTypes::LineString:
{
if ( symbolType != QgsSymbolV2::Line )
{
QgsDebugMsg( "linestring can be drawn only with line symbol!" );
break;
}
QPolygonF pts;
_getLineString( pts, context, segmentizedGeometry->asWkb(), symbol->clipFeaturesToExtent() );
(( QgsLineSymbolV2* )symbol )->renderPolyline( pts, &feature, context, layer, selected );
}
break;
case QgsWKBTypes::Polygon:
{
if ( symbolType != QgsSymbolV2::Fill )
{
QgsDebugMsg( "polygon can be drawn only with fill symbol!" );
break;
}
QPolygonF pts;
QList<QPolygonF> holes;
_getPolygon( pts, holes, context, segmentizedGeometry->asWkb(), symbol->clipFeaturesToExtent() );
(( QgsFillSymbolV2* )symbol )->renderPolygon( pts, ( holes.count() ? &holes : NULL ), &feature, context, layer, selected );
}
break;
case QgsWKBTypes::MultiPoint:
{
if ( symbolType != QgsSymbolV2::Marker )
{
QgsDebugMsg( "multi-point can be drawn only with marker symbol!" );
break;
}
QgsConstWkbPtr wkbPtr( segmentizedGeometry->asWkb() + 1 + sizeof( int ) );
unsigned int num;
wkbPtr >> num;
const unsigned char* ptr = wkbPtr;
QPointF pt;
for ( unsigned int i = 0; i < num; ++i )
{
ptr = QgsConstWkbPtr( _getPoint( pt, context, ptr ) );
(( QgsMarkerSymbolV2* )symbol )->renderPoint( pt, &feature, context, layer, selected );
}
}
break;
case QgsWKBTypes::MultiCurve:
case QgsWKBTypes::MultiLineString:
{
if ( symbolType != QgsSymbolV2::Line )
{
QgsDebugMsg( "multi-linestring can be drawn only with line symbol!" );
break;
}
QgsConstWkbPtr wkbPtr( segmentizedGeometry->asWkb() + 1 + sizeof( int ) );
unsigned int num;
wkbPtr >> num;
const unsigned char* ptr = wkbPtr;
QPolygonF pts;
const QgsGeometryCollectionV2* geomCollection = dynamic_cast<const QgsGeometryCollectionV2*>( geom->geometry() );
for ( unsigned int i = 0; i < num; ++i )
{
if ( geomCollection )
{
context.setGeometry( geomCollection->geometryN( i ) );
}
ptr = QgsConstWkbPtr( _getLineString( pts, context, ptr, symbol->clipFeaturesToExtent() ) );
(( QgsLineSymbolV2* )symbol )->renderPolyline( pts, &feature, context, layer, selected );
}
}
break;
case QgsWKBTypes::MultiSurface:
case QgsWKBTypes::MultiPolygon:
{
if ( symbolType != QgsSymbolV2::Fill )
{
QgsDebugMsg( "multi-polygon can be drawn only with fill symbol!" );
break;
}
QgsConstWkbPtr wkbPtr( segmentizedGeometry->asWkb() + 1 + sizeof( int ) );
unsigned int num;
wkbPtr >> num;
const unsigned char* ptr = wkbPtr;
QPolygonF pts;
QList<QPolygonF> holes;
const QgsGeometryCollectionV2* geomCollection = dynamic_cast<const QgsGeometryCollectionV2*>( geom->geometry() );
for ( unsigned int i = 0; i < num; ++i )
{
if ( geomCollection )
{
context.setGeometry( geomCollection->geometryN( i ) );
}
ptr = _getPolygon( pts, holes, context, ptr, symbol->clipFeaturesToExtent() );
(( QgsFillSymbolV2* )symbol )->renderPolygon( pts, ( holes.count() ? &holes : NULL ), &feature, context, layer, selected );
}
break;
}
default:
QgsDebugMsg( QString( "feature %1: unsupported wkb type 0x%2 for rendering" ).arg( feature.id() ).arg( geom->wkbType(), 0, 16 ) );
}
if ( drawVertexMarker )
{
const QgsCoordinateTransform* ct = context.coordinateTransform();
const QgsMapToPixel& mtp = context.mapToPixel();
QgsPointV2 vertexPoint;
QgsVertexId vertexId;
double x, y, z;
QPointF mapPoint;
while ( geom->geometry()->nextVertex( vertexId, vertexPoint ) )
{
//transform
x = vertexPoint.x(); y = vertexPoint.y(); z = vertexPoint.z();
if ( ct )
{
ct->transformInPlace( x, y, z );
}
mapPoint.setX( x ); mapPoint.setY( y );
mtp.transformInPlace( mapPoint.rx(), mapPoint.ry() );
renderVertexMarker( mapPoint, context );
}
}
if ( deleteSegmentizedGeometry )
{
delete segmentizedGeometry;
}
}
void QgsPointDisplacementRenderer::drawGroup( const DisplacementGroup& group, QgsRenderContext& context )
{
const QgsFeature& feature = group.begin().value().first;
bool selected = mSelectedFeatures.contains( feature.id() ); // maybe we should highlight individual features instead of the whole group?
//get list of labels and symbols
QStringList labelAttributeList;
QList<QgsMarkerSymbolV2*> symbolList;
QgsMultiPointV2* groupMultiPoint = new QgsMultiPointV2();
for ( DisplacementGroup::const_iterator attIt = group.constBegin(); attIt != group.constEnd(); ++attIt )
{
labelAttributeList << ( mDrawLabels ? getLabel( attIt.value().first ) : QString() );
symbolList << dynamic_cast<QgsMarkerSymbolV2*>( attIt.value().second );
groupMultiPoint->addGeometry( attIt.value().first.constGeometry()->geometry()->clone() );
}
//calculate centroid of all points, this will be center of group
QgsGeometry groupGeom( groupMultiPoint );
QgsGeometry* centroid = groupGeom.centroid();
QPointF pt;
_getPoint( pt, context, QgsConstWkbPtr( centroid->asWkb(), centroid->wkbSize() ) );
delete centroid;
//calculate max diagonal size from all symbols in group
double diagonal = 0;
Q_FOREACH ( QgsMarkerSymbolV2* symbol, symbolList )
{
if ( symbol )
{
diagonal = qMax( diagonal, QgsSymbolLayerV2Utils::convertToPainterUnits( context,
M_SQRT2 * symbol->size(),
symbol->outputUnit(), symbol->mapUnitScale() ) );
}
}
QgsSymbolV2RenderContext symbolContext( context, QgsSymbolV2::MM, 1.0, selected );
QList<QPointF> symbolPositions;
QList<QPointF> labelPositions;
double circleRadius = -1.0;
calculateSymbolAndLabelPositions( symbolContext, pt, symbolList.size(), diagonal, symbolPositions, labelPositions, circleRadius );
//draw Circle
if ( circleRadius > 0 )
drawCircle( circleRadius, symbolContext, pt, symbolList.size() );
//draw mid point
if ( labelAttributeList.size() > 1 )
{
if ( mCenterSymbol )
{
mCenterSymbol->renderPoint( pt, &feature, context, -1, selected );
}
else
{
context.painter()->drawRect( QRectF( pt.x() - symbolContext.outputLineWidth( 1 ), pt.y() - symbolContext.outputLineWidth( 1 ), symbolContext.outputLineWidth( 2 ), symbolContext.outputLineWidth( 2 ) ) );
}
}
//draw symbols on the circle
drawSymbols( feature, context, symbolList, symbolPositions, selected );
//and also the labels
drawLabels( pt, symbolContext, labelPositions, labelAttributeList );
}
