void QgsMarkerLineSymbolLayerV2::renderOffsetVertexAlongLine( const QPolygonF &points, int vertex, double distance, QgsSymbolV2RenderContext& context )
{
if ( points.isEmpty() )
return;
QgsRenderContext& rc = context.renderContext();
double origAngle = mMarker->angle();
if ( distance == 0 )
{
// rotate marker (if desired)
if ( mRotateMarker )
{
bool isRing = false;
if ( points.first() == points.last() )
isRing = true;
double angle = markerAngle( points, isRing, vertex );
mMarker->setAngle( origAngle + angle * 180 / M_PI );
}
mMarker->renderPoint( points[vertex], context.feature(), rc, -1, context.selected() );
return;
}
int pointIncrement = distance > 0 ? 1 : -1;
QPointF previousPoint = points[vertex];
int startPoint = distance > 0 ? qMin( vertex + 1, points.count() - 1 ) : qMax( vertex - 1, 0 );
int endPoint = distance > 0 ? points.count() - 1 : 0;
double distanceLeft = qAbs( distance );
for ( int i = startPoint; pointIncrement > 0 ? i <= endPoint : i >= endPoint; i += pointIncrement )
{
const QPointF& pt = points[i];
if ( previousPoint == pt ) // must not be equal!
continue;
// create line segment
MyLine l( previousPoint, pt );
if ( distanceLeft < l.length() )
{
//destination point is in current segment
QPointF markerPoint = previousPoint + l.diffForInterval( distanceLeft );
// rotate marker (if desired)
if ( mRotateMarker )
{
mMarker->setAngle( origAngle + ( l.angle() * 180 / M_PI ) );
}
mMarker->renderPoint( markerPoint, context.feature(), rc, -1, context.selected() );
return;
}
distanceLeft -= l.length();
previousPoint = pt;
}
//didn't find point
return;
}
void QgsLineDecorationSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
// draw arrow at the end of line
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
int cnt = points.count();
QPointF p2 = points.at( --cnt );
QPointF p1 = points.at( --cnt );
while ( p2 == p1 && cnt )
p1 = points.at( --cnt );
if ( p1 == p2 ) {
// this is a collapsed line... don't bother drawing an arrow
// with arbitrary orientation
return;
}
double angle = atan2( p2.y() - p1.y(), p2.x() - p1.x() );
double size = context.outputLineWidth( mWidth * 8 );
double angle1 = angle + M_PI / 6;
double angle2 = angle - M_PI / 6;
QPointF p2_1 = p2 - QPointF( size * cos( angle1 ), size * sin( angle1 ) );
QPointF p2_2 = p2 - QPointF( size * cos( angle2 ), size * sin( angle2 ) );
p->setPen( context.selected() ? mSelPen : mPen );
p->drawLine( p2, p2_1 );
p->drawLine( p2, p2_2 );
}
void QgsSimpleLineSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
double offset = 0.0;
applyDataDefinedSymbology( context, mPen, mSelPen, offset );
p->setPen( context.selected() ? mSelPen : mPen );
// Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #2 points).
#if 0 // TODO[MD]: after merge
if ( points.size() <= 2 && context.layer() && context.layer()->simplifyDrawingCanbeApplied( context.renderContext(), QgsVectorSimplifyMethod::AntialiasingSimplification ) && QgsAbstractGeometrySimplifier::canbeGeneralizedByDeviceBoundingBox( points, context.layer()->simplifyMethod().threshold() ) && ( p->renderHints() & QPainter::Antialiasing ) )
{
p->setRenderHint( QPainter::Antialiasing, false );
p->drawPolyline( points );
p->setRenderHint( QPainter::Antialiasing, true );
return;
}
#endif
if ( offset == 0 )
{
p->drawPolyline( points );
}
else
{
double scaledOffset = offset * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOffsetUnit );
p->drawPolyline( ::offsetLine( points, scaledOffset ) );
}
}
void QgsFontMarkerSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context )
{
QPainter *p = context.renderContext().painter();
if ( !p )
return;
QColor penColor = context.selected() ? context.renderContext().selectionColor() : mColor;
penColor.setAlphaF( mColor.alphaF() * context.alpha() );
p->setPen( penColor );
p->setFont( mFont );
p->save();
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( context, offsetX, offsetY );
QPointF outputOffset( offsetX, offsetY );
if ( mAngle )
outputOffset = _rotatedOffset( outputOffset, mAngle );
p->translate( point + outputOffset );
if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale )
{
double s = mSize / mOrigSize;
p->scale( s, s );
}
if ( mAngle != 0 )
p->rotate( mAngle );
p->drawText( -mChrOffset, mChr );
p->restore();
}
void QgsSimpleLineSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale )
{
double scaledWidth = context.outputLineWidth( mWidth );
mPen.setWidthF( scaledWidth );
mSelPen.setWidthF( scaledWidth );
}
p->setPen( context.selected() ? mSelPen : mPen );
if ( mOffset == 0 )
{
p->drawPolyline( points );
}
else
{
double scaledOffset = context.outputLineWidth( mOffset );
p->drawPolyline( ::offsetLine( points, scaledOffset ) );
}
}
void QgsSimpleFillSymbolLayerV2::renderPolygon( const QPolygonF& points, QList<QPolygonF>* rings, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
p->setBrush( context.selected() ? mSelBrush : mBrush );
p->setPen( mPen );
p->setPen( context.selected() ? mSelPen : mPen );
if ( !mOffset.isNull() )
p->translate( mOffset );
_renderPolygon( p, points, rings );
if ( !mOffset.isNull() )
p->translate( -mOffset );
}
void QgsMarkerLineSymbolLayerV2::renderPolylineVertex( const QPolygonF& points, QgsSymbolV2RenderContext& context, Placement placement )
{
if ( points.isEmpty() )
return;
QgsRenderContext& rc = context.renderContext();
double origAngle = mMarker->angle();
int i, maxCount;
bool isRing = false;
if ( placement == FirstVertex )
{
i = 0;
maxCount = 1;
}
else if ( placement == LastVertex )
{
i = points.count() - 1;
maxCount = points.count();
}
else
{
i = 0;
maxCount = points.count();
if ( points.first() == points.last() )
isRing = true;
}
for ( ; i < maxCount; ++i )
{
if ( isRing && placement == Vertex && i == points.count() - 1 )
{
continue; // don't draw the last marker - it has been drawn already
}
// rotate marker (if desired)
if ( mRotateMarker )
{
double angle = markerAngle( points, isRing, i );
mMarker->setAngle( origAngle + angle * 180 / M_PI );
}
mMarker->renderPoint( points.at( i ), context.feature(), rc, -1, context.selected() );
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsMarkerLineSymbolLayerV2::renderPolylineCentral( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
if ( points.size() > 0 )
{
// calc length
qreal length = 0;
QPolygonF::const_iterator it = points.constBegin();
QPointF last = *it;
for ( ++it; it != points.constEnd(); ++it )
{
length += sqrt(( last.x() - it->x() ) * ( last.x() - it->x() ) +
( last.y() - it->y() ) * ( last.y() - it->y() ) );
last = *it;
}
// find the segment where the central point lies
it = points.constBegin();
last = *it;
qreal last_at = 0, next_at = 0;
QPointF next;
int segment = 0;
for ( ++it; it != points.constEnd(); ++it )
{
next = *it;
next_at += sqrt(( last.x() - it->x() ) * ( last.x() - it->x() ) +
( last.y() - it->y() ) * ( last.y() - it->y() ) );
if ( next_at >= length / 2 )
break; // we have reached the center
last = *it;
last_at = next_at;
segment++;
}
// find out the central point on segment
MyLine l( last, next ); // for line angle
qreal k = ( length * 0.5 - last_at ) / ( next_at - last_at );
QPointF pt = last + ( next - last ) * k;
// draw the marker
double origAngle = mMarker->angle();
if ( mRotateMarker )
mMarker->setAngle( origAngle + l.angle() * 180 / M_PI );
mMarker->renderPoint( pt, context.feature(), context.renderContext(), -1, context.selected() );
if ( mRotateMarker )
mMarker->setAngle( origAngle );
}
}
void QgsSimpleLineSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
double offset = 0.0;
applyDataDefinedSymbology( context, mPen, mSelPen, offset );
p->setPen( context.selected() ? mSelPen : mPen );
// Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #2 points).
if ( points.size() <= 2 && context.layer() && context.layer()->simplifyDrawingCanbeApplied( context.renderContext(), QgsVectorLayer::AntialiasingSimplification ) && QgsAbstractGeometrySimplifier::canbeGeneralizedByDeviceBoundingBox( points, context.layer()->simplifyMethod().threshold() ) && ( p->renderHints() & QPainter::Antialiasing ) )
{
p->setRenderHint( QPainter::Antialiasing, false );
p->drawPolyline( points );
p->setRenderHint( QPainter::Antialiasing, true );
return;
}
if ( mDrawInsidePolygon )
{
//only drawing the line on the interior of the polygon, so set clip path for painter
p->save();
QPainterPath clipPath;
clipPath.addPolygon( points );
p->setClipPath( clipPath, Qt::IntersectClip );
}
if ( offset == 0 )
{
p->drawPolyline( points );
}
else
{
double scaledOffset = offset * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOffsetUnit );
p->drawPolyline( ::offsetLine( points, scaledOffset ) );
}
if ( mDrawInsidePolygon )
{
//restore painter to reset clip path
p->restore();
}
}
void QgsImageFillSymbolLayer::renderPolygon( const QPolygonF& points, QList<QPolygonF>* rings, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
p->setPen( QPen( Qt::NoPen ) );
if ( context.selected() )
{
QColor selColor = context.selectionColor();
// Alister - this doesn't seem to work here
//if ( ! selectionIsOpaque )
// selColor.setAlphaF( context.alpha() );
p->setBrush( QBrush( selColor ) );
_renderPolygon( p, points, rings );
}
if ( doubleNear( mAngle, 0.0 ) )
{
p->setBrush( mBrush );
}
else
{
QTransform t = mBrush.transform();
t.rotate( mAngle );
QBrush rotatedBrush = mBrush;
rotatedBrush.setTransform( t );
p->setBrush( rotatedBrush );
}
_renderPolygon( p, points, rings );
if ( mOutline )
{
mOutline->renderPolyline( points, context.feature(), context.renderContext(), -1, selectFillBorder && context.selected() );
if ( rings )
{
QList<QPolygonF>::const_iterator ringIt = rings->constBegin();
for ( ; ringIt != rings->constEnd(); ++ringIt )
{
mOutline->renderPolyline( *ringIt, context.feature(), context.renderContext(), -1, selectFillBorder && context.selected() );
}
}
}
}
void QgsSimpleLineSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
//size scaling by field
if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale )
{
applySizeScale( context, mPen, mSelPen );
}
double offset = mOffset;
applyDataDefinedSymbology( context, mPen, mSelPen, offset );
p->setPen( context.selected() ? mSelPen : mPen );
// Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #2 points).
if ( points.size() <= 2 &&
( context.renderContext().vectorSimplifyMethod().simplifyHints() & QgsVectorSimplifyMethod::AntialiasingSimplification ) &&
QgsAbstractGeometrySimplifier::isGeneralizableByDeviceBoundingBox( points, context.renderContext().vectorSimplifyMethod().threshold() ) &&
( p->renderHints() & QPainter::Antialiasing ) )
{
p->setRenderHint( QPainter::Antialiasing, false );
p->drawPolyline( points );
p->setRenderHint( QPainter::Antialiasing, true );
return;
}
if ( qgsDoubleNear( offset, 0 ) )
{
p->drawPolyline( points );
}
else
{
double scaledOffset = QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), offset, mOffsetUnit, mOffsetMapUnitScale );
QList<QPolygonF> mline = ::offsetLine( points, scaledOffset, context.feature() ? context.feature()->constGeometry()->type() : QGis::Line );
for ( int part = 0; part < mline.count(); ++part )
p->drawPolyline( mline[ part ] );
}
}
void QgsSimpleLineSymbolLayerV2::renderPolyline( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
double offset = 0.0;
applyDataDefinedSymbology( context, mPen, mSelPen, offset );
p->setPen( context.selected() ? mSelPen : mPen );
if ( offset == 0 )
{
p->drawPolyline( points );
}
else
{
double scaledOffset = offset * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOffsetUnit );
p->drawPolyline( ::offsetLine( points, scaledOffset ) );
}
}
void QgsSimpleMarkerSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context )
{
QPainter *p = context.renderContext().painter();
if ( !p )
{
return;
}
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( context, offsetX, offsetY );
QPointF off( offsetX, offsetY );
//angle
double angle = mAngle;
if ( mAngleExpression )
{
angle = mAngleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
if ( angle )
off = _rotatedOffset( off, angle );
//data defined shape?
if ( mNameExpression )
{
QString name = mNameExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
if ( !prepareShape( name ) ) // drawing as a polygon
{
preparePath( name ); // drawing as a painter path
}
}
if ( mUsingCache )
{
// we will use cached image
QImage &img = context.selected() ? mSelCache : mCache;
double s = img.width() / context.renderContext().rasterScaleFactor();
p->drawImage( QRectF( point.x() - s / 2.0 + off.x(),
point.y() - s / 2.0 + off.y(),
s, s ), img );
}
else
{
QMatrix transform;
// move to the desired position
transform.translate( point.x() + off.x(), point.y() + off.y() );
QgsExpression *sizeExpression = expression( "size" );
bool hasDataDefinedSize = context.renderHints() & QgsSymbolV2::DataDefinedSizeScale || sizeExpression;
// resize if necessary
if ( hasDataDefinedSize )
{
double scaledSize = mSize;
if ( sizeExpression )
{
scaledSize = sizeExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
scaledSize *= QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mSizeUnit );
switch ( mScaleMethod )
{
case QgsSymbolV2::ScaleArea:
scaledSize = sqrt( scaledSize );
break;
case QgsSymbolV2::ScaleDiameter:
break;
}
double half = scaledSize / 2.0;
transform.scale( half, half );
}
bool hasDataDefinedRotation = context.renderHints() & QgsSymbolV2::DataDefinedRotation || mAngleExpression;
if ( angle != 0 && hasDataDefinedRotation )
transform.rotate( angle );
QgsExpression* colorExpression = expression( "color" );
QgsExpression* colorBorderExpression = expression( "color_border" );
QgsExpression* outlineWidthExpression = expression( "outline_width" );
if ( colorExpression )
{
mBrush.setColor( QgsSymbolLayerV2Utils::decodeColor( colorExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() ) );
}
if ( colorBorderExpression )
{
mPen.setColor( QgsSymbolLayerV2Utils::decodeColor( colorBorderExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() ) );
mSelPen.setColor( QgsSymbolLayerV2Utils::decodeColor( colorBorderExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() ) );
}
if ( outlineWidthExpression )
{
double outlineWidth = outlineWidthExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
mPen.setWidthF( outlineWidth * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOutlineWidthUnit ) );
mSelPen.setWidthF( outlineWidth * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mOutlineWidthUnit ) );
}
p->setBrush( context.selected() ? mSelBrush : mBrush );
p->setPen( context.selected() ? mSelPen : mPen );
if ( !mPolygon.isEmpty() )
p->drawPolygon( transform.map( mPolygon ) );
else
p->drawPath( transform.map( mPath ) );
}
}
void QgsMarkerLineSymbolLayerV2::renderPolylineVertex( const QPolygonF& points, QgsSymbolV2RenderContext& context, Placement placement )
{
if ( points.isEmpty() )
return;
QgsRenderContext& rc = context.renderContext();
double origAngle = mMarker->angle();
double angle;
int i, maxCount;
bool isRing = false;
if ( placement == FirstVertex )
{
i = 0;
maxCount = 1;
}
else if ( placement == LastVertex )
{
i = points.count() - 1;
maxCount = points.count();
}
else
{
i = 0;
maxCount = points.count();
if ( points.first() == points.last() )
isRing = true;
}
for ( ; i < maxCount; ++i )
{
const QPointF& pt = points[i];
// rotate marker (if desired)
if ( mRotateMarker )
{
if ( i == 0 )
{
if ( !isRing )
{
// use first segment's angle
const QPointF& nextPt = points[i+1];
if ( pt == nextPt )
continue;
angle = MyLine( pt, nextPt ).angle();
}
else
{
// closed ring: use average angle between first and last segment
const QPointF& prevPt = points[points.count() - 2];
const QPointF& nextPt = points[1];
if ( prevPt == pt || nextPt == pt )
continue;
angle = _averageAngle( prevPt, pt, nextPt );
}
}
else if ( i == points.count() - 1 )
{
if ( !isRing )
{
// use last segment's angle
const QPointF& prevPt = points[i-1];
if ( pt == prevPt )
continue;
angle = MyLine( prevPt, pt ).angle();
}
else
{
// don't draw the last marker - it has been drawn already
continue;
}
}
else
{
// use average angle
const QPointF& prevPt = points[i-1];
const QPointF& nextPt = points[i+1];
if ( prevPt == pt || nextPt == pt )
continue;
angle = _averageAngle( prevPt, pt, nextPt );
}
mMarker->setAngle( origAngle + angle * 180 / M_PI );
}
mMarker->renderPoint( points.at( i ), context.feature(), rc, -1, context.selected() );
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsCentroidFillSymbolLayerV2::renderPolygon( const QPolygonF& points, QList<QPolygonF>* rings, QgsSymbolV2RenderContext& context )
{
Q_UNUSED( rings );
// calculate centroid
double cx = 0, cy = 0;
double area, sum = 0;
for ( int i = points.count() - 1, j = 0; j < points.count(); i = j++ )
{
const QPointF& p1 = points[i];
const QPointF& p2 = points[j];
area = p1.x() * p2.y() - p1.y() * p2.x();
sum += area;
cx += ( p1.x() + p2.x() ) * area;
cy += ( p1.y() + p2.y() ) * area;
}
sum *= 3.0;
cx /= sum;
cy /= sum;
mMarker->renderPoint( QPointF( cx, cy ), context.feature(), context.renderContext(), -1, context.selected() );
}
void QgsSvgMarkerSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context )
{
QPainter *p = context.renderContext().painter();
if ( !p )
return;
double size = mSize;
QgsExpression* sizeExpression = expression( "size" );
bool hasDataDefinedSize = context.renderHints() & QgsSymbolV2::DataDefinedSizeScale || sizeExpression;
if ( sizeExpression )
{
size = sizeExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
size *= QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mSizeUnit );
if ( hasDataDefinedSize )
{
switch ( mScaleMethod )
{
case QgsSymbolV2::ScaleArea:
size = sqrt( size );
break;
case QgsSymbolV2::ScaleDiameter:
break;
}
}
//don't render symbols with size below one or above 10,000 pixels
if (( int )size < 1 || 10000.0 < size )
{
return;
}
p->save();
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( context, offsetX, offsetY );
QPointF outputOffset( offsetX, offsetY );
double angle = mAngle;
QgsExpression* angleExpression = expression( "angle" );
if ( angleExpression )
{
angle = angleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
if ( angle )
outputOffset = _rotatedOffset( outputOffset, angle );
p->translate( point + outputOffset );
bool rotated = !qgsDoubleNear( angle, 0 );
bool drawOnScreen = qgsDoubleNear( context.renderContext().rasterScaleFactor(), 1.0, 0.1 );
if ( rotated )
p->rotate( angle );
QString path = mPath;
QgsExpression* nameExpression = expression( "name" );
if ( nameExpression )
{
path = nameExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
}
double outlineWidth = mOutlineWidth;
QgsExpression* outlineWidthExpression = expression( "outline_width" );
if ( outlineWidthExpression )
{
outlineWidth = outlineWidthExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
QColor fillColor = mFillColor;
QgsExpression* fillExpression = expression( "fill" );
if ( fillExpression )
{
fillColor = QgsSymbolLayerV2Utils::decodeColor( fillExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() );
}
QColor outlineColor = mOutlineColor;
QgsExpression* outlineExpression = expression( "outline" );
if ( outlineExpression )
{
outlineColor = QgsSymbolLayerV2Utils::decodeColor( outlineExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() );
}
bool fitsInCache = true;
bool usePict = true;
double hwRatio = 1.0;
if ( drawOnScreen && !rotated )
{
usePict = false;
const QImage& img = QgsSvgCache::instance()->svgAsImage( path, size, fillColor, outlineColor, outlineWidth,
context.renderContext().scaleFactor(), context.renderContext().rasterScaleFactor(), fitsInCache );
if ( fitsInCache && img.width() > 1 )
{
//consider transparency
if ( !qgsDoubleNear( context.alpha(), 1.0 ) )
{
QImage transparentImage = img.copy();
QgsSymbolLayerV2Utils::multiplyImageOpacity( &transparentImage, context.alpha() );
p->drawImage( -transparentImage.width() / 2.0, -transparentImage.height() / 2.0, transparentImage );
hwRatio = ( double )transparentImage.height() / ( double )transparentImage.width();
}
else
{
p->drawImage( -img.width() / 2.0, -img.height() / 2.0, img );
hwRatio = ( double )img.height() / ( double )img.width();
}
}
}
if ( usePict || !fitsInCache )
{
p->setOpacity( context.alpha() );
const QPicture& pct = QgsSvgCache::instance()->svgAsPicture( path, size, fillColor, outlineColor, outlineWidth,
context.renderContext().scaleFactor(), context.renderContext().rasterScaleFactor(), context.renderContext().forceVectorOutput() );
if ( pct.width() > 1 )
{
p->drawPicture( 0, 0, pct );
hwRatio = ( double )pct.height() / ( double )pct.width();
}
}
if ( context.selected() )
{
QPen pen( context.renderContext().selectionColor() );
double penWidth = QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), QgsSymbolV2::MM );
if ( penWidth > size / 20 )
{
// keep the pen width from covering symbol
penWidth = size / 20;
}
double penOffset = penWidth / 2;
pen.setWidth( penWidth );
p->setPen( pen );
p->setBrush( Qt::NoBrush );
double wSize = size + penOffset;
double hSize = size * hwRatio + penOffset;
p->drawRect( QRectF( -wSize / 2.0, -hSize / 2.0, wSize, hSize ) );
}
p->restore();
}
void QgsMarkerLineSymbolLayerV2::renderPolylineVertex( const QPolygonF& points, QgsSymbolV2RenderContext& context, Placement placement )
{
if ( points.isEmpty() )
return;
QgsRenderContext& rc = context.renderContext();
double origAngle = mMarker->angle();
int i, maxCount;
bool isRing = false;
double offsetAlongLine = mOffsetAlongLine;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_OFFSET_ALONG_LINE ) )
{
context.setOriginalValueVariable( mOffsetAlongLine );
offsetAlongLine = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OFFSET_ALONG_LINE, context, mOffsetAlongLine ).toDouble();
}
if ( offsetAlongLine != 0 )
{
//scale offset along line
offsetAlongLine = QgsSymbolLayerV2Utils::convertToPainterUnits( rc, offsetAlongLine, mOffsetAlongLineUnit, mOffsetAlongLineMapUnitScale );
}
if ( offsetAlongLine == 0 && context.renderContext().geometry()
&& context.renderContext().geometry()->hasCurvedSegments() && ( placement == Vertex || placement == CurvePoint ) )
{
const QgsCoordinateTransform* ct = context.renderContext().coordinateTransform();
const QgsMapToPixel& mtp = context.renderContext().mapToPixel();
QgsVertexId vId;
QgsPointV2 vPoint;
double x, y, z;
QPointF mapPoint;
while ( context.renderContext().geometry()->nextVertex( vId, vPoint ) )
{
if (( placement == Vertex && vId.type == QgsVertexId::SegmentVertex )
|| ( placement == CurvePoint && vId.type == QgsVertexId::CurveVertex ) )
{
//transform
x = vPoint.x(), y = vPoint.y(); z = vPoint.z();
if ( ct )
{
ct->transformInPlace( x, y, z );
}
mapPoint.setX( x ); mapPoint.setY( y );
mtp.transformInPlace( mapPoint.rx(), mapPoint.ry() );
if ( mRotateMarker )
{
double angle = context.renderContext().geometry()->vertexAngle( vId );
mMarker->setAngle( angle * 180 / M_PI );
}
mMarker->renderPoint( mapPoint, context.feature(), rc, -1, context.selected() );
}
}
return;
}
if ( placement == FirstVertex )
{
i = 0;
maxCount = 1;
}
else if ( placement == LastVertex )
{
i = points.count() - 1;
maxCount = points.count();
}
else if ( placement == Vertex )
{
i = 0;
maxCount = points.count();
if ( points.first() == points.last() )
isRing = true;
}
else
{
return;
}
if ( offsetAlongLine > 0 && ( placement == FirstVertex || placement == LastVertex ) )
{
double distance;
distance = placement == FirstVertex ? offsetAlongLine : -offsetAlongLine;
renderOffsetVertexAlongLine( points, i, distance, context );
// restore original rotation
mMarker->setAngle( origAngle );
return;
}
for ( ; i < maxCount; ++i )
{
if ( isRing && placement == Vertex && i == points.count() - 1 )
{
continue; // don't draw the last marker - it has been drawn already
}
// rotate marker (if desired)
if ( mRotateMarker )
{
double angle = markerAngle( points, isRing, i );
mMarker->setAngle( origAngle + angle * 180 / M_PI );
}
mMarker->renderPoint( points.at( i ), context.feature(), rc, -1, context.selected() );
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsMarkerLineSymbolLayerV2::renderPolylineInterval( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
if ( points.isEmpty() )
return;
QPointF lastPt = points[0];
double lengthLeft = 0; // how much is left until next marker
bool first = mOffsetAlongLine ? false : true; //only draw marker at first vertex when no offset along line is set
QgsRenderContext& rc = context.renderContext();
double interval = mInterval;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_INTERVAL ) )
{
context.setOriginalValueVariable( mInterval );
interval = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_INTERVAL, context, mInterval ).toDouble();
}
if ( interval <= 0 )
{
interval = 0.1;
}
double offsetAlongLine = mOffsetAlongLine;
if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_OFFSET_ALONG_LINE ) )
{
context.setOriginalValueVariable( mOffsetAlongLine );
offsetAlongLine = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OFFSET_ALONG_LINE, context, mOffsetAlongLine ).toDouble();
}
double painterUnitInterval = QgsSymbolLayerV2Utils::convertToPainterUnits( rc, interval, mIntervalUnit, mIntervalMapUnitScale );
lengthLeft = painterUnitInterval - QgsSymbolLayerV2Utils::convertToPainterUnits( rc, offsetAlongLine, mIntervalUnit, mIntervalMapUnitScale );
for ( int i = 1; i < points.count(); ++i )
{
const QPointF& pt = points[i];
if ( lastPt == pt ) // must not be equal!
continue;
// for each line, find out dx and dy, and length
MyLine l( lastPt, pt );
QPointF diff = l.diffForInterval( painterUnitInterval );
// if there's some length left from previous line
// use only the rest for the first point in new line segment
double c = 1 - lengthLeft / painterUnitInterval;
lengthLeft += l.length();
// rotate marker (if desired)
if ( mRotateMarker )
{
mMarker->setLineAngle( l.angle() * 180 / M_PI );
}
// draw first marker
if ( first )
{
mMarker->renderPoint( lastPt, context.feature(), rc, -1, context.selected() );
first = false;
}
// while we're not at the end of line segment, draw!
while ( lengthLeft > painterUnitInterval )
{
// "c" is 1 for regular point or in interval (0,1] for begin of line segment
lastPt += c * diff;
lengthLeft -= painterUnitInterval;
mMarker->renderPoint( lastPt, context.feature(), rc, -1, context.selected() );
c = 1; // reset c (if wasn't 1 already)
}
lastPt = pt;
}
}
void QgsSvgMarkerSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context )
{
QPainter* p = context.renderContext().painter();
if ( !p )
{
return;
}
double size = context.outputLineWidth( mSize );
//don't render symbols with size below one or above 10,000 pixels
if (( int )size < 1 || 10000.0 < size )
{
return;
}
p->save();
QPointF outputOffset = QPointF( context.outputLineWidth( mOffset.x() ), context.outputLineWidth( mOffset.y() ) );
if ( mAngle )
outputOffset = _rotatedOffset( outputOffset, mAngle );
p->translate( point + outputOffset );
bool rotated = !doubleNear( mAngle, 0 );
bool drawOnScreen = doubleNear( context.renderContext().rasterScaleFactor(), 1.0, 0.1 );
if ( rotated )
p->rotate( mAngle );
bool fitsInCache = true;
bool usePict = true;
double hwRatio = 1.0;
if ( drawOnScreen && !rotated )
{
usePict = false;
const QImage& img = QgsSvgCache::instance()->svgAsImage( mPath, size, mFillColor, mOutlineColor, mOutlineWidth,
context.renderContext().scaleFactor(), context.renderContext().rasterScaleFactor(), fitsInCache );
if ( fitsInCache && img.width() > 1 )
{
//consider transparency
if ( !doubleNear( context.alpha(), 1.0 ) )
{
QImage transparentImage = img.copy();
QgsSymbolLayerV2Utils::multiplyImageOpacity( &transparentImage, context.alpha() );
p->drawImage( -transparentImage.width() / 2.0, -transparentImage.height() / 2.0, transparentImage );
hwRatio = ( double )transparentImage.height() / ( double )transparentImage.width();
}
else
{
p->drawImage( -img.width() / 2.0, -img.height() / 2.0, img );
hwRatio = ( double )img.height() / ( double )img.width();
}
}
}
if ( usePict || !fitsInCache )
{
p->setOpacity( context.alpha() );
const QPicture& pct = QgsSvgCache::instance()->svgAsPicture( mPath, size, mFillColor, mOutlineColor, mOutlineWidth,
context.renderContext().scaleFactor(), context.renderContext().rasterScaleFactor() );
if ( pct.width() > 1 )
{
p->drawPicture( 0, 0, pct );
hwRatio = ( double )pct.height() / ( double )pct.width();
}
}
if ( context.selected() )
{
QPen pen( context.selectionColor() );
double penWidth = context.outputLineWidth( 1.0 );
if ( penWidth > size / 20 )
{
// keep the pen width from covering symbol
penWidth = size / 20;
}
double penOffset = penWidth / 2;
pen.setWidth( penWidth );
p->setPen( pen );
p->setBrush( Qt::NoBrush );
double wSize = size + penOffset;
double hSize = size * hwRatio + penOffset;
p->drawRect( QRectF( -wSize / 2.0, -hSize / 2.0, wSize, hSize ) );
}
p->restore();
}
void QgsMarkerLineSymbolLayerV2::renderPolylineInterval( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
if ( points.isEmpty() )
return;
QPointF lastPt = points[0];
double lengthLeft = 0; // how much is left until next marker
bool first = mOffsetAlongLine ? false : true; //only draw marker at first vertex when no offset along line is set
double origAngle = mMarker->angle();
QgsRenderContext& rc = context.renderContext();
double interval = mInterval;
QgsExpression* intervalExpression = expression( "interval" );
if ( intervalExpression )
{
interval = intervalExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
if ( interval <= 0 )
{
interval = 0.1;
}
double offsetAlongLine = mOffsetAlongLine;
QgsExpression* offsetAlongLineExpression = expression( "offset_along_line" );
if ( offsetAlongLineExpression )
{
offsetAlongLine = offsetAlongLineExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
double painterUnitInterval = interval * QgsSymbolLayerV2Utils::lineWidthScaleFactor( rc, mIntervalUnit, mIntervalMapUnitScale );
lengthLeft = painterUnitInterval - offsetAlongLine * QgsSymbolLayerV2Utils::lineWidthScaleFactor( rc, mIntervalUnit, mIntervalMapUnitScale );
for ( int i = 1; i < points.count(); ++i )
{
const QPointF& pt = points[i];
if ( lastPt == pt ) // must not be equal!
continue;
// for each line, find out dx and dy, and length
MyLine l( lastPt, pt );
QPointF diff = l.diffForInterval( painterUnitInterval );
// if there's some length left from previous line
// use only the rest for the first point in new line segment
double c = 1 - lengthLeft / painterUnitInterval;
lengthLeft += l.length();
// rotate marker (if desired)
if ( mRotateMarker )
{
mMarker->setAngle( origAngle + ( l.angle() * 180 / M_PI ) );
}
// draw first marker
if ( first )
{
mMarker->renderPoint( lastPt, context.feature(), rc, -1, context.selected() );
first = false;
}
// while we're not at the end of line segment, draw!
while ( lengthLeft > painterUnitInterval )
{
// "c" is 1 for regular point or in interval (0,1] for begin of line segment
lastPt += c * diff;
lengthLeft -= painterUnitInterval;
mMarker->renderPoint( lastPt, context.feature(), rc, -1, context.selected() );
c = 1; // reset c (if wasn't 1 already)
}
lastPt = pt;
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsMarkerLineSymbolLayerV2::renderPolylineInterval( const QPolygonF& points, QgsSymbolV2RenderContext& context )
{
if ( points.isEmpty() )
return;
QPointF lastPt = points[0];
double lengthLeft = 0; // how much is left until next marker
bool first = true;
double origAngle = mMarker->angle();
double painterUnitInterval = context.outputLineWidth( mInterval > 0 ? mInterval : 0.1 );
QgsRenderContext& rc = context.renderContext();
for ( int i = 1; i < points.count(); ++i )
{
const QPointF& pt = points[i];
if ( lastPt == pt ) // must not be equal!
continue;
// for each line, find out dx and dy, and length
MyLine l( lastPt, pt );
QPointF diff = l.diffForInterval( painterUnitInterval );
// if there's some length left from previous line
// use only the rest for the first point in new line segment
double c = 1 - lengthLeft / painterUnitInterval;
lengthLeft += l.length();
// rotate marker (if desired)
if ( mRotateMarker )
{
mMarker->setAngle( origAngle + ( l.angle() * 180 / M_PI ) );
}
// draw first marker
if ( first )
{
mMarker->renderPoint( lastPt, rc, -1, context.selected() );
first = false;
}
// while we're not at the end of line segment, draw!
while ( lengthLeft > painterUnitInterval )
{
// "c" is 1 for regular point or in interval (0,1] for begin of line segment
lastPt += c * diff;
lengthLeft -= painterUnitInterval;
mMarker->renderPoint( lastPt, rc, -1, context.selected() );
c = 1; // reset c (if wasn't 1 already)
}
lastPt = pt;
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsMarkerLineSymbolLayerV2::renderPolylineVertex( const QPolygonF& points, QgsSymbolV2RenderContext& context, Placement placement )
{
if ( points.isEmpty() )
return;
QgsRenderContext& rc = context.renderContext();
double origAngle = mMarker->angle();
int i, maxCount;
bool isRing = false;
double offsetAlongLine = mOffsetAlongLine;
QgsExpression* offsetAlongLineExpression = expression( "offset_along_line" );
if ( offsetAlongLineExpression )
{
offsetAlongLine = offsetAlongLineExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
if ( offsetAlongLine != 0 )
{
//scale offset along line
offsetAlongLine *= QgsSymbolLayerV2Utils::lineWidthScaleFactor( rc, mOffsetAlongLineUnit, mOffsetAlongLineMapUnitScale );
}
if ( placement == FirstVertex )
{
i = 0;
maxCount = 1;
}
else if ( placement == LastVertex )
{
i = points.count() - 1;
maxCount = points.count();
}
else
{
i = 0;
maxCount = points.count();
if ( points.first() == points.last() )
isRing = true;
}
if ( offsetAlongLine > 0 && ( placement == FirstVertex || placement == LastVertex ) )
{
double distance;
distance = placement == FirstVertex ? offsetAlongLine : -offsetAlongLine;
renderOffsetVertexAlongLine( points, i, distance, context );
// restore original rotation
mMarker->setAngle( origAngle );
return;
}
for ( ; i < maxCount; ++i )
{
if ( isRing && placement == Vertex && i == points.count() - 1 )
{
continue; // don't draw the last marker - it has been drawn already
}
// rotate marker (if desired)
if ( mRotateMarker )
{
double angle = markerAngle( points, isRing, i );
mMarker->setAngle( origAngle + angle * 180 / M_PI );
}
mMarker->renderPoint( points.at( i ), context.feature(), rc, -1, context.selected() );
}
// restore original rotation
mMarker->setAngle( origAngle );
}
void QgsSimpleMarkerSymbolLayerV2::renderPoint( const QPointF& point, QgsSymbolV2RenderContext& context )
{
QgsRenderContext& rc = context.renderContext();
QPainter* p = rc.painter();
if ( !p )
{
return;
}
QPointF off( context.outputLineWidth( mOffset.x() ), context.outputLineWidth( mOffset.y() ) );
if ( mAngle )
off = _rotatedOffset( off, mAngle );
if ( mUsingCache )
{
// we will use cached image
QImage &img = context.selected() ? mSelCache : mCache;
double s = img.width() / context.renderContext().rasterScaleFactor();
p->drawImage( QRectF( point.x() - s / 2.0 + off.x(),
point.y() - s / 2.0 + off.y(),
s, s ), img );
}
else
{
QMatrix transform;
bool hasDataDefinedRotation = context.renderHints() & QgsSymbolV2::DataDefinedRotation;
bool hasDataDefinedSize = context.renderHints() & QgsSymbolV2::DataDefinedSizeScale;
// move to the desired position
transform.translate( point.x() + off.x(), point.y() + off.y() );
// resize if necessary
if ( hasDataDefinedSize )
{
double scaledSize = context.outputLineWidth( mSize );
switch ( mScaleMethod )
{
case QgsSymbolV2::ScaleArea:
scaledSize = sqrt( scaledSize );
break;
case QgsSymbolV2::ScaleDiameter:
break;
}
double half = scaledSize / 2.0;
transform.scale( half, half );
}
// rotate if necessary
if ( mAngle != 0 && hasDataDefinedRotation )
{
transform.rotate( mAngle );
}
p->setBrush( context.selected() ? mSelBrush : mBrush );
p->setPen( context.selected() ? mSelPen : mPen );
if ( !mPolygon.isEmpty() )
p->drawPolygon( transform.map( mPolygon ) );
else
p->drawPath( transform.map( mPath ) );
}
}
