34 #include <QSvgRenderer> 35 #include <QDomDocument> 36 #include <QDomElement> 39 Qt::PenJoinStyle penJoinStyle )
40 : mBrushStyle( style )
41 , mStrokeColor( strokeColor )
42 , mStrokeStyle( strokeStyle )
43 , mStrokeWidth( strokeWidth )
44 , mPenJoinStyle( penJoinStyle )
80 void QgsSimpleFillSymbolLayer::applyDataDefinedSymbology(
QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen )
96 if ( exprVal.isValid() )
108 double width = exprVal.toDouble( &ok );
112 pen.setWidthF( width );
113 selPen.setWidthF( width );
149 if ( props.contains( QStringLiteral(
"color" ) ) )
151 if ( props.contains( QStringLiteral(
"style" ) ) )
153 if ( props.contains( QStringLiteral(
"color_border" ) ) )
158 else if ( props.contains( QStringLiteral(
"outline_color" ) ) )
162 else if ( props.contains( QStringLiteral(
"line_color" ) ) )
167 if ( props.contains( QStringLiteral(
"style_border" ) ) )
172 else if ( props.contains( QStringLiteral(
"outline_style" ) ) )
176 else if ( props.contains( QStringLiteral(
"line_style" ) ) )
180 if ( props.contains( QStringLiteral(
"width_border" ) ) )
183 strokeWidth = props[QStringLiteral(
"width_border" )].toDouble();
185 else if ( props.contains( QStringLiteral(
"outline_width" ) ) )
187 strokeWidth = props[QStringLiteral(
"outline_width" )].toDouble();
189 else if ( props.contains( QStringLiteral(
"line_width" ) ) )
191 strokeWidth = props[QStringLiteral(
"line_width" )].toDouble();
193 if ( props.contains( QStringLiteral(
"offset" ) ) )
195 if ( props.contains( QStringLiteral(
"joinstyle" ) ) )
200 if ( props.contains( QStringLiteral(
"border_width_unit" ) ) )
204 else if ( props.contains( QStringLiteral(
"outline_width_unit" ) ) )
208 else if ( props.contains( QStringLiteral(
"line_width_unit" ) ) )
212 if ( props.contains( QStringLiteral(
"offset_unit" ) ) )
215 if ( props.contains( QStringLiteral(
"border_width_map_unit_scale" ) ) )
217 if ( props.contains( QStringLiteral(
"offset_map_unit_scale" ) ) )
228 return QStringLiteral(
"SimpleFill" );
248 mPen = QPen( strokeColor );
278 p->translate( offset );
285 p->translate( -offset );
296 map[QStringLiteral(
"outline_width" )] = QString::number(
mStrokeWidth );
324 QDomElement symbolizerElem = doc.createElement( QStringLiteral(
"se:PolygonSymbolizer" ) );
325 if ( !props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ).isEmpty() )
326 symbolizerElem.setAttribute( QStringLiteral(
"uom" ), props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ) );
327 element.appendChild( symbolizerElem );
335 QDomElement fillElem = doc.createElement( QStringLiteral(
"se:Fill" ) );
336 symbolizerElem.appendChild( fillElem );
343 QDomElement strokeElem = doc.createElement( QStringLiteral(
"se:Stroke" ) );
344 symbolizerElem.appendChild( strokeElem );
359 symbolStyle.append(
';' );
370 Qt::BrushStyle fillStyle;
374 QDomElement fillElem = element.firstChildElement( QStringLiteral(
"Fill" ) );
377 QDomElement strokeElem = element.firstChildElement( QStringLiteral(
"Stroke" ) );
383 QString uom = element.attribute( QStringLiteral(
"uom" ), QString() );
398 return penBleed + offsetBleed;
459 : mGradientColorType( colorType )
460 , mGradientType( gradientType )
461 , mCoordinateMode( coordinateMode )
462 , mGradientSpread( spread )
463 , mReferencePoint1( QPointF( 0.5, 0 ) )
464 , mReferencePoint2( QPointF( 0.5, 1 ) )
485 bool refPoint1IsCentroid =
false;
487 bool refPoint2IsCentroid =
false;
492 if ( props.contains( QStringLiteral(
"type" ) ) )
493 type = static_cast< GradientType >( props[QStringLiteral(
"type" )].toInt() );
494 if ( props.contains( QStringLiteral(
"coordinate_mode" ) ) )
495 coordinateMode = static_cast< GradientCoordinateMode >( props[QStringLiteral(
"coordinate_mode" )].toInt() );
496 if ( props.contains( QStringLiteral(
"spread" ) ) )
497 gradientSpread = static_cast< GradientSpread >( props[QStringLiteral(
"spread" )].toInt() );
498 if ( props.contains( QStringLiteral(
"color_type" ) ) )
499 colorType = static_cast< GradientColorType >( props[QStringLiteral(
"color_type" )].toInt() );
500 if ( props.contains( QStringLiteral(
"gradient_color" ) ) )
505 else if ( props.contains( QStringLiteral(
"color" ) ) )
509 if ( props.contains( QStringLiteral(
"gradient_color2" ) ) )
514 if ( props.contains( QStringLiteral(
"reference_point1" ) ) )
516 if ( props.contains( QStringLiteral(
"reference_point1_iscentroid" ) ) )
517 refPoint1IsCentroid = props[QStringLiteral(
"reference_point1_iscentroid" )].toInt();
518 if ( props.contains( QStringLiteral(
"reference_point2" ) ) )
520 if ( props.contains( QStringLiteral(
"reference_point2_iscentroid" ) ) )
521 refPoint2IsCentroid = props[QStringLiteral(
"reference_point2_iscentroid" )].toInt();
522 if ( props.contains( QStringLiteral(
"angle" ) ) )
523 angle = props[QStringLiteral(
"angle" )].toDouble();
525 if ( props.contains( QStringLiteral(
"offset" ) ) )
530 if ( props.contains( QStringLiteral(
"rampType" ) ) && props[QStringLiteral(
"rampType" )] == QStringLiteral(
"cpt-city" ) )
542 if ( props.contains( QStringLiteral(
"offset_unit" ) ) )
544 if ( props.contains( QStringLiteral(
"offset_map_unit_scale" ) ) )
567 return QStringLiteral(
"GradientFill" );
570 void QgsGradientFillSymbolLayer::applyDataDefinedSymbology(
QgsSymbolRenderContext &context,
const QPolygonF &points )
613 if ( currentType == QObject::tr(
"linear" ) )
617 else if ( currentType == QObject::tr(
"radial" ) )
621 else if ( currentType == QObject::tr(
"conical" ) )
635 if ( currentCoordMode == QObject::tr(
"feature" ) )
639 else if ( currentCoordMode == QObject::tr(
"viewport" ) )
653 if ( currentSpread == QObject::tr(
"pad" ) )
657 else if ( currentSpread == QObject::tr(
"repeat" ) )
661 else if ( currentSpread == QObject::tr(
"reflect" ) )
708 if ( refPoint1IsCentroid || refPoint2IsCentroid )
713 QRectF bbox = points.boundingRect();
714 double centroidX = ( centroid.x() - bbox.left() ) / bbox.width();
715 double centroidY = ( centroid.y() - bbox.top() ) / bbox.height();
717 if ( refPoint1IsCentroid )
719 refPoint1X = centroidX;
720 refPoint1Y = centroidY;
722 if ( refPoint2IsCentroid )
724 refPoint2X = centroidX;
725 refPoint2Y = centroidY;
731 spread, QPointF( refPoint1X, refPoint1Y ), QPointF( refPoint2X, refPoint2Y ), angle );
734 QPointF QgsGradientFillSymbolLayer::rotateReferencePoint( QPointF refPoint,
double angle )
739 QLineF refLine = QLineF( QPointF( 0.5, 0.5 ), refPoint );
741 refLine.setAngle( refLine.angle() +
angle );
743 QPointF rotatedReferencePoint = refLine.p2();
745 if ( rotatedReferencePoint.x() > 1 )
746 rotatedReferencePoint.setX( 1 );
747 if ( rotatedReferencePoint.x() < 0 )
748 rotatedReferencePoint.setX( 0 );
749 if ( rotatedReferencePoint.y() > 1 )
750 rotatedReferencePoint.setY( 1 );
751 if ( rotatedReferencePoint.y() < 0 )
752 rotatedReferencePoint.setY( 0 );
754 return rotatedReferencePoint;
765 fillColor.setAlphaF( context.
opacity() * fillColor.alphaF() );
766 QColor fillColor2 =
color2;
767 fillColor2.setAlphaF( context.
opacity() * fillColor2.alphaF() );
778 gradient = QLinearGradient( rotatedReferencePoint1, rotatedReferencePoint2 );
781 gradient = QRadialGradient( rotatedReferencePoint1, QLineF( rotatedReferencePoint1, rotatedReferencePoint2 ).length() );
784 gradient = QConicalGradient( rotatedReferencePoint1, QLineF( rotatedReferencePoint1, rotatedReferencePoint2 ).
angle() );
790 gradient.setCoordinateMode( QGradient::ObjectBoundingMode );
793 gradient.setCoordinateMode( QGradient::StretchToDeviceMode );
799 gradient.setSpread( QGradient::PadSpread );
802 gradient.setSpread( QGradient::ReflectSpread );
805 gradient.setSpread( QGradient::RepeatSpread );
811 ( gradientRamp->
type() == QLatin1String(
"gradient" ) || gradientRamp->
type() == QLatin1String(
"cpt-city" ) ) )
820 gradient.setColorAt( 0.0, fillColor );
821 gradient.setColorAt( 1.0, fillColor2 );
825 brush = QBrush( gradient );
832 selColor.setAlphaF( context.
opacity() );
849 applyDataDefinedSymbology( context, points );
852 p->setPen( Qt::NoPen );
859 p->translate( offset );
866 p->translate( -offset );
876 map[QStringLiteral(
"type" )] = QString::number(
mGradientType );
877 map[QStringLiteral(
"coordinate_mode" )] = QString::number(
mCoordinateMode );
883 map[QStringLiteral(
"angle" )] = QString::number(
mAngle );
941 int blurRadius,
bool useWholeShape,
double maxDistance )
942 : mBlurRadius( blurRadius )
943 , mUseWholeShape( useWholeShape )
944 , mMaxDistance( maxDistance )
945 , mColorType( colorType )
964 if ( props.contains( QStringLiteral(
"color_type" ) ) )
966 colorType =
static_cast< ShapeburstColorType >( props[QStringLiteral(
"color_type" )].toInt() );
968 if ( props.contains( QStringLiteral(
"shapeburst_color" ) ) )
973 else if ( props.contains( QStringLiteral(
"color" ) ) )
978 if ( props.contains( QStringLiteral(
"shapeburst_color2" ) ) )
983 else if ( props.contains( QStringLiteral(
"gradient_color2" ) ) )
987 if ( props.contains( QStringLiteral(
"blur_radius" ) ) )
989 blurRadius = props[QStringLiteral(
"blur_radius" )].toInt();
991 if ( props.contains( QStringLiteral(
"use_whole_shape" ) ) )
993 useWholeShape = props[QStringLiteral(
"use_whole_shape" )].toInt();
995 if ( props.contains( QStringLiteral(
"max_distance" ) ) )
997 maxDistance = props[QStringLiteral(
"max_distance" )].toDouble();
999 if ( props.contains( QStringLiteral(
"offset" ) ) )
1006 if ( props.contains( QStringLiteral(
"rampType" ) ) && props[QStringLiteral(
"rampType" )] == QStringLiteral(
"cpt-city" ) )
1018 if ( props.contains( QStringLiteral(
"offset_unit" ) ) )
1022 if ( props.contains( QStringLiteral(
"distance_unit" ) ) )
1026 if ( props.contains( QStringLiteral(
"offset_map_unit_scale" ) ) )
1030 if ( props.contains( QStringLiteral(
"distance_map_unit_scale" ) ) )
1034 if ( props.contains( QStringLiteral(
"ignore_rings" ) ) )
1036 sl->
setIgnoreRings( props[QStringLiteral(
"ignore_rings" )].toInt() );
1050 return QStringLiteral(
"ShapeburstFill" );
1055 if ( mGradientRamp.get() == ramp )
1058 mGradientRamp.reset( ramp );
1105 ignoreRings = mIgnoreRings;
1119 selColor.setAlphaF( context.
opacity() );
1120 mSelBrush = QBrush( selColor );
1125 Q_UNUSED( context );
1139 p->setBrush( mSelBrush );
1141 if ( !mOffset.isNull() )
1145 p->translate( offset );
1148 if ( !mOffset.isNull() )
1150 p->translate( -offset );
1161 applyDataDefinedSymbology( context, color1, color2, blurRadius, useWholeShape, maxDistance, ignoreRings );
1164 int outputPixelMaxDist = 0;
1172 std::unique_ptr< QgsGradientColorRamp > twoColorGradientRamp;
1175 twoColorGradientRamp = qgis::make_unique< QgsGradientColorRamp >( color1,
color2 );
1179 p->setPen( QPen( Qt::NoPen ) );
1182 int sideBuffer = 4 + ( blurRadius + 2 ) * 4;
1184 int pointsWidth =
static_cast< int >( std::round( points.boundingRect().width() ) );
1185 int pointsHeight =
static_cast< int >( std::round( points.boundingRect().height() ) );
1186 int imWidth = pointsWidth + ( sideBuffer * 2 );
1187 int imHeight = pointsHeight + ( sideBuffer * 2 );
1188 std::unique_ptr< QImage > fillImage = qgis::make_unique< QImage >( imWidth,
1189 imHeight, QImage::Format_ARGB32_Premultiplied );
1190 if ( fillImage->isNull() )
1197 std::unique_ptr< QImage > alphaImage = qgis::make_unique< QImage >( fillImage->width(), fillImage->height(), QImage::Format_ARGB32_Premultiplied );
1198 if ( alphaImage->isNull() )
1207 fillImage->fill( Qt::black );
1210 alphaImage->fill( Qt::transparent );
1213 QPainter imgPainter;
1214 imgPainter.begin( alphaImage.get() );
1215 imgPainter.setRenderHint( QPainter::Antialiasing,
true );
1216 imgPainter.setBrush( QBrush( Qt::white ) );
1217 imgPainter.setPen( QPen( Qt::black ) );
1218 imgPainter.translate( -points.boundingRect().left() + sideBuffer, - points.boundingRect().top() + sideBuffer );
1224 imgPainter.begin( fillImage.get() );
1227 imgPainter.drawImage( 0, 0, *alphaImage );
1234 imgPainter.setBrush( QBrush( Qt::white ) );
1235 imgPainter.setPen( QPen( Qt::black ) );
1236 imgPainter.translate( -points.boundingRect().left() + sideBuffer, - points.boundingRect().top() + sideBuffer );
1242 double *dtArray = distanceTransform( fillImage.get() );
1252 if ( blurRadius > 0 )
1258 imgPainter.begin( fillImage.get() );
1259 imgPainter.setCompositionMode( QPainter::CompositionMode_DestinationIn );
1260 imgPainter.drawImage( 0, 0, *alphaImage );
1269 if ( !mOffset.isNull() )
1273 p->translate( offset );
1276 p->drawImage( points.boundingRect().left() - sideBuffer, points.boundingRect().top() - sideBuffer, *fillImage );
1278 if ( !mOffset.isNull() )
1280 p->translate( -offset );
1289 void QgsShapeburstFillSymbolLayer::distanceTransform1d(
double *f,
int n,
int *v,
double *z,
double *d )
1295 for (
int q = 1; q <= n - 1; q++ )
1297 double s = ( ( f[q] + q * q ) - ( f[v[k]] + ( v[k] * v[k] ) ) ) / ( 2 * q - 2 * v[k] );
1301 s = ( ( f[q] + q * q ) - ( f[v[k]] + ( v[k] * v[k] ) ) ) / ( 2 * q - 2 * v[k] );
1310 for (
int q = 0; q <= n - 1; q++ )
1312 while ( z[k + 1] < q )
1314 d[q] = ( q - v[k] ) * ( q - v[k] ) + f[v[k]];
1319 void QgsShapeburstFillSymbolLayer::distanceTransform2d(
double *im,
int width,
int height )
1321 int maxDimension = std::max( width, height );
1322 double *f =
new double[ maxDimension ];
1323 int *v =
new int[ maxDimension ];
1324 double *z =
new double[ maxDimension + 1 ];
1325 double *d =
new double[ maxDimension ];
1328 for (
int x = 0; x < width; x++ )
1330 for (
int y = 0; y < height; y++ )
1332 f[y] = im[ x + y * width ];
1334 distanceTransform1d( f, height, v, z, d );
1335 for (
int y = 0; y < height; y++ )
1337 im[ x + y * width ] = d[y];
1342 for (
int y = 0; y < height; y++ )
1344 for (
int x = 0; x < width; x++ )
1346 f[x] = im[ x + y * width ];
1348 distanceTransform1d( f, width, v, z, d );
1349 for (
int x = 0; x < width; x++ )
1351 im[ x + y * width ] = d[x];
1362 double *QgsShapeburstFillSymbolLayer::distanceTransform( QImage *im )
1364 int width = im->width();
1365 int height = im->height();
1367 double *dtArray =
new double[width * height];
1372 for (
int heightIndex = 0; heightIndex < height; ++heightIndex )
1374 const QRgb *scanLine =
reinterpret_cast< const QRgb *
>( im->constScanLine( heightIndex ) );
1375 for (
int widthIndex = 0; widthIndex < width; ++widthIndex )
1377 tmpRgb = scanLine[widthIndex];
1378 if ( qRed( tmpRgb ) == 0 )
1386 dtArray[ idx ] =
INF;
1393 distanceTransform2d( dtArray, width, height );
1398 void QgsShapeburstFillSymbolLayer::dtArrayToQImage(
double *array, QImage *im,
QgsColorRamp *ramp,
double layerAlpha,
bool useWholeShape,
int maxPixelDistance )
1400 int width = im->width();
1401 int height = im->height();
1404 double maxDistanceValue;
1409 double dtMaxValue = array[0];
1410 for (
int i = 1; i < ( width * height ); ++i )
1412 if ( array[i] > dtMaxValue )
1414 dtMaxValue = array[i];
1419 maxDistanceValue = std::sqrt( dtMaxValue );
1424 maxDistanceValue = maxPixelDistance;
1429 double squaredVal = 0;
1432 bool layerHasAlpha = layerAlpha < 1.0;
1434 for (
int heightIndex = 0; heightIndex < height; ++heightIndex )
1436 QRgb *scanLine =
reinterpret_cast< QRgb *
>( im->scanLine( heightIndex ) );
1437 for (
int widthIndex = 0; widthIndex < width; ++widthIndex )
1440 squaredVal = array[idx];
1443 if ( maxDistanceValue > 0 )
1445 pixVal = squaredVal > 0 ? std::min( ( std::sqrt( squaredVal ) / maxDistanceValue ), 1.0 ) : 0;
1453 pixColor = ramp->
color( pixVal );
1455 int pixAlpha = pixColor.alpha();
1456 if ( ( layerHasAlpha ) || ( pixAlpha != 255 ) )
1459 double alpha = pixAlpha * layerAlpha;
1464 scanLine[widthIndex] = pixColor.rgba();
1475 map[QStringLiteral(
"color_type" )] = QString::number( mColorType );
1476 map[QStringLiteral(
"blur_radius" )] = QString::number( mBlurRadius );
1477 map[QStringLiteral(
"use_whole_shape" )] = QString::number( mUseWholeShape );
1478 map[QStringLiteral(
"max_distance" )] = QString::number( mMaxDistance );
1481 map[QStringLiteral(
"ignore_rings" )] = QString::number( mIgnoreRings );
1485 if ( mGradientRamp )
1487 map.unite( mGradientRamp->properties() );
1496 if ( mGradientRamp )
1513 double offsetBleed = context.
convertToPainterUnits( std::max( std::fabs( mOffset.x() ), std::fabs( mOffset.y() ) ), mOffsetUnit, mOffsetMapUnitScale );
1519 mDistanceUnit = unit;
1525 if ( mDistanceUnit == mOffsetUnit )
1527 return mDistanceUnit;
1534 mDistanceMapUnitScale = scale;
1535 mOffsetMapUnitScale = scale;
1540 if ( mDistanceMapUnitScale == mOffsetMapUnitScale )
1542 return mDistanceMapUnitScale;
1564 applyDataDefinedSettings( context );
1566 p->setPen( QPen( Qt::NoPen ) );
1568 QTransform bkTransform = mBrush.transform();
1572 QPointF leftCorner = points.boundingRect().topLeft();
1573 QTransform t = mBrush.transform();
1574 t.translate( leftCorner.x(), leftCorner.y() );
1575 mBrush.setTransform( t );
1584 p->setBrush( QBrush( selColor ) );
1590 QTransform t = mBrush.transform();
1591 t.rotate( mNextAngle );
1592 mBrush.setTransform( t );
1594 p->setBrush( mBrush );
1601 QList<QPolygonF>::const_iterator ringIt = rings->constBegin();
1602 for ( ; ringIt != rings->constEnd(); ++ringIt )
1609 mBrush.setTransform( bkTransform );
1616 mStroke.reset(
nullptr );
1629 mStroke.reset( lineSymbol );
1639 mStrokeWidthUnit = unit;
1644 return mStrokeWidthUnit;
1649 mStrokeWidthMapUnitScale = scale;
1654 return mStrokeWidthMapUnitScale;
1659 if ( mStroke && mStroke->symbolLayer( 0 ) )
1661 double subLayerBleed = mStroke->symbolLayer( 0 )->estimateMaxBleed( context );
1662 return subLayerBleed;
1669 double width = mStrokeWidth;
1680 Q_UNUSED( context );
1683 return QColor( Qt::black );
1685 return mStroke->color();
1690 return Qt::SolidLine;
1694 return Qt::SolidLine;
1698 return mStroke->dxfPenStyle();
1707 attr.unite( mStroke->usedAttributes( context ) );
1716 , mPatternWidth( width )
1718 , mSvgStrokeWidthUnit(
QgsUnitTypes::RenderMillimeters )
1723 mColor = QColor( 255, 255, 255 );
1726 setDefaultSvgParams();
1740 mColor = QColor( 255, 255, 255 );
1744 setDefaultSvgParams();
1759 mStroke->setOutputUnit( unit );
1797 setDefaultSvgParams();
1807 if ( properties.contains( QStringLiteral(
"width" ) ) )
1809 width = properties[QStringLiteral(
"width" )].toDouble();
1811 if ( properties.contains( QStringLiteral(
"svgFile" ) ) )
1813 svgFilePath = properties[QStringLiteral(
"svgFile" )];
1815 if ( properties.contains( QStringLiteral(
"angle" ) ) )
1817 angle = properties[QStringLiteral(
"angle" )].toDouble();
1821 if ( !svgFilePath.isEmpty() )
1827 if ( properties.contains( QStringLiteral(
"data" ) ) )
1829 data = QByteArray::fromHex( properties[QStringLiteral(
"data" )].toLocal8Bit() );
1835 if ( properties.contains( QStringLiteral(
"svgFillColor" ) ) )
1840 else if ( properties.contains( QStringLiteral(
"color" ) ) )
1844 if ( properties.contains( QStringLiteral(
"svgOutlineColor" ) ) )
1849 else if ( properties.contains( QStringLiteral(
"outline_color" ) ) )
1853 else if ( properties.contains( QStringLiteral(
"line_color" ) ) )
1857 if ( properties.contains( QStringLiteral(
"svgOutlineWidth" ) ) )
1860 symbolLayer->
setSvgStrokeWidth( properties[QStringLiteral(
"svgOutlineWidth" )].toDouble() );
1862 else if ( properties.contains( QStringLiteral(
"outline_width" ) ) )
1864 symbolLayer->
setSvgStrokeWidth( properties[QStringLiteral(
"outline_width" )].toDouble() );
1866 else if ( properties.contains( QStringLiteral(
"line_width" ) ) )
1868 symbolLayer->
setSvgStrokeWidth( properties[QStringLiteral(
"line_width" )].toDouble() );
1872 if ( properties.contains( QStringLiteral(
"pattern_width_unit" ) ) )
1876 if ( properties.contains( QStringLiteral(
"pattern_width_map_unit_scale" ) ) )
1880 if ( properties.contains( QStringLiteral(
"svg_outline_width_unit" ) ) )
1884 if ( properties.contains( QStringLiteral(
"svg_outline_width_map_unit_scale" ) ) )
1888 if ( properties.contains( QStringLiteral(
"outline_width_unit" ) ) )
1892 if ( properties.contains( QStringLiteral(
"outline_width_map_unit_scale" ) ) )
1904 QgsStringMap::iterator it = properties.find( QStringLiteral(
"svgFile" ) );
1905 if ( it != properties.end() )
1916 return QStringLiteral(
"SVGFill" );
1933 if ( static_cast< int >( size ) < 1.0 || 10000.0 < size )
1940 bool fitsInCache =
true;
1948 double hwRatio = 1.0;
1949 if ( patternPict.width() > 0 )
1951 hwRatio =
static_cast< double >( patternPict.height() ) / static_cast< double >( patternPict.width() );
1953 mSvgPattern =
new QImage( static_cast< int >( size ), static_cast< int >( size * hwRatio ), QImage::Format_ARGB32_Premultiplied );
1957 p.drawPicture( QPointF( size / 2, size * hwRatio / 2 ), patternPict );
1960 QTransform brushTransform;
1963 QImage transparentImage = fitsInCache ? patternImage.copy() :
mSvgPattern->copy();
1965 brush.setTextureImage( transparentImage );
1969 brush.setTextureImage( fitsInCache ? patternImage : *
mSvgPattern );
1971 brush.setTransform( brushTransform );
1978 applyPattern(
mBrush,
mSvgFilePath,
mPatternWidth,
mPatternWidthUnit,
mColor,
mSvgStrokeColor,
mSvgStrokeWidth,
mSvgStrokeWidthUnit, context,
mPatternWidthMapUnitScale,
mSvgStrokeWidthMapUnitScale );
1999 map.insert( QStringLiteral(
"svgFile" ),
mSvgFilePath );
2003 map.insert( QStringLiteral(
"data" ), QString(
mSvgData.toHex() ) );
2006 map.insert( QStringLiteral(
"width" ), QString::number(
mPatternWidth ) );
2007 map.insert( QStringLiteral(
"angle" ), QString::number(
mAngle ) );
2012 map.insert( QStringLiteral(
"outline_width" ), QString::number(
mSvgStrokeWidth ) );
2057 QDomElement symbolizerElem = doc.createElement( QStringLiteral(
"se:PolygonSymbolizer" ) );
2058 if ( !props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ).isEmpty() )
2059 symbolizerElem.setAttribute( QStringLiteral(
"uom" ), props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ) );
2060 element.appendChild( symbolizerElem );
2064 QDomElement fillElem = doc.createElement( QStringLiteral(
"se:Fill" ) );
2065 symbolizerElem.appendChild( fillElem );
2067 QDomElement graphicFillElem = doc.createElement( QStringLiteral(
"se:GraphicFill" ) );
2068 fillElem.appendChild( graphicFillElem );
2070 QDomElement graphicElem = doc.createElement( QStringLiteral(
"se:Graphic" ) );
2071 graphicFillElem.appendChild( graphicElem );
2084 symbolizerElem.appendChild( doc.createComment( QStringLiteral(
"SVG from data not implemented yet" ) ) );
2090 double angle = props.value( QStringLiteral(
"angle" ), QStringLiteral(
"0" ) ).toDouble( &ok );
2093 angleFunc = QStringLiteral(
"%1 + %2" ).arg( props.value( QStringLiteral(
"angle" ), QStringLiteral(
"0" ) ) ).arg(
mAngle );
2097 angleFunc = QString::number( angle +
mAngle );
2106 mStroke->toSld( doc, element, props );
2114 QString path, mimeType;
2116 Qt::PenStyle penStyle;
2117 double size, strokeWidth;
2119 QDomElement fillElem = element.firstChildElement( QStringLiteral(
"Fill" ) );
2120 if ( fillElem.isNull() )
2123 QDomElement graphicFillElem = fillElem.firstChildElement( QStringLiteral(
"GraphicFill" ) );
2124 if ( graphicFillElem.isNull() )
2127 QDomElement graphicElem = graphicFillElem.firstChildElement( QStringLiteral(
"Graphic" ) );
2128 if ( graphicElem.isNull() )
2134 if ( mimeType != QLatin1String(
"image/svg+xml" ) )
2139 QString uom = element.attribute( QStringLiteral(
"uom" ) );
2148 double d = angleFunc.toDouble( &ok );
2154 sl->
setOutputUnit( QgsUnitTypes::RenderUnit::RenderPixels );
2160 QDomElement strokeElem = element.firstChildElement( QStringLiteral(
"Stroke" ) );
2161 if ( !strokeElem.isNull() )
2226 void QgsSVGFillSymbolLayer::storeViewBox()
2241 void QgsSVGFillSymbolLayer::setDefaultSvgParams()
2248 bool hasFillParam, hasFillOpacityParam, hasStrokeParam, hasStrokeWidthParam, hasStrokeOpacityParam;
2249 bool hasDefaultFillColor, hasDefaultFillOpacity, hasDefaultStrokeColor, hasDefaultStrokeWidth, hasDefaultStrokeOpacity;
2250 QColor defaultFillColor, defaultStrokeColor;
2251 double defaultStrokeWidth, defaultFillOpacity, defaultStrokeOpacity;
2253 hasFillOpacityParam, hasDefaultFillOpacity, defaultFillOpacity,
2254 hasStrokeParam, hasDefaultStrokeColor, defaultStrokeColor,
2255 hasStrokeWidthParam, hasDefaultStrokeWidth, defaultStrokeWidth,
2256 hasStrokeOpacityParam, hasDefaultStrokeOpacity, defaultStrokeOpacity );
2258 double newFillOpacity = hasFillOpacityParam ?
mColor.alphaF() : 1.0;
2259 double newStrokeOpacity = hasStrokeOpacityParam ?
mSvgStrokeColor.alphaF() : 1.0;
2261 if ( hasDefaultFillColor )
2263 mColor = defaultFillColor;
2264 mColor.setAlphaF( newFillOpacity );
2266 if ( hasDefaultFillOpacity )
2268 mColor.setAlphaF( defaultFillOpacity );
2270 if ( hasDefaultStrokeColor )
2275 if ( hasDefaultStrokeOpacity )
2279 if ( hasDefaultStrokeWidth )
2307 return mFillLineSymbol ? mFillLineSymbol->
color() :
mColor;
2312 delete mFillLineSymbol;
2327 delete mFillLineSymbol;
2328 mFillLineSymbol = lineSymbol;
2339 return mFillLineSymbol;
2345 if ( mFillLineSymbol )
2400 QColor
color( Qt::black );
2403 if ( properties.contains( QStringLiteral(
"lineangle" ) ) )
2406 lineAngle = properties[QStringLiteral(
"lineangle" )].toDouble();
2408 else if ( properties.contains( QStringLiteral(
"angle" ) ) )
2410 lineAngle = properties[QStringLiteral(
"angle" )].toDouble();
2414 if ( properties.contains( QStringLiteral(
"distance" ) ) )
2416 distance = properties[QStringLiteral(
"distance" )].toDouble();
2420 if ( properties.contains( QStringLiteral(
"linewidth" ) ) )
2423 lineWidth = properties[QStringLiteral(
"linewidth" )].toDouble();
2425 else if ( properties.contains( QStringLiteral(
"outline_width" ) ) )
2427 lineWidth = properties[QStringLiteral(
"outline_width" )].toDouble();
2429 else if ( properties.contains( QStringLiteral(
"line_width" ) ) )
2431 lineWidth = properties[QStringLiteral(
"line_width" )].toDouble();
2435 if ( properties.contains( QStringLiteral(
"color" ) ) )
2439 else if ( properties.contains( QStringLiteral(
"outline_color" ) ) )
2443 else if ( properties.contains( QStringLiteral(
"line_color" ) ) )
2449 if ( properties.contains( QStringLiteral(
"offset" ) ) )
2451 offset = properties[QStringLiteral(
"offset" )].toDouble();
2456 if ( properties.contains( QStringLiteral(
"distance_unit" ) ) )
2460 if ( properties.contains( QStringLiteral(
"distance_map_unit_scale" ) ) )
2464 if ( properties.contains( QStringLiteral(
"line_width_unit" ) ) )
2468 else if ( properties.contains( QStringLiteral(
"outline_width_unit" ) ) )
2472 if ( properties.contains( QStringLiteral(
"line_width_map_unit_scale" ) ) )
2476 if ( properties.contains( QStringLiteral(
"offset_unit" ) ) )
2480 if ( properties.contains( QStringLiteral(
"offset_map_unit_scale" ) ) )
2484 if ( properties.contains( QStringLiteral(
"outline_width_unit" ) ) )
2488 if ( properties.contains( QStringLiteral(
"outline_width_map_unit_scale" ) ) )
2495 return patternLayer;
2500 return QStringLiteral(
"LinePatternFill" );
2505 mBrush.setTextureImage( QImage() );
2507 if ( !mFillLineSymbol )
2513 if ( !fillLineSymbol )
2525 double outputPixelBleed = 0;
2526 double outputPixelInterval = 0;
2531 outputPixelBleed = std::max( outputPixelBleed, outputPixelLayerBleed );
2534 if ( markerLineLayer )
2543 outputPixelInterval = std::max( outputPixelInterval, outputPixelLayerInterval );
2547 if ( outputPixelInterval > 0 )
2551 double intervalScale = std::round( outputPixelInterval ) / outputPixelInterval;
2552 outputPixelInterval = std::round( outputPixelInterval );
2559 if ( markerLineLayer )
2570 height = outputPixelDist;
2571 width = outputPixelInterval > 0 ? outputPixelInterval : height;
2575 width = outputPixelDist;
2576 height = outputPixelInterval > 0 ? outputPixelInterval : width;
2580 height = outputPixelDist / std::cos(
lineAngle * M_PI / 180 );
2581 width = outputPixelDist / std::sin(
lineAngle * M_PI / 180 );
2584 lineAngle = 180 * std::atan2( static_cast< double >( height ), static_cast< double >( width ) ) / M_PI;
2590 height = std::abs( height );
2591 width = std::abs( width );
2593 outputPixelDist = height * std::cos(
lineAngle * M_PI / 180 );
2597 int offsetHeight = std::round( std::fabs( outputPixelOffset / std::cos(
lineAngle * M_PI / 180 ) ) );
2598 outputPixelOffset = offsetHeight * std::cos(
lineAngle * M_PI / 180 );
2607 int bufferMulti = std::max( std::ceil( outputPixelBleed / width ), std::ceil( outputPixelBleed / width ) );
2611 bufferMulti = std::max( bufferMulti, 1 );
2613 int xBuffer = width * bufferMulti;
2614 int yBuffer = height * bufferMulti;
2615 int innerWidth = width;
2616 int innerHeight = height;
2617 width += 2 * xBuffer;
2618 height += 2 * yBuffer;
2621 if ( width > 10000 || height > 10000 || width == 0 || height == 0 )
2626 QImage patternImage( width, height, QImage::Format_ARGB32 );
2627 patternImage.fill( 0 );
2629 QPointF p1, p2, p3, p4, p5, p6;
2632 p1 = QPointF( 0, yBuffer );
2633 p2 = QPointF( width, yBuffer );
2634 p3 = QPointF( 0, yBuffer + innerHeight );
2635 p4 = QPointF( width, yBuffer + innerHeight );
2639 p1 = QPointF( xBuffer, height );
2640 p2 = QPointF( xBuffer, 0 );
2641 p3 = QPointF( xBuffer + innerWidth, height );
2642 p4 = QPointF( xBuffer + innerWidth, 0 );
2646 dx = outputPixelDist * std::cos( ( 90 -
lineAngle ) * M_PI / 180.0 );
2647 dy = outputPixelDist * std::sin( ( 90 -
lineAngle ) * M_PI / 180.0 );
2648 p1 = QPointF( 0, height );
2649 p2 = QPointF( width, 0 );
2650 p3 = QPointF( -dx, height - dy );
2651 p4 = QPointF( width - dx, -dy );
2652 p5 = QPointF( dx, height + dy );
2653 p6 = QPointF( width + dx, dy );
2657 dx = outputPixelDist * std::cos( ( 90 -
lineAngle ) * M_PI / 180.0 );
2658 dy = outputPixelDist * std::sin( ( 90 -
lineAngle ) * M_PI / 180.0 );
2659 p1 = QPointF( width, 0 );
2660 p2 = QPointF( 0, height );
2661 p3 = QPointF( width - dx, -dy );
2662 p4 = QPointF( -dx, height - dy );
2663 p5 = QPointF( width + dx, dy );
2664 p6 = QPointF( dx, height + dy );
2668 dy = outputPixelDist * std::cos( ( 180 -
lineAngle ) * M_PI / 180 );
2669 dx = outputPixelDist * std::sin( ( 180 -
lineAngle ) * M_PI / 180 );
2670 p1 = QPointF( 0, 0 );
2671 p2 = QPointF( width, height );
2672 p5 = QPointF( dx, -dy );
2673 p6 = QPointF( width + dx, height - dy );
2674 p3 = QPointF( -dx, dy );
2675 p4 = QPointF( width - dx, height + dy );
2679 dy = outputPixelDist * std::cos( ( 180 -
lineAngle ) * M_PI / 180 );
2680 dx = outputPixelDist * std::sin( ( 180 -
lineAngle ) * M_PI / 180 );
2681 p1 = QPointF( width, height );
2682 p2 = QPointF( 0, 0 );
2683 p5 = QPointF( width + dx, height - dy );
2684 p6 = QPointF( dx, -dy );
2685 p3 = QPointF( width - dx, height + dy );
2686 p4 = QPointF( -dx, dy );
2693 p3 = QPointF( tempPt.x(), tempPt.y() );
2695 p4 = QPointF( tempPt.x(), tempPt.y() );
2697 p5 = QPointF( tempPt.x(), tempPt.y() );
2699 p6 = QPointF( tempPt.x(), tempPt.y() );
2703 p1 = QPointF( tempPt.x(), tempPt.y() );
2705 p2 = QPointF( tempPt.x(), tempPt.y() );
2708 QPainter p( &patternImage );
2712 p.setRenderHint( QPainter::Antialiasing,
false );
2713 QPen pen( QColor( Qt::black ) );
2714 pen.setWidthF( 0.1 );
2715 pen.setCapStyle( Qt::FlatCap );
2720 QPolygon polygon = QPolygon() << QPoint( 0, 0 ) << QPoint( width - 1, 0 ) << QPoint( width - 1, height - 1 ) << QPoint( 0, height - 1 ) << QPoint( 0, 0 );
2721 p.drawPolygon( polygon );
2723 polygon = QPolygon() << QPoint( xBuffer, yBuffer ) << QPoint( width - xBuffer - 1, yBuffer ) << QPoint( width - xBuffer - 1, height - yBuffer - 1 ) << QPoint( xBuffer, height - yBuffer - 1 ) << QPoint( xBuffer, yBuffer );
2724 p.drawPolygon( polygon );
2730 p.setRenderHint( QPainter::Antialiasing,
true );
2743 QVector<QPolygonF> polygons;
2744 polygons.append( QPolygonF() << p1 << p2 );
2745 polygons.append( QPolygonF() << p3 << p4 );
2748 polygons.append( QPolygonF() << p5 << p6 );
2751 Q_FOREACH (
const QPolygonF &polygon, polygons )
2756 fillLineSymbol->
stopRender( lineRenderContext );
2760 patternImage = patternImage.copy( xBuffer, yBuffer, patternImage.width() - 2 * xBuffer, patternImage.height() - 2 * yBuffer );
2765 QImage transparentImage = patternImage.copy();
2767 brush.setTextureImage( transparentImage );
2771 brush.setTextureImage( patternImage );
2774 QTransform brushTransform;
2775 brush.setTransform( brushTransform );
2777 delete fillLineSymbol;
2784 if ( mFillLineSymbol )
2792 if ( mFillLineSymbol )
2801 map.insert( QStringLiteral(
"angle" ), QString::number(
mLineAngle ) );
2802 map.insert( QStringLiteral(
"distance" ), QString::number(
mDistance ) );
2803 map.insert( QStringLiteral(
"line_width" ), QString::number(
mLineWidth ) );
2805 map.insert( QStringLiteral(
"offset" ), QString::number(
mOffset ) );
2820 if ( mFillLineSymbol )
2831 QDomElement symbolizerElem = doc.createElement( QStringLiteral(
"se:PolygonSymbolizer" ) );
2832 if ( !props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ).isEmpty() )
2833 symbolizerElem.setAttribute( QStringLiteral(
"uom" ), props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ) );
2834 element.appendChild( symbolizerElem );
2839 QDomElement fillElem = doc.createElement( QStringLiteral(
"se:Fill" ) );
2840 symbolizerElem.appendChild( fillElem );
2842 QDomElement graphicFillElem = doc.createElement( QStringLiteral(
"se:GraphicFill" ) );
2843 fillElem.appendChild( graphicFillElem );
2845 QDomElement graphicElem = doc.createElement( QStringLiteral(
"se:Graphic" ) );
2846 graphicFillElem.appendChild( graphicElem );
2849 QColor lineColor = mFillLineSymbol ? mFillLineSymbol->
color() : QColor();
2850 double lineWidth = mFillLineSymbol ? mFillLineSymbol->
width() : 0.0;
2858 double angle = props.value( QStringLiteral(
"angle" ), QStringLiteral(
"0" ) ).toDouble( &ok );
2861 angleFunc = QStringLiteral(
"%1 + %2" ).arg( props.value( QStringLiteral(
"angle" ), QStringLiteral(
"0" ) ) ).arg(
mLineAngle );
2865 angleFunc = QString::number( angle +
mLineAngle );
2877 QString featureStyle;
2878 featureStyle.append(
"Brush(" );
2879 featureStyle.append( QStringLiteral(
"fc:%1" ).arg(
mColor.name() ) );
2880 featureStyle.append( QStringLiteral(
",bc:%1" ).arg( QStringLiteral(
"#00000000" ) ) );
2881 featureStyle.append(
",id:\"ogr-brush-2\"" );
2882 featureStyle.append( QStringLiteral(
",a:%1" ).arg(
mLineAngle ) );
2883 featureStyle.append( QStringLiteral(
",s:%1" ).arg(
mLineWidth * widthScaleFactor ) );
2884 featureStyle.append(
",dx:0mm" );
2885 featureStyle.append( QStringLiteral(
",dy:%1mm" ).arg(
mDistance * widthScaleFactor ) );
2886 featureStyle.append(
')' );
2887 return featureStyle;
2910 applyPattern( context,
mBrush, lineAngle, distance );
2920 Qt::PenStyle lineStyle;
2922 QDomElement fillElem = element.firstChildElement( QStringLiteral(
"Fill" ) );
2923 if ( fillElem.isNull() )
2926 QDomElement graphicFillElem = fillElem.firstChildElement( QStringLiteral(
"GraphicFill" ) );
2927 if ( graphicFillElem.isNull() )
2930 QDomElement graphicElem = graphicFillElem.firstChildElement( QStringLiteral(
"Graphic" ) );
2931 if ( graphicElem.isNull() )
2937 if ( name != QLatin1String(
"horline" ) )
2945 double d = angleFunc.toDouble( &ok );
2954 offset = std::sqrt( std::pow( vectOffset.x(), 2 ) + std::pow( vectOffset.y(), 2 ) );
2957 QString uom = element.attribute( QStringLiteral(
"uom" ) );
2962 sl->
setOutputUnit( QgsUnitTypes::RenderUnit::RenderPixels );
2970 QDomElement strokeElem = element.firstChildElement( QStringLiteral(
"Stroke" ) );
2971 if ( !strokeElem.isNull() )
3052 if ( properties.contains( QStringLiteral(
"distance_x" ) ) )
3054 layer->
setDistanceX( properties[QStringLiteral(
"distance_x" )].toDouble() );
3056 if ( properties.contains( QStringLiteral(
"distance_y" ) ) )
3058 layer->
setDistanceY( properties[QStringLiteral(
"distance_y" )].toDouble() );
3060 if ( properties.contains( QStringLiteral(
"displacement_x" ) ) )
3062 layer->
setDisplacementX( properties[QStringLiteral(
"displacement_x" )].toDouble() );
3064 if ( properties.contains( QStringLiteral(
"displacement_y" ) ) )
3066 layer->
setDisplacementY( properties[QStringLiteral(
"displacement_y" )].toDouble() );
3069 if ( properties.contains( QStringLiteral(
"distance_x_unit" ) ) )
3073 if ( properties.contains( QStringLiteral(
"distance_x_map_unit_scale" ) ) )
3077 if ( properties.contains( QStringLiteral(
"distance_y_unit" ) ) )
3081 if ( properties.contains( QStringLiteral(
"distance_y_map_unit_scale" ) ) )
3085 if ( properties.contains( QStringLiteral(
"displacement_x_unit" ) ) )
3089 if ( properties.contains( QStringLiteral(
"displacement_x_map_unit_scale" ) ) )
3093 if ( properties.contains( QStringLiteral(
"displacement_y_unit" ) ) )
3097 if ( properties.contains( QStringLiteral(
"displacement_y_map_unit_scale" ) ) )
3101 if ( properties.contains( QStringLiteral(
"outline_width_unit" ) ) )
3105 if ( properties.contains( QStringLiteral(
"outline_width_map_unit_scale" ) ) )
3117 return QStringLiteral(
"PointPatternFill" );
3128 if ( width > 10000 || height > 10000 )
3131 brush.setTextureImage( img );
3135 QImage patternImage( width, height, QImage::Format_ARGB32 );
3136 patternImage.fill( 0 );
3140 QPainter p( &patternImage );
3150 p.setRenderHint( QPainter::Antialiasing,
true );
3179 QImage transparentImage = patternImage.copy();
3181 brush.setTextureImage( transparentImage );
3185 brush.setTextureImage( patternImage );
3187 QTransform brushTransform;
3188 brush.setTransform( brushTransform );
3212 map.insert( QStringLiteral(
"distance_x" ), QString::number(
mDistanceX ) );
3213 map.insert( QStringLiteral(
"distance_y" ), QString::number(
mDistanceY ) );
3214 map.insert( QStringLiteral(
"displacement_x" ), QString::number(
mDisplacementX ) );
3215 map.insert( QStringLiteral(
"displacement_y" ), QString::number(
mDisplacementY ) );
3245 QDomElement symbolizerElem = doc.createElement( QStringLiteral(
"se:PolygonSymbolizer" ) );
3246 if ( !props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ).isEmpty() )
3247 symbolizerElem.setAttribute( QStringLiteral(
"uom" ), props.value( QStringLiteral(
"uom" ), QLatin1String(
"" ) ) );
3248 element.appendChild( symbolizerElem );
3253 QDomElement fillElem = doc.createElement( QStringLiteral(
"se:Fill" ) );
3254 symbolizerElem.appendChild( fillElem );
3256 QDomElement graphicFillElem = doc.createElement( QStringLiteral(
"se:GraphicFill" ) );
3257 fillElem.appendChild( graphicFillElem );
3264 symbolizerElem.appendChild( distanceElem );
3270 QString errorMsg = QStringLiteral(
"MarkerSymbolLayerV2 expected, %1 found. Skip it." ).arg( layer->
layerType() );
3271 graphicFillElem.appendChild( doc.createComment( errorMsg ) );
3282 Q_UNUSED( element );
3335 applyPattern( context,
mBrush, distanceX, distanceY, displacementX, displacementY );
3377 if ( properties.contains( QStringLiteral(
"point_on_surface" ) ) )
3378 sl->
setPointOnSurface( properties[QStringLiteral(
"point_on_surface" )].toInt() != 0 );
3379 if ( properties.contains( QStringLiteral(
"point_on_all_parts" ) ) )
3380 sl->
setPointOnAllParts( properties[QStringLiteral(
"point_on_all_parts" )].toInt() != 0 );
3389 return QStringLiteral(
"CentroidFill" );
3394 mMarker->setColor( color );
3400 return mMarker ? mMarker->color() :
mColor;
3405 mMarker->setOpacity( context.
opacity() );
3408 mCurrentFeatureId = -1;
3409 mBiggestPartIndex = 0;
3421 if ( !mPointOnAllParts )
3426 if ( feature->
id() != mCurrentFeatureId )
3428 mCurrentFeatureId = feature->
id();
3429 mBiggestPartIndex = 1;
3437 double areaBiggest = 0;
3441 if ( area > areaBiggest )
3444 mBiggestPartIndex = i + 1;
3452 if ( mPointOnAllParts || ( context.
geometryPartNum() == mBiggestPartIndex ) )
3462 map[QStringLiteral(
"point_on_surface" )] = QString::number( mPointOnSurface );
3463 map[QStringLiteral(
"point_on_all_parts" )] = QString::number( mPointOnAllParts );
3485 mMarker->toSld( doc, element, props );
3498 std::unique_ptr< QgsMarkerSymbol > marker(
new QgsMarkerSymbol( layers ) );
3508 return mMarker.get();
3519 mMarker.reset( static_cast<QgsMarkerSymbol *>( symbol ) );
3520 mColor = mMarker->color();
3529 attributes.unite( mMarker->usedAttributes( context ) );
3538 mMarker->setOutputUnit( unit );
3546 return mMarker->outputUnit();
3555 mMarker->setMapUnitScale( scale );
3563 return mMarker->mapUnitScale();
3573 , mImageFilePath( imageFilePath )
3587 if ( properties.contains( QStringLiteral(
"imageFile" ) ) )
3589 imagePath = properties[QStringLiteral(
"imageFile" )];
3591 if ( properties.contains( QStringLiteral(
"coordinate_mode" ) ) )
3593 mode =
static_cast< FillCoordinateMode >( properties[QStringLiteral(
"coordinate_mode" )].toInt() );
3595 if ( properties.contains( QStringLiteral(
"alpha" ) ) )
3597 alpha = properties[QStringLiteral(
"alpha" )].toDouble();
3599 if ( properties.contains( QStringLiteral(
"offset" ) ) )
3603 if ( properties.contains( QStringLiteral(
"angle" ) ) )
3605 angle = properties[QStringLiteral(
"angle" )].toDouble();
3607 if ( properties.contains( QStringLiteral(
"width" ) ) )
3609 width = properties[QStringLiteral(
"width" )].toDouble();
3617 if ( properties.contains( QStringLiteral(
"offset_unit" ) ) )
3621 if ( properties.contains( QStringLiteral(
"offset_map_unit_scale" ) ) )
3625 if ( properties.contains( QStringLiteral(
"width_unit" ) ) )
3629 if ( properties.contains( QStringLiteral(
"width_map_unit_scale" ) ) )
3641 QgsStringMap::iterator it = properties.find( QStringLiteral(
"imageFile" ) );
3642 if ( it != properties.end() )
3645 it.value() = pathResolver.
writePath( it.value() );
3647 it.value() = pathResolver.
readPath( it.value() );
3659 return QStringLiteral(
"RasterFill" );
3675 p->translate( offset );
3679 QRectF boundingRect = points.boundingRect();
3680 mBrush.setTransform(
mBrush.transform().translate( boundingRect.left() -
mBrush.transform().dx(),
3681 boundingRect.top() -
mBrush.transform().dy() ) );
3687 p->translate( -offset );
3698 Q_UNUSED( context );
3705 map[QStringLiteral(
"coordinate_mode" )] = QString::number(
mCoordinateMode );
3706 map[QStringLiteral(
"alpha" )] = QString::number(
mOpacity );
3710 map[QStringLiteral(
"angle" )] = QString::number(
mAngle );
3711 map[QStringLiteral(
"width" )] = QString::number(
mWidth );
3764 if ( !hasWidthExpression && !hasAngleExpression && !hasOpacityExpression && !hasFileExpression )
3770 if ( hasAngleExpression )
3778 if ( !hasWidthExpression && !hasOpacityExpression && !hasFileExpression )
3784 if ( hasWidthExpression )
3790 if ( hasOpacityExpression )
3796 if ( hasFileExpression )
3801 applyPattern(
mBrush, file, width, opacity, context );
3807 if ( image.isNull() )
3811 if ( !image.hasAlphaChannel() )
3813 image = image.convertToFormat( QImage::Format_ARGB32 );
3823 pixelWidth = image.width();
3831 p.setCompositionMode( QPainter::CompositionMode_DestinationIn );
3832 QColor alphaColor( 0, 0, 0 );
3833 alphaColor.setAlphaF( alpha );
3834 p.fillRect( image.rect(), alphaColor );
3841 image = image.scaledToWidth( pixelWidth, Qt::SmoothTransformation );
3844 brush.setTextureImage( image );
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
static void wellKnownMarkerToSld(QDomDocument &doc, QDomElement &element, const QString &name, const QColor &color, const QColor &strokeColor, Qt::PenStyle strokeStyle, double strokeWidth=-1, double size=-1)
const QgsMapUnitScale & intervalMapUnitScale() const
QgsMapUnitScale mapUnitScale() const override
QColor color2() const
Returns the color used for the endpoint of the shapeburst fill.
void setSvgStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
#define DEFAULT_SIMPLEFILL_BORDERCOLOR
QPicture svgAsPicture(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, bool forceVectorOutput=false, double fixedAspectRatio=0)
Gets SVG as QPicture&.
QgsUnitTypes::RenderUnit mStrokeWidthUnit
QgsMapUnitScale mapUnitScale() const override
void setForceVectorOutput(bool force)
static QgsSymbolLayer * createFromSld(QDomElement &element)
QgsImageFillSymbolLayer()
static QgsSvgCache * svgCache()
Returns the application's SVG cache, used for caching SVG images and handling parameter replacement w...
double interval() const
Returns the interval between individual markers.
void stopRender(QgsSymbolRenderContext &context) override
QgsSimpleFillSymbolLayer(const QColor &color=DEFAULT_SIMPLEFILL_COLOR, Qt::BrushStyle style=DEFAULT_SIMPLEFILL_STYLE, const QColor &strokeColor=DEFAULT_SIMPLEFILL_BORDERCOLOR, Qt::PenStyle strokeStyle=DEFAULT_SIMPLEFILL_BORDERSTYLE, double strokeWidth=DEFAULT_SIMPLEFILL_BORDERWIDTH, Qt::PenJoinStyle penJoinStyle=DEFAULT_SIMPLEFILL_JOINSTYLE)
QColor valueAsColor(int key, const QgsExpressionContext &context, const QColor &defaultColor=QColor(), bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a color...
void setDistance(double d)
Sets the distance between lines in the fill pattern.
Gradient reference point 1 is centroid.
QgsSimpleFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
double mStrokeWidth
Stroke width.
double rendererScale() const
Returns the renderer map scale.
Qt::BrushStyle mBrushStyle
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QgsUnitTypes::RenderUnit mDisplacementXUnit
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
double symbologyScale() const
Returns the reference scale for output.
void setColorRamp(QgsColorRamp *ramp)
Sets the color ramp used for the gradient fill.
QString svgFilePath() const
void setPatternWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the width of the SVG images in the pattern.
QColor strokeColor() const override
Gets stroke color.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
static Qt::BrushStyle decodeBrushStyle(const QString &str)
static QDomElement createVendorOptionElement(QDomDocument &doc, const QString &name, const QString &value)
FillCoordinateMode mCoordinateMode
QgsSVGFillSymbolLayer(const QString &svgFilePath, double width=20, double rotation=0.0)
Constructs SVG fill symbol layer with picture from given absolute path to a SVG file.
#define DEFAULT_SIMPLEFILL_JOINSTYLE
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
Gradient reference point 1 x.
QByteArray getImageData(const QString &path) const
Gets image data.
QgsFields fields() const
Fields of the layer.
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the fill's offset.
QgsMapUnitScale mStrokeWidthMapUnitScale
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
QgsRasterFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
QgsMapUnitScale mLineWidthMapUnitScale
Qt::PenStyle mStrokeStyle
void stopRender(QgsSymbolRenderContext &context) override
void setSvgFillColor(const QColor &c)
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
void setPatternWidthMapUnitScale(const QgsMapUnitScale &scale)
QString layerType() const override
Returns a string that represents this layer type.
~QgsSVGFillSymbolLayer() override
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double...
void setColor(const QColor &c) override
The fill color.
QString imageFilePath() const
The path to the raster image used for the fill.
QPointF offset() const
Returns the offset for the shapeburst fill.
Use antialiasing while drawing.
QString readPath(const QString &filename) const
Turn filename read from the project file to an absolute path.
QgsMapUnitScale mapUnitScale() const override
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
GradientCoordinateMode coordinateMode() const
Coordinate mode for gradient. Controls how the gradient stops are positioned.
QImage svgAsImage(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, bool &fitsInCache, double fixedAspectRatio=0)
Gets SVG as QImage.
QColor dxfColor(QgsSymbolRenderContext &context) const override
Gets color.
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
virtual QgsColorRamp * clone() const =0
Creates a clone of the color ramp.
void startRender(QgsSymbolRenderContext &context) override
void stopRender(QgsSymbolRenderContext &context) override
QgsPointPatternFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setReferencePoint1IsCentroid(bool isCentroid)
Sets the starting point of the gradient to be the feature centroid.
Qt::PenJoinStyle penJoinStyle() const
GradientSpread gradientSpread() const
Gradient spread mode. Controls how the gradient behaves outside of the predefined stops...
QgsLinePatternFillSymbolLayer()
QgsUnitTypes::RenderUnit mOffsetUnit
QgsMapUnitScale mapUnitScale() const override
Base class for polygon renderers generating texture images.
QgsMapUnitScale mPatternWidthMapUnitScale
void setColorRamp(QgsColorRamp *ramp)
Sets the color ramp used to draw the shapeburst fill.
void startRender(QgsSymbolRenderContext &context) override
void setDisplacementYUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the vertical displacement between rows in the pattern.
void stopRender(QgsSymbolRenderContext &context) override
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
void setOffset(QPointF offset)
Sets the offset for the shapeburst fill.
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
void applyDataDefinedSettings(QgsSymbolRenderContext &context) override
QgsUnitTypes::RenderUnit patternWidthUnit() const
Returns the units for the width of the SVG images in the pattern.
void setAngle(double angle)
void startRender(QgsSymbolRenderContext &context) override
Abstract base class for color ramps.
static QString ogrFeatureStyleBrush(const QColor &fillColr)
Create ogr feature style string for brush.
Helper functions for various unit types.
QString ogrFeatureStyle(double mmScaleFactor, double mapUnitScaleFactor) const override
void setRendererScale(double scale)
Sets the renderer map scale.
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
virtual QColor strokeColor() const
Gets stroke color.
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
void renderPolyline(const QPolygonF &points, const QgsFeature *f, QgsRenderContext &context, int layer=-1, bool selected=false)
static bool displacementFromSldElement(QDomElement &element, QPointF &offset)
QgsUnitTypes::RenderUnit mSvgStrokeWidthUnit
static QPointF decodePoint(const QString &string)
Decodes a QSizeF from a string.
QString layerType() const override
Returns a string that represents this layer type.
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
void setDistanceUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary...
ShapeburstColorType colorType() const
Returns the color mode used for the shapeburst fill.
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
QgsMapUnitScale mapUnitScale() const override
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
~QgsGradientFillSymbolLayer() override
static QString encodeMapUnitScale(const QgsMapUnitScale &mapUnitScale)
void setDistanceUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the distance between lines in the fill pattern.
static void createDisplacementElement(QDomDocument &doc, QDomElement &element, QPointF offset)
A geometry is the spatial representation of a feature.
void restoreOldDataDefinedProperties(const QgsStringMap &stringMap)
Restores older data defined properties from string map.
static double sizeInPixelsFromSldUom(const QString &uom, double size)
Returns the size scaled in pixels according to the uom attribute.
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
void _renderPolygon(QPainter *p, const QPolygonF &points, const QList< QPolygonF > *rings, QgsSymbolRenderContext &context)
Default method to render polygon.
bool useWholeShape() const
Returns whether the shapeburst fill is set to cover the entire shape.
void setOffsetUnit(const QgsUnitTypes::RenderUnit unit)
Sets the units for the fill's offset.
Flags flags() const
Returns combination of flags used for rendering.
static QgsSymbolLayer * createFromSld(QDomElement &element)
int symbolLayerCount() const
Returns total number of symbol layers contained in the symbol.
void setDistanceXMapUnitScale(const QgsMapUnitScale &scale)
static QgsColorRamp * create(const QgsStringMap &properties=QgsStringMap())
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
#define DEFAULT_SIMPLEFILL_COLOR
QgsUnitTypes::DistanceUnit mapUnits() const
Retrieve map units.
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
double mDistance
Distance (in mm or map units) between lines.
void startRender(QgsSymbolRenderContext &context) override
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
static bool rotationFromSldElement(QDomElement &element, QString &rotationFunc)
QColor color2() const
Color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoColor.
QgsGradientFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
double mLineAngle
Vector line angle in degrees (0 = horizontal, counterclockwise)
void setReferencePoint2IsCentroid(bool isCentroid)
Sets the end point of the gradient to be the feature centroid.
QgsUnitTypes::RenderUnit mDistanceUnit
GradientColorType mGradientColorType
const QgsMapUnitScale & svgStrokeWidthMapUnitScale() const
virtual QColor color(double value) const =0
Returns the color corresponding to a specified value.
QColor color() const override
The fill color.
QgsMapUnitScale mDistanceYMapUnitScale
void setPointOnAllParts(bool pointOnAllParts)
Sets whether a point is drawn for all parts or only on the biggest part of multi-part features...
QPointF referencePoint1() const
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
QString layerType() const override
Returns a string that represents this layer type.
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
QMap< QString, QString > QgsStringMap
Shapeburst use whole shape.
static QString encodePoint(QPointF point)
Encodes a QPointF to a string.
static QgsSymbolLayer * createFromSld(QDomElement &element)
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
void setStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the symbol's stroke width.
QColor color() const override
The fill color.
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
void startRender(QgsRenderContext &context, const QgsFields &fields=QgsFields())
Begins the rendering process for the symbol.
QgsUnitTypes::RenderUnit mStrokeWidthUnit
Gradient reference point 2 y.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
QgsMapUnitScale mapUnitScale() const override
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
void setInterval(double interval)
Sets the interval between individual markers.
void setMapUnitScale(const QgsMapUnitScale &scale) override
#define DEFAULT_SIMPLEFILL_STYLE
static QString encodeColor(const QColor &color)
QgsMapUnitScale mDisplacementYMapUnitScale
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the line pattern's offset.
void setCoordinateMode(FillCoordinateMode mode)
Set the coordinate mode for fill.
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
void setOutputUnit(QgsUnitTypes::RenderUnit unit)
Sets the units to use for sizes and widths within the symbol.
void setOffset(QPointF offset)
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
static QPointF pointOnLineWithDistance(QPointF startPoint, QPointF directionPoint, double distance)
Returns a point on the line from startPoint to directionPoint that is a certain distance away from th...
QPointF referencePoint2() const
QVariant value(int key, const QgsExpressionContext &context, const QVariant &defaultValue=QVariant()) const override
Returns the calculated value of the property with the specified key from within the collection...
void renderPoint(QPointF point, const QgsFeature *f, QgsRenderContext &context, int layer=-1, bool selected=false)
QString layerType() const override
Returns a string that represents this layer type.
QgsUnitTypes::RenderUnit mOffsetUnit
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
QString mImageFilePath
Path to the image file.
static QString encodePenStyle(Qt::PenStyle style)
Perform transforms between map coordinates and device coordinates.
void setIgnoreRings(bool ignoreRings)
Sets whether the shapeburst fill should ignore polygon rings when calculating the buffered shading...
virtual void writeSldMarker(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const
Writes the symbol layer definition as a SLD XML element.
static QString svgSymbolPathToName(const QString &path, const QgsPathResolver &pathResolver)
Determines an SVG symbol's name from its path.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QgsUnitTypes::RenderUnit mOffsetUnit
static double rescaleUom(double size, QgsUnitTypes::RenderUnit unit, const QgsStringMap &props)
Rescales the given size based on the uomScale found in the props, if any is found, otherwise returns the value un-modified.
void setLineAngle(double a)
QgsLinePatternFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setImageFilePath(const QString &imagePath)
Sets the path to the raster image used for the fill.
double strokeWidth() const
double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets line width.
std::unique_ptr< QgsLineSymbol > mStroke
Custom stroke.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
A class for filling symbols with a repeated raster image.
QByteArray mSvgData
SVG data.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
QgsMapUnitScale mDistanceXMapUnitScale
#define DEFAULT_SIMPLEFILL_BORDERWIDTH
QColor dxfBrushColor(QgsSymbolRenderContext &context) const override
Gets brush/fill color.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
void setWidth(const double width)
Sets the width for scaling the image used in the fill.
double mOffset
Offset perpendicular to line direction.
static const bool SELECT_FILL_STYLE
Whether fill styles for selected features uses symbol layer style.
void setColor(const QColor &color) override
The fill color.
void setReferencePoint1(QPointF referencePoint)
Starting point of gradient fill, in the range [0,0] - [1,1].
QgsUnitTypes::RenderUnit mWidthUnit
void setSvgStrokeWidth(double w)
GradientType mGradientType
void setWidth(double width)
qreal opacity() const
Returns the opacity for the symbol.
static QgsSymbolLayer * createFromSld(QDomElement &element)
double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets line width.
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
Gradient coordinate mode.
bool mReferencePoint1IsCentroid
void setWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the image's width.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides...
double displacementX() const
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
static double mapUnitScaleFactor(double scale, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
virtual QColor color() const
The fill color.
static void resolvePaths(QgsStringMap &properties, const QgsPathResolver &pathResolver, bool saving)
Turns relative paths in properties map to absolute when reading and vice versa when writing...
static QgsSymbolLayer * createMarkerLayerFromSld(QDomElement &element)
static void createRotationElement(QDomDocument &doc, QDomElement &element, const QString &rotationFunc)
void setDistanceYMapUnitScale(const QgsMapUnitScale &scale)
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
Filename, eg for svg files.
QColor selectionColor() const
QgsGradientFillSymbolLayer(const QColor &color=DEFAULT_SIMPLEFILL_COLOR, const QColor &color2=Qt::white, GradientColorType gradientColorType=SimpleTwoColor, GradientType gradientType=Linear, GradientCoordinateMode coordinateMode=Feature, GradientSpread gradientSpread=Pad)
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
QgsMapUnitScale mOffsetMapUnitScale
void startRender(QgsSymbolRenderContext &context) override
QList< QgsSymbolLayer * > QgsSymbolLayerList
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
QgsUnitTypes::RenderUnit mOffsetUnit
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
Shapeburst fill from edge distance.
void setMapUnitScale(const QgsMapUnitScale &scale) override
QgsSymbol::SymbolType type() const
bool ignoreRings() const
Returns whether the shapeburst fill is set to ignore polygon interior rings.
virtual double area() const
Returns the area of the geometry.
static void parametricSvgToSld(QDomDocument &doc, QDomElement &graphicElem, const QString &path, const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth)
Encodes a reference to a parametric SVG into SLD, as a succession of parametric SVG using URL paramet...
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
virtual QString type() const =0
Returns a string representing the color ramp type.
QString layerType() const override
Returns a string that represents this layer type.
static Q_INVOKABLE QgsUnitTypes::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
static bool lineFromSld(QDomElement &element, Qt::PenStyle &penStyle, QColor &color, double &width, Qt::PenJoinStyle *penJoinStyle=nullptr, Qt::PenCapStyle *penCapStyle=nullptr, QVector< qreal > *customDashPattern=nullptr, double *dashOffset=nullptr)
QgsGeometry geometry() const
Returns the geometry associated with this feature.
void stopRender(QgsSymbolRenderContext &context) override
double mapUnitsPerPixel() const
Returns current map units per pixel.
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
QColor fillColor() const override
Gets fill color.
QgsUnitTypes::RenderUnit svgStrokeWidthUnit() const
Returns the units for the stroke width.
QColor svgStrokeColor() const
QgsMapUnitScale mDisplacementXMapUnitScale
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
void stopRender(QgsSymbolRenderContext &context) override
void setLineWidthMapUnitScale(const QgsMapUnitScale &scale)
QColor color() const override
The fill color.
QgsSymbolLayer * symbolLayer(int layer)
Returns a specific symbol layers contained in the symbol.
QgsSymbol * subSymbol() override
Returns the symbol's sub symbol, if present.
void setDisplacementXMapUnitScale(const QgsMapUnitScale &scale)
QgsMapUnitScale mOffsetMapUnitScale
static Qt::PenStyle decodePenStyle(const QString &str)
void setOffset(QPointF offset)
Sets the offset for the fill.
static bool externalGraphicFromSld(QDomElement &element, QString &path, QString &mime, QColor &color, double &size)
bool mReferencePoint2IsCentroid
static void premultiplyColor(QColor &rgb, int alpha)
Converts a QColor into a premultiplied ARGB QColor value using a specified alpha value.
static void resolvePaths(QgsStringMap &properties, const QgsPathResolver &pathResolver, bool saving)
Turns relative paths in properties map to absolute when reading and vice versa when writing...
void applyDataDefinedSettings(QgsSymbolRenderContext &context) override
QString mSvgFilePath
Path to the svg file (or empty if constructed directly from data)
virtual double estimateMaxBleed(const QgsRenderContext &context) const
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
static bool fillFromSld(QDomElement &element, Qt::BrushStyle &brushStyle, QColor &color)
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
double mLineWidth
Line width (in mm or map units)
QgsShapeburstFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setSvgStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the stroke width.
Gradient reference point 1 y.
~QgsPointPatternFillSymbolLayer() override
void setOffset(QPointF offset)
Offset for gradient fill.
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
QgsMapUnitScale mapUnitScale() const override
static void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
QgsMapUnitScale mapUnitScale() const override
double dxfAngle(QgsSymbolRenderContext &context) const override
Gets angle.
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
void setDistanceXUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the horizontal distance between points in the pattern.
void setMapUnitScale(const QgsMapUnitScale &scale) override
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
void setDisplacementY(double d)
QgsExpressionContext & expressionContext()
Gets the expression context.
void containsParams(const QString &path, bool &hasFillParam, QColor &defaultFillColor, bool &hasStrokeParam, QColor &defaultStrokeColor, bool &hasStrokeWidthParam, double &defaultStrokeWidth) const
Tests if an svg file contains parameters for fill, stroke color, stroke width.
QString layerType() const override
Returns a string that represents this layer type.
void startRender(QgsSymbolRenderContext &context) override
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
QString layerType() const override
Returns a string that represents this layer type.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
int geometryPartNum() const
Part number of current geometry.
bool valueAsBool(int key, const QgsExpressionContext &context, bool defaultValue=false, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as an boolean...
GradientCoordinateMode mCoordinateMode
GradientType gradientType() const
Type of gradient, e.g., linear or radial.
QgsRasterFillSymbolLayer(const QString &imageFilePath=QString())
GradientSpread mGradientSpread
void setLineWidth(double w)
void setMapUnitScale(const QgsMapUnitScale &scale) override
static QPointF polygonCentroid(const QPolygonF &points)
Calculate the centroid point of a QPolygonF.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QgsMapUnitScale mWidthMapUnitScale
static QgsColorRamp * create(const QgsStringMap &properties=QgsStringMap())
Creates a new QgsColorRamp from a map of properties.
QgsUnitTypes::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
QString valueAsString(int key, const QgsExpressionContext &context, const QString &defaultString=QString(), bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a string...
A class for svg fill patterns.
void setMapUnitScale(const QgsMapUnitScale &scale) override
Stroke style (eg solid, dashed)
QgsSymbol * subSymbol() override
Returns the symbol's sub symbol, if present.
QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns a list of attributes required to render this feature.
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
Contains information about the context of a rendering operation.
Abstract base class for marker symbol layers.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to painter units (pixels).
QgsUnitTypes::RenderUnit mLineWidthUnit
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
QString layerType() const override
Returns a string that represents this layer type.
QgsCentroidFillSymbolLayer()
QgsCentroidFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
QPainter * painter()
Returns the destination QPainter for the render operation.
const QgsMapToPixel & mapToPixel() const
Qt::BrushStyle dxfBrushStyle() const override
Gets brush/fill style.
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
static void blurImageInPlace(QImage &image, QRect rect, int radius, bool alphaOnly)
Blurs an image in place, e.g. creating Qt-independent drop shadows.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
bool hasDataDefinedProperties() const
Returns whether the symbol utilizes any data defined properties.
QgsPointPatternFillSymbolLayer()
QColor svgFillColor() const
static QgsSymbolLayer * create(const QgsStringMap &properties=QgsStringMap())
void setWidthUnit(const QgsUnitTypes::RenderUnit unit)
Sets the units for the image's width.
~QgsShapeburstFillSymbolLayer() override
Struct for storing maximum and minimum scales for measurements in map units.
QgsMapUnitScale mDistanceMapUnitScale
static QString encodeBrushStyle(Qt::BrushStyle style)
const QgsMapUnitScale & patternWidthMapUnitScale() const
void applyDataDefinedSettings(QgsSymbolRenderContext &context) override
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
void setSvgFilePath(const QString &svgPath)
virtual QgsStringMap properties() const =0
Returns a string map containing all the color ramp's properties.
QString ogrFeatureStyleWidth(double widthScaleFactor) const
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
Qt::PenStyle strokeStyle() const
void setStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the width of the fill's stroke.
static const bool SELECTION_IS_OPAQUE
Whether styles for selected features ignore symbol alpha.
const QgsFeature * feature() const
Current feature being rendered - may be null.
#define DEFAULT_SIMPLEFILL_BORDERSTYLE
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
GradientColorType gradientColorType() const
Gradient color mode, controls how gradient color stops are created.
Qt::PenJoinStyle mPenJoinStyle
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
void setMapToPixel(const QgsMapToPixel &mtp)
QgsColorRamp * mGradientRamp
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
QColor dxfColor(QgsSymbolRenderContext &context) const override
Gets color.
double patternWidth() const
static QgsSymbolLayer * createFromSld(QDomElement &element)
void setDisplacementXUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the horizontal displacement between rows in the pattern.
void setDistanceY(double d)
Secondary color (eg for gradient fills)
static bool wellKnownMarkerFromSld(QDomElement &element, QString &name, QColor &color, QColor &strokeColor, Qt::PenStyle &strokeStyle, double &strokeWidth, double &size)
QgsMarkerSymbol * mMarkerSymbol
double maxDistance() const
Returns the maximum distance from the shape's boundary which is shaded.
QString writePath(const QString &filename) const
Prepare a filename to save it to the project file.
void setDisplacementYMapUnitScale(const QgsMapUnitScale &scale)
void applyDataDefinedSettings(QgsSymbolRenderContext &context) override
void setFlag(Flag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
double opacity() const
Returns the opacity for the raster image used in the fill.
static QgsMapUnitScale decodeMapUnitScale(const QString &str)
static QgsSymbolLayer * createLineLayerFromSld(QDomElement &element)
void setMapUnitScale(const QgsMapUnitScale &scale) override
static const bool SELECT_FILL_BORDER
Whether fill styles for selected features also highlight symbol stroke.
void setOutputUnit(QgsUnitTypes::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
void setDistanceX(double d)
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
void setMapUnitScale(const QgsMapUnitScale &scale) override
static void fillToSld(QDomDocument &doc, QDomElement &element, Qt::BrushStyle brushStyle, const QColor &color=QColor())
static void lineToSld(QDomDocument &doc, QDomElement &element, Qt::PenStyle penStyle, const QColor &color, double width=-1, const Qt::PenJoinStyle *penJoinStyle=nullptr, const Qt::PenCapStyle *penCapStyle=nullptr, const QVector< qreal > *customDashPattern=nullptr, double dashOffset=0.0)
void setColor(const QColor &c) override
The fill color.
Qt::PenStyle dxfPenStyle() const override
Gets pen style.
double svgStrokeWidth() const
static QString svgSymbolNameToPath(const QString &name, const QgsPathResolver &pathResolver)
Determines an SVG symbol's path from its name.
QgsUnitTypes::RenderUnit mDistanceXUnit
int blurRadius() const
Returns the blur radius, which controls the amount of blurring applied to the fill.
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the units used for the offset for the shapeburst fill.
bool testFlag(Flag flag) const
Check whether a particular flag is enabled.
static QPointF polygonPointOnSurface(const QPolygonF &points)
Calculate a point within of a QPolygonF.
void setOffset(double offset)
QgsUnitTypes::RenderUnit mDisplacementYUnit
void stopRender(QgsSymbolRenderContext &context) override
Resolves relative paths into absolute paths and vice versa.
void setLineWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the line's width.
Draw map such that there are no problems between adjacent tiles.
void setOpacity(double opacity)
Sets the opacity for the raster image used in the fill.
void startRender(QgsSymbolRenderContext &context) override
void setSvgStrokeColor(const QColor &c)
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Units for gradient fill offset.
void addStopsToGradient(QGradient *gradient, double opacity=1)
Copy color ramp stops to a QGradient.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
double distance() const
Returns the distance between lines in the fill pattern.
void stopRender(QgsSymbolRenderContext &context) override
Gradient color ramp, which smoothly interpolates between two colors and also supports optional extra ...
void renderPolygon(const QPolygonF &points, QList< QPolygonF > *rings, QgsSymbolRenderContext &context) override
Fill style (eg solid, dots)
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
void setDistanceYUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the vertical distance between points in the pattern.
double displacementY() const
virtual QColor fillColor() const
Gets fill color.
int valueAsInt(int key, const QgsExpressionContext &context, int defaultValue=0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as an integer...
static QString ogrFeatureStylePen(double width, double mmScaleFactor, double mapUnitsScaleFactor, const QColor &c, Qt::PenJoinStyle joinStyle=Qt::MiterJoin, Qt::PenCapStyle capStyle=Qt::FlatCap, double offset=0.0, const QVector< qreal > *dashPattern=nullptr)
Create ogr feature style string for pen.
static void multiplyImageOpacity(QImage *image, qreal opacity)
Multiplies opacity of image pixel values with a (global) transparency value.
void setDisplacementX(double d)
void stopRender(QgsRenderContext &context)
Ends the rendering process.
double width() const
Returns the width used for scaling the image used in the fill.
QgsUnitTypes::RenderUnit intervalUnit() const
Returns the units for the interval between markers.
QgsSVGFillSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
Gradient reference point 2 is centroid.
void setMapUnitScale(const QgsMapUnitScale &scale) override
QgsShapeburstFillSymbolLayer(const QColor &color=DEFAULT_SIMPLEFILL_COLOR, const QColor &color2=Qt::white, ShapeburstColorType colorType=SimpleTwoColor, int blurRadius=0, bool useWholeShape=true, double maxDistance=5)
QgsUnitTypes::RenderUnit mPatternWidthUnit
QgsMapUnitScale mOffsetMapUnitScale
static QString encodePenJoinStyle(Qt::PenJoinStyle style)
void setReferencePoint2(QPointF referencePoint)
End point of gradient fill, in the range [0,0] - [1,1].
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
Gradient reference point 2 x.
QgsPropertyCollection mDataDefinedProperties
QgsUnitTypes::RenderUnit mDistanceYUnit
void startRender(QgsSymbolRenderContext &context) override
int geometryPartCount() const
Part count of current geometry.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
Qt::PenStyle dxfPenStyle() const override
Gets pen style.
QgsMarkerSymbol * clone() const override
Gets a deep copy of this symbol.
~QgsLinePatternFillSymbolLayer() override
QgsMapUnitScale mSvgStrokeWidthMapUnitScale
RenderUnit
Rendering size units.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
static QColor decodeColor(const QString &str)
void copyDataDefinedProperties(QgsSymbolLayer *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
QgsMapUnitScale mStrokeWidthMapUnitScale
void setPointOnSurface(bool pointOnSurface)
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
QRectF mSvgViewBox
SVG view box (to keep the aspect ratio.
QImage * mSvgPattern
SVG pattern image.
QgsLineSymbol * clone() const override
Gets a deep copy of this symbol.
Horizontal distance between points.
QPointF offset() const
Returns the offset for the fill.
virtual QString layerType() const =0
Returns a string that represents this layer type.
double estimateMaxBleed(const QgsRenderContext &context) const override
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
void setColor(const QColor &color)
double mPatternWidth
Width of the pattern (in output units)
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
Vertical distance between points.
QgsMapUnitScale mOffsetMapUnitScale