62#define strcasecmp( a, b ) stricmp( a, b )
74 mMapSettings = settings;
89 QList<QgsMapLayer *> layerList;
91 mLayerNameAttribute.clear();
93 layerList.reserve( layers.size() );
94 for (
const DxfLayer &dxfLayer : layers )
96 layerList << dxfLayer.layer();
97 if ( dxfLayer.layerOutputAttributeIndex() >= 0 )
98 mLayerNameAttribute.insert( dxfLayer.layer()->id(), dxfLayer.layerOutputAttributeIndex() );
132 if ( !mForce2d && p.
is3D() && std::isfinite( p.
z() ) )
139 int minDist = std::numeric_limits<int>::max();
141 for (
int i = 1; i < static_cast< int >(
sizeof( sDxfColors ) /
sizeof( *sDxfColors ) ) && minDist > 0; ++i )
143 int dist = color_distance( color.rgba(), i );
144 if ( dist >= minDist )
151 if ( minDist == 0 && minDistAt != 7 )
155 if ( color.alpha() == 255 )
159 int c = ( color.red() & 0xff ) * 0x10000 + ( color.green() & 0xff ) * 0x100 + ( color.blue() & 0xff );
161 if ( transparencyCode != -1 && color.alpha() < 255 )
162 writeGroup( transparencyCode, 0x2000000 | color.alpha() );
167 mTextStream << QStringLiteral(
"%1\n" ).arg( code, 3, 10, QChar(
' ' ) );
172 mTextStream << QStringLiteral(
"%1\n" ).arg( i, 6, 10, QChar(
' ' ) );
178 if ( !s.contains(
'.' ) )
179 s += QLatin1String(
".0" );
180 mTextStream << s <<
'\n';
185 mTextStream << s <<
'\n';
195 if ( !d->isOpen() && !d->open( QIODevice::WriteOnly | QIODevice::Truncate ) )
200 mTextStream.setDevice( d );
201#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
202 mTextStream.setCodec( encoding.toLocal8Bit() );
204 mTextStream.setEncoding( QStringConverter::encodingForName( encoding.toLocal8Bit() ).value_or( QStringConverter::Utf8 ) );
212 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
227 mExtent = layerExtent;
263void QgsDxfExport::writeHeader(
const QString &codepage )
265 writeGroup( 999, QStringLiteral(
"DXF created from QGIS" ) );
271 writeGroup( 9, QStringLiteral(
"$ACADVER" ) );
283 writeGroup( 9, QStringLiteral(
"$LTSCALE" ) );
295 writeGroup( 9, QStringLiteral(
"$PSLTSCALE" ) );
298 writeGroup( 9, QStringLiteral(
"$HANDSEED" ) );
301 writeGroup( 9, QStringLiteral(
"$DWGCODEPAGE" ) );
310 handle = mNextHandleId++;
312 Q_ASSERT_X( handle <
DXF_HANDMAX,
"QgsDxfExport::writeHandle(int, int)",
"DXF handle too large" );
314 writeGroup( code, QString::number( handle, 16 ) );
318void QgsDxfExport::writeTables()
325 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > slList;
326 switch ( mSymbologyExport )
331 slList = symbolLayers( context );
344 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
347 writeDefaultLinetypes();
350 for (
const auto &symbolLayer : std::as_const( slList ) )
352 writeSymbolLayerLinetype( symbolLayer.first );
359 writeGroup( 2, QStringLiteral(
"BLOCK_RECORD" ) );
362 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
365 const QStringList blockStrings = QStringList() << QStringLiteral(
"*Model_Space" ) << QStringLiteral(
"*Paper_Space" ) << QStringLiteral(
"*Paper_Space0" );
366 for (
const QString &block : blockStrings )
368 writeGroup( 0, QStringLiteral(
"BLOCK_RECORD" ) );
370 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
371 writeGroup( 100, QStringLiteral(
"AcDbBlockTableRecord" ) );
376 for (
const auto &symbolLayer : std::as_const( slList ) )
382 if ( hasBlockBreakingDataDefinedProperties( ml, symbolLayer.second ) )
385 QString name = QStringLiteral(
"symbolLayer%1" ).arg( i++ );
386 writeGroup( 0, QStringLiteral(
"BLOCK_RECORD" ) );
388 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
389 writeGroup( 100, QStringLiteral(
"AcDbBlockTableRecord" ) );
399 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
403 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
404 writeGroup( 100, QStringLiteral(
"AcDbRegAppTableRecord" ) );
413 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
421 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
429 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
433 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
434 writeGroup( 100, QStringLiteral(
"AcDbViewportTableRecord" ) );
473 writeGroup( 2, QStringLiteral(
"DIMSTYLE" ) );
475 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
476 writeGroup( 100, QStringLiteral(
"AcDbDimStyleTable" ) );
480 QSet<QString> layerNames;
481 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
484 if ( !layerIsScaleBasedVisible( ml ) )
491 int attrIdx = mLayerNameAttribute.value( vl->
id(), -1 );
498 const QSet<QVariant> values = vl->
uniqueValues( attrIdx );
499 for (
const QVariant &v : values )
511 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
516 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
517 writeGroup( 100, QStringLiteral(
"AcDbLayerTableRecord" ) );
521 writeGroup( 6, QStringLiteral(
"CONTINUOUS" ) );
524 for (
const QString &
layerName : std::as_const( layerNames ) )
528 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
529 writeGroup( 100, QStringLiteral(
"AcDbLayerTableRecord" ) );
533 writeGroup( 6, QStringLiteral(
"CONTINUOUS" ) );
542 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
548 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
549 writeGroup( 100, QStringLiteral(
"AcDbTextStyleTableRecord" ) );
550 writeGroup( 2, QStringLiteral(
"STANDARD" ) );
557 writeGroup( 3, QStringLiteral(
"romans.shx" ) );
565void QgsDxfExport::writeBlocks()
570 static const QStringList blockStrings = QStringList() << QStringLiteral(
"*Model_Space" ) << QStringLiteral(
"*Paper_Space" ) << QStringLiteral(
"*Paper_Space0" );
571 for (
const QString &block : blockStrings )
575 writeGroup( 330, QString::number( mBlockHandles[ block ], 16 ) );
576 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
578 writeGroup( 100, QStringLiteral(
"AcDbBlockBegin" ) );
586 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
588 writeGroup( 100, QStringLiteral(
"AcDbBlockEnd" ) );
594 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > slList;
595 switch ( mSymbologyExport )
600 slList = symbolLayers( ct );
607 for (
const auto &symbolLayer : std::as_const( slList ) )
617 if ( hasBlockBreakingDataDefinedProperties( ml, symbolLayer.second ) )
622 QString block( QStringLiteral(
"symbolLayer%1" ).arg( mBlockCounter++ ) );
623 mBlockHandle = QString::number( mBlockHandles[ block ], 16 );
628 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
630 writeGroup( 100, QStringLiteral(
"AcDbBlockBegin" ) );
643 ml->
writeDxf( *
this,
mapUnitScaleFactor( mSymbologyScale, ml->
sizeUnit(), mMapUnits, ctx.renderContext().mapToPixel().mapUnitsPerPixel() ), QStringLiteral(
"0" ), ctx );
647 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
649 writeGroup( 100, QStringLiteral(
"AcDbBlockEnd" ) );
651 mPointSymbolBlocks.insert( ml, block );
652 mPointSymbolBlockSizes.insert( ml, ml->
dxfSize( *
this, ctx ) );
653 mPointSymbolBlockAngles.insert( ml, ml->
dxfAngle( ctx ) );
659void QgsDxfExport::writeEntities()
662 writeGroup( 2, QStringLiteral(
"ENTITIES" ) );
664 mBlockHandle = QString::number( mBlockHandles[ QStringLiteral(
"*Model_Space" )], 16 );
673 job->renderer->usingSymbolLevels() )
675 writeEntitiesSymbolLevels( job );
693 QString lName(
dxfLayerName( job->splitLayerAttribute.isNull() ? job->layerTitle : fet.attribute( job->splitLayerAttribute ).toString() ) );
695 sctx.setFeature( &fet );
697 if ( !job->renderer->willRenderFeature( fet, mRenderContext ) )
702 addFeature( sctx, ct, lName,
nullptr,
nullptr );
706 const QgsSymbolList symbolList = job->renderer->symbolsForFeature( fet, mRenderContext );
707 bool hasSymbology = symbolList.size() > 0;
719 bool isGeometryGenerator = ( symbolLayer->layerType() == QLatin1String(
"GeometryGenerator" ) );
720 if ( isGeometryGenerator )
722 addGeometryGeneratorSymbolLayer( sctx, ct, lName, symbolLayer,
true );
726 addFeature( sctx, ct, lName, symbolLayer, symbol );
731 else if ( hasSymbology )
742 addGeometryGeneratorSymbolLayer( sctx, ct, lName, s->
symbolLayer( 0 ),
false );
746 addFeature( sctx, ct, lName, s->
symbolLayer( 0 ), s );
750 if ( job->labelProvider )
752 job->labelProvider->registerFeature( fet, mRenderContext );
757 else if ( job->ruleBasedLabelProvider )
759 job->ruleBasedLabelProvider->registerFeature( fet, mRenderContext );
768 QImage image( 10, 10, QImage::Format_ARGB32_Premultiplied );
769 image.setDotsPerMeterX( 96 / 25.4 * 1000 );
770 image.setDotsPerMeterY( 96 / 25.4 * 1000 );
771 QPainter painter( &image );
779void QgsDxfExport::prepareRenderers()
781 Q_ASSERT( mJobs.empty() );
789 mExtent.
height() * mFactor, 0 ) );
795 mLabelingEngine = std::make_unique<QgsDefaultLabelingEngine>();
796 mLabelingEngine->setMapSettings( mMapSettings );
799 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
809 if ( !layerIsScaleBasedVisible( vl ) )
812 QString splitLayerAttribute;
813 int splitLayerAttributeIndex = mLayerNameAttribute.value( vl->
id(), -1 );
815 if ( splitLayerAttributeIndex >= 0 && splitLayerAttributeIndex < fields.
size() )
816 splitLayerAttribute = fields.
at( splitLayerAttributeIndex ).
name();
822void QgsDxfExport::writeEntitiesSymbolLevels(
DxfLayerJob *job )
824 QHash< QgsSymbol *, QList<QgsFeature> > features;
846 featureSymbol = job->
renderer->symbolForFeature( fet, ctx );
847 if ( !featureSymbol )
852 QHash< QgsSymbol *, QList<QgsFeature> >::iterator it = features.find( featureSymbol );
853 if ( it == features.end() )
855 it = features.insert( featureSymbol, QList<QgsFeature>() );
857 it.value().append( fet );
865 for (
int j = 0; j < symbol->symbolLayerCount(); j++ )
867 int level = symbol->symbolLayer( j )->renderingPass();
868 if ( level < 0 || level >= 1000 )
871 while ( level >= levels.count() )
873 levels[level].append( item );
882 QHash< QgsSymbol *, QList<QgsFeature> >::iterator levelIt = features.find( item.symbol() );
883 if ( levelIt == features.end() )
888 int llayer = item.layer();
889 const QList<QgsFeature> &featureList = levelIt.value();
890 for (
const QgsFeature &feature : featureList )
892 sctx.setFeature( &feature );
893 addFeature( sctx, ct, job->
layerName, levelIt.key()->symbolLayer( llayer ), levelIt.key() );
899void QgsDxfExport::stopRenderers()
905void QgsDxfExport::writeEndFile()
912void QgsDxfExport::startSection()
917void QgsDxfExport::endSection()
942 QHash< const QgsSymbolLayer *, QString >::const_iterator blockIt = mPointSymbolBlocks.constFind( symbolLayer );
943 if ( !symbolLayer || blockIt == mPointSymbolBlocks.constEnd() )
958 const double scale = symbolLayer->
dxfSize( *
this, ctx ) / mPointSymbolBlockSizes.value( symbolLayer );
963 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
964 writeGroup( 100, QStringLiteral(
"AcDbBlockReference" ) );
967 writeGroup( 50, mPointSymbolBlockAngles.value( symbolLayer ) - angle );
968 if ( std::isfinite( scale ) && scale != 1.0 )
982 QgsDebugError( QStringLiteral(
"writePolyline: empty line layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
988 QgsDebugError( QStringLiteral(
"writePolyline: line too short layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
992 if ( mForce2d || !line.at( 0 ).is3D() )
994 bool polygon = line[0] == line[ line.size() - 1 ];
998 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
1001 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1002 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
1010 for (
int i = 0; i < n; i++ )
1015 writeGroup( 0, QStringLiteral(
"POLYLINE" ) );
1018 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1022 writeGroup( 100, QStringLiteral(
"AcDb3dPolyline" ) );
1026 for (
int i = 0; i < n; i++ )
1031 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1034 writeGroup( 100, QStringLiteral(
"AcDbVertex" ) );
1035 writeGroup( 100, QStringLiteral(
"AcDb3dPolylineVertex" ) );
1043 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1049void QgsDxfExport::appendCurve(
const QgsCurve &
c, QVector<QgsPoint> &points, QVector<double> &bulges )
1054 appendLineString( *
dynamic_cast<const QgsLineString *
>( &
c ), points, bulges );
1058 appendCircularString( *
dynamic_cast<const QgsCircularString *
>( &
c ), points, bulges );
1062 appendCompoundCurve( *
dynamic_cast<const QgsCompoundCurve *
>( &
c ), points, bulges );
1066 QgsDebugError( QStringLiteral(
"Unexpected curve type %1" ).arg(
c.wktTypeStr() ) );
1071void QgsDxfExport::appendLineString(
const QgsLineString &ls, QVector<QgsPoint> &points, QVector<double> &bulges )
1073 for (
int i = 0; i < ls.
numPoints(); i++ )
1076 if ( !points.isEmpty() && points.last() == p )
1084void QgsDxfExport::appendCircularString(
const QgsCircularString &cs, QVector<QgsPoint> &points, QVector<double> &bulges )
1086 for (
int i = 0; i < cs.
numPoints() - 2; i += 2 )
1092 if ( points.isEmpty() || points.last() != p1 )
1094 else if ( !bulges.isEmpty() )
1095 bulges.removeLast();
1097 double a = ( M_PI - ( p1 - p2 ).
angle() + ( p3 - p2 ).
angle() ) / 2.0;
1098 bulges << sin( a ) / cos( a );
1105void QgsDxfExport::appendCompoundCurve(
const QgsCompoundCurve &cc, QVector<QgsPoint> &points, QVector<double> &bulges )
1107 for (
int i = 0; i < cc.
nCurves(); i++ )
1111 appendCurve( *
c, points, bulges );
1120 QgsDebugError( QStringLiteral(
"writePolyline: empty line layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
1126 QgsDebugError( QStringLiteral(
"writePolyline: line too short layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
1130 QVector<QgsPoint> points;
1131 QVector<double> bulges;
1132 appendCurve( curve, points, bulges );
1134 if ( mForce2d || !curve.
is3D() )
1136 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
1139 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1140 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
1145 QgsDxfExport::DxfPolylineFlags polylineFlags;
1155 writeGroup( 70,
static_cast<int>( polylineFlags ) );
1158 for (
int i = 0; i < points.size(); i++ )
1161 if ( bulges[i] != 0.0 )
1167 writeGroup( 0, QStringLiteral(
"POLYLINE" ) );
1170 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1174 writeGroup( 100, QStringLiteral(
"AcDb3dPolyline" ) );
1178 for (
int i = 0; i < points.size(); i++ )
1183 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1186 writeGroup( 100, QStringLiteral(
"AcDbVertex" ) );
1187 writeGroup( 100, QStringLiteral(
"AcDb3dPolylineVertex" ) );
1189 if ( bulges[i] != 0.0 )
1197 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1208 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1211 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1217 writeGroup( 70, hatchPattern == QLatin1String(
"SOLID" ) );
1221 for (
int i = 0; i < polygon.size(); ++i )
1228 for (
int j = 0; j < polygon[i].size(); ++j )
1247 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1250 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1256 writeGroup( 70, hatchPattern == QLatin1String(
"SOLID" ) );
1259 QVector<QVector<QgsPoint>> points;
1260 QVector<QVector<double>> bulges;
1263 points.reserve( ringCount + 1 );
1264 bulges.reserve( ringCount + 1 );
1266 points << QVector<QgsPoint>();
1267 bulges << QVector<double>();
1268 appendCurve( *polygon.
exteriorRing(), points.last(), bulges.last() );
1270 for (
int i = 0; i < ringCount; i++ )
1272 points << QVector<QgsPoint>();
1273 bulges << QVector<double>();
1274 appendCurve( *polygon.
interiorRing( i ), points.last(), bulges.last() );
1277 bool hasBulges =
false;
1278 for (
int i = 0; i < points.size() && !hasBulges; ++i )
1279 for (
int j = 0; j < points[i].size() && !hasBulges; ++j )
1280 hasBulges = bulges[i][j] != 0.0;
1284 for (
int i = 0; i < points.size(); ++i )
1291 for (
int j = 0; j < points[i].size(); ++j )
1315 double lblX = label->
getX();
1316 double lblY = label->
getY();
1341 switch ( offsetQuad )
1391 const QString haliString = exprVal.toString();
1392 if ( haliString.compare( QLatin1String(
"Center" ), Qt::CaseInsensitive ) == 0 )
1396 else if ( haliString.compare( QLatin1String(
"Right" ), Qt::CaseInsensitive ) == 0 )
1410 const QString valiString = exprVal.toString();
1411 if ( valiString.compare( QLatin1String(
"Bottom" ), Qt::CaseInsensitive ) != 0 )
1413 if ( valiString.compare( QLatin1String(
"Base" ), Qt::CaseInsensitive ) == 0 )
1417 else if ( valiString.compare( QLatin1String(
"Half" ), Qt::CaseInsensitive ) == 0 )
1436 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1437 writeGroup( 100, QStringLiteral(
"AcDbPoint" ) );
1448 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1451 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1482 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
1486 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1487 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
1506 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1509 writeGroup( 100, QStringLiteral(
"AcDbText" ) );
1520 writeGroup( 7, QStringLiteral(
"STANDARD" ) );
1521 writeGroup( 100, QStringLiteral(
"AcDbText" ) );
1530#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1531 if ( !mTextStream.codec()->canEncode( text ) )
1534 QgsDebugError( QStringLiteral(
"could not encode:%1" ).arg( text ) );
1541 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1542 writeGroup( 100, QStringLiteral(
"AcDbMText" ) );
1549 while ( t.length() > 250 )
1565 writeGroup( 7, QStringLiteral(
"STANDARD" ) );
1580 geom.transform( ct );
1589 penColor = colorFromSymbolLayer( symbolLayer, ctx );
1593 Qt::PenStyle penStyle( Qt::SolidLine );
1594 Qt::BrushStyle brushStyle( Qt::NoBrush );
1596 double offset = 0.0;
1600 width = symbolLayer->
dxfWidth( *
this, ctx );
1601 offset = symbolLayer->
dxfOffset( *
this, ctx );
1610 QString lineStyleName = QStringLiteral(
"CONTINUOUS" );
1613 lineStyleName = lineStyleFromSymbolLayer( symbolLayer );
1619 writePoint( geom.constGet()->coordinateSequence().at( 0 ).at( 0 ).at( 0 ), layer, penColor, ctx, symbolLayer, symbol, angle );
1626 for (
int i = 0; i < cs.size(); i++ )
1628 writePoint( cs.at( i ).at( 0 ).at( 0 ), layer, penColor, ctx, symbolLayer, symbol, angle );
1633 if ( penStyle != Qt::NoPen )
1636 std::unique_ptr< QgsAbstractGeometry > tempGeom;
1651 sourceGeom = tempGeom.get();
1653 sourceGeom = geom.constGet();
1659 writePolyline( *curve, layer, lineStyleName, penColor, width );
1671 writePolyline( *curve, layer, lineStyleName, penColor, width );
1688 sourceGeom = tempGeom.get();
1690 sourceGeom = geom.constGet();
1709 Q_ASSERT( polygon );
1727 if ( brushStyle != Qt::NoBrush )
1730 std::unique_ptr< QgsAbstractGeometry > tempGeom;
1738 Q_ASSERT( polygon );
1739 writePolygon( *polygon, layer, QStringLiteral(
"SOLID" ), brushColor );
1752 Q_ASSERT( polygon );
1753 writePolygon( *polygon, layer, QStringLiteral(
"SOLID" ), brushColor );
1770 return symbolLayer->
dxfColor( ctx );
1773QString QgsDxfExport::lineStyleFromSymbolLayer(
const QgsSymbolLayer *symbolLayer )
1775 QString lineStyleName = QStringLiteral(
"CONTINUOUS" );
1778 return lineStyleName;
1781 QHash< const QgsSymbolLayer *, QString >::const_iterator lineTypeIt = mLineStyles.constFind( symbolLayer );
1782 if ( lineTypeIt != mLineStyles.constEnd() )
1784 lineStyleName = lineTypeIt.value();
1785 return lineStyleName;
1789 return lineNameFromPenStyle( symbolLayer->
dxfPenStyle() );
1796 int current_distance = std::numeric_limits<int>::max();
1797 for (
int i = 1; i < static_cast< int >(
sizeof( sDxfColors ) /
sizeof( *sDxfColors ) ); ++i )
1799 int dist = color_distance( pixel, i );
1800 if ( dist < current_distance )
1802 current_distance = dist;
1811int QgsDxfExport::color_distance( QRgb p1,
int index )
1813 if ( index > 255 || index < 0 )
1818 double redDiff = qRed( p1 ) - sDxfColors[index][0];
1819 double greenDiff = qGreen( p1 ) - sDxfColors[index][1];
1820 double blueDiff = qBlue( p1 ) - sDxfColors[index][2];
1822 QgsDebugMsgLevel( QStringLiteral(
"color_distance( r:%1 g:%2 b:%3 <=> i:%4 r:%5 g:%6 b:%7 ) => %8" )
1823 .arg( qRed( p1 ) ).arg( qGreen( p1 ) ).arg( qBlue( p1 ) )
1825 .arg( mDxfColors[index][0] )
1826 .arg( mDxfColors[index][1] )
1827 .arg( mDxfColors[index][2] )
1828 .arg( redDiff * redDiff + greenDiff * greenDiff + blueDiff * blueDiff ), 2 );
1830 return redDiff * redDiff + greenDiff * greenDiff + blueDiff * blueDiff;
1833QRgb QgsDxfExport::createRgbEntry( qreal r, qreal g, qreal b )
1835 return QColor::fromRgbF( r, g, b ).rgb();
1840 return mRenderContext;
1855 return mapUnitsPerPixel;
1869 double minSizeMU = std::numeric_limits<double>::lowest();
1872 minSizeMU = scale.
minSizeMM * pixelToMMFactor * mapUnitsPerPixel;
1876 minSizeMU = std::max( minSizeMU, value );
1878 value = std::max( value, minSizeMU );
1880 double maxSizeMU = std::numeric_limits<double>::max();
1883 maxSizeMU = scale.
maxSizeMM * pixelToMMFactor * mapUnitsPerPixel;
1887 maxSizeMU = std::min( maxSizeMU, value );
1889 value = std::min( value, maxSizeMU );
1892QList< QPair< QgsSymbolLayer *, QgsSymbol * > > QgsDxfExport::symbolLayers(
QgsRenderContext &context )
1894 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > symbolLayers;
1905 maxSymbolLayers = 1;
1907 for (
int i = 0; i < maxSymbolLayers; ++i )
1909 symbolLayers.append( qMakePair( symbol->
symbolLayer( i ), symbol ) );
1914 return symbolLayers;
1917void QgsDxfExport::writeDefaultLinetypes()
1920 for (
const QString <ype : { QStringLiteral(
"ByLayer" ), QStringLiteral(
"ByBlock" ), QStringLiteral(
"CONTINUOUS" ) } )
1924 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
1925 writeGroup( 100, QStringLiteral(
"AcDbLinetypeTableRecord" ) );
1928 writeGroup( 3, QStringLiteral(
"Defaultstyle" ) );
1934 double das = dashSize();
1935 double dss = dashSeparatorSize();
1936 double dos = dotSize();
1938 QVector<qreal> dashVector( 2 );
1939 dashVector[0] = das;
1940 dashVector[1] = dss;
1943 QVector<qreal> dotVector( 2 );
1948 QVector<qreal> dashDotVector( 4 );
1949 dashDotVector[0] = das;
1950 dashDotVector[1] = dss;
1951 dashDotVector[2] = dos;
1952 dashDotVector[3] = dss;
1955 QVector<qreal> dashDotDotVector( 6 );
1956 dashDotDotVector[0] = das;
1957 dashDotDotVector[1] = dss;
1958 dashDotDotVector[2] = dos;
1959 dashDotDotVector[3] = dss;
1960 dashDotDotVector[4] = dos;
1961 dashDotDotVector[5] = dss;
1965void QgsDxfExport::writeSymbolLayerLinetype(
const QgsSymbolLayer *symbolLayer )
1974 if ( !customLinestyle.isEmpty() )
1976 QString name = QStringLiteral(
"symbolLayer%1" ).arg( mSymbolLayerCounter++ );
1977 writeLinetype( name, customLinestyle, unit );
1978 mLineStyles.insert( symbolLayer, name );
1982int QgsDxfExport::nLineTypes(
const QList< QPair< QgsSymbolLayer *, QgsSymbol * > > &symbolLayers )
1985 for (
const auto &symbolLayer : symbolLayers )
1999void QgsDxfExport::writeLinetype(
const QString &styleName,
const QVector<qreal> &pattern,
Qgis::RenderUnit u )
2002 for ( qreal size : pattern )
2010 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
2011 writeGroup( 100, QStringLiteral(
"AcDbLinetypeTableRecord" ) );
2020 for ( qreal size : pattern )
2023 double segmentLength = ( isGap ? -size : size );
2049 geomExpr.prepare( &expressionContext );
2057 symbolExpressionContextScope->
setFeature( f );
2062 for (
int i = 0; i < nSymbolLayers; ++i )
2064 addFeature( ctx, ct, layer, symbol->
symbolLayer( i ), symbol );
2073 if ( !sl || !symbol )
2078 bool blockBreak =
false;
2085 blockBreak = !properties.isEmpty();
2091double QgsDxfExport::dashSize()
const
2093 double size = mSymbologyScale * 0.002;
2094 return sizeToMapUnits( size );
2097double QgsDxfExport::dotSize()
const
2099 double size = mSymbologyScale * 0.0006;
2100 return sizeToMapUnits( size );
2103double QgsDxfExport::dashSeparatorSize()
const
2105 double size = mSymbologyScale * 0.0006;
2106 return sizeToMapUnits( size );
2109double QgsDxfExport::sizeToMapUnits(
double s )
const
2115QString QgsDxfExport::lineNameFromPenStyle( Qt::PenStyle style )
2120 return QStringLiteral(
"DASH" );
2122 return QStringLiteral(
"DOT" );
2123 case Qt::DashDotLine:
2124 return QStringLiteral(
"DASHDOT" );
2125 case Qt::DashDotDotLine:
2126 return QStringLiteral(
"DASHDOTDOT" );
2129 return QStringLiteral(
"CONTINUOUS" );
2135 if ( name.isEmpty() )
2136 return QStringLiteral(
"0" );
2161 layerName.replace( QLatin1String(
"\r\n" ), QLatin1String(
"_" ) );
2168bool QgsDxfExport::layerIsScaleBasedVisible(
const QgsMapLayer *layer )
const
2182 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
2186 if ( vl && vl->
id() ==
id )
2188 int attrIdx = mLayerNameAttribute.value( vl->
id(), -1 );
2193 return QStringLiteral(
"0" );
2198 const QList< QByteArray > codecs = QTextCodec::availableCodecs();
2199 for (
const QByteArray &codec : codecs )
2201 if ( name != codec )
2205 for ( i = 0; i < static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) && name != DXF_ENCODINGS[i][1]; ++i )
2208 if ( i ==
static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) )
2211 return DXF_ENCODINGS[i][0];
2220 const QList< QByteArray > codecs = QTextCodec::availableCodecs();
2222 for (
const QByteArray &codec : codecs )
2225 for ( i = 0; i < static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) && strcasecmp( codec.data(), DXF_ENCODINGS[i][1] ) != 0; ++i )
2228 if ( i <
static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) )
2240 return mLayerTitleAsName && !vl->
title().isEmpty() ? vl->
title() : vl->
name();
2258 const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues = lf->
dataDefinedValues();
2263 QgsDebugMsgLevel( QStringLiteral(
"PAL font definedFont: %1, Style: %2" ).arg( dFont.toString(), dFont.styleName() ), 4 );
2293 QgsPalLabeling::dataDefinedTextStyle( tmpLyr, ddValues );
2296 QgsPalLabeling::dataDefinedTextBuffer( tmpLyr, ddValues );
2299 QgsPalLabeling::dataDefinedTextFormatting( tmpLyr, ddValues );
2305 QString dxfLayer = mDxfLayerNames[layerId][fid];
2307 QString wrapchr = tmpLyr.
wrapChar.isEmpty() ? QStringLiteral(
"\n" ) : tmpLyr.
wrapChar;
2312 bool prependSymb =
false;
2330 prependSymb =
false;
2339 symb = symb + wrapchr;
2343 prependSymb =
false;
2344 symb = wrapchr + symb;
2353 txt.prepend( symb );
2363 txt.replace( QChar( QChar::LineFeed ),
' ' );
2364 txt.replace( QChar( QChar::CarriageReturn ),
' ' );
2369 txt.replace( QString( QChar( QChar::CarriageReturn ) ) + QString( QChar( QChar::LineFeed ) ), QStringLiteral(
"\\P" ) );
2370 txt.replace( QChar( QChar::CarriageReturn ), QStringLiteral(
"\\P" ) );
2371 txt = txt.replace( wrapchr, QLatin1String(
"\\P" ) );
2372 txt.replace( QLatin1String(
" " ), QLatin1String(
"\\~" ) );
2376 txt.prepend(
"\\L" ).append(
"\\l" );
2381 txt.prepend(
"\\O" ).append(
"\\o" );
2386 txt.prepend(
"\\K" ).append(
"\\k" );
2389 txt.prepend( QStringLiteral(
"\\f%1|i%2|b%3;\\H%4;" )
2391 .arg( tmpLyr.
format().
font().italic() ? 1 : 0 )
2392 .arg( tmpLyr.
format().
font().bold() ? 1 : 0 )
2393 .arg( label->
getHeight() / ( 1 + txt.count( QStringLiteral(
"\\P" ) ) ) * 0.75 ) );
2401 if ( !mDxfLayerNames.contains( layerId ) )
2402 mDxfLayerNames[ layerId ] = QMap<QgsFeatureId, QString>();
2404 mDxfLayerNames[layerId][fid] =
layerName;
2420 QString splitLayerFieldName;
2422 if ( mLayerOutputAttributeIndex >= 0 && mLayerOutputAttributeIndex < fields.
size() )
2424 splitLayerFieldName = fields.
at( mLayerOutputAttributeIndex ).
name();
2427 return splitLayerFieldName;
@ OverPoint
Arranges candidates over a point (or centroid of a polygon), or at a preset offset from the point....
@ Line
Arranges candidates parallel to a generalised line representing the feature or parallel to a polygon'...
DistanceUnit
Units of distance.
LabelQuadrantPosition
Label quadrant positions.
@ Miter
Use mitered joins.
@ FollowPlacement
Alignment follows placement of label, e.g., labels to the left of a feature will be drawn with right ...
RenderUnit
Rendering size units.
@ Millimeters
Millimeters.
@ Flat
Flat cap (in line with start/end of line)
WkbType
The WKB type describes the number of dimensions a geometry has.
@ CompoundCurve
CompoundCurve.
@ MultiPolygon
MultiPolygon.
@ MultiLineString
MultiLineString.
@ CircularString
CircularString.
@ CurvePolygon
CurvePolygon.
@ MultiSurface
MultiSurface.
@ PerFeature
Keeps the number of features and export symbology per feature.
@ PerSymbolLayer
Exports one feature per symbol layer (considering symbol levels)
@ NoSymbology
Export only data.
@ Reverse
Reverse/inverse transform (from destination to source)
Abstract base class for all geometries.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
virtual bool hasCurvedSegments() const
Returns true if the geometry contains curved segments.
Circular string geometry type.
int numPoints() const override
Returns the number of points in the curve.
QgsPoint pointN(int i) const
Returns the point at index i within the circular string.
Compound curve geometry type.
int nCurves() const
Returns the number of curves in the geometry.
const QgsCurve * curveAt(int i) const
Returns the curve at the specified index.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Qgis::DistanceUnit mapUnits
Curve polygon geometry type.
int numInteriorRings() const
Returns the number of interior rings contained with the curve polygon.
const QgsCurve * exteriorRing() const
Returns the curve polygon's exterior ring.
const QgsCurve * interiorRing(int i) const
Retrieves an interior ring from the curve polygon.
Abstract base class for curved geometry type.
QgsCoordinateSequence coordinateSequence() const override
Retrieves the sequence of geometries, rings and nodes.
virtual int numPoints() const =0
Returns the number of points in the curve.
virtual bool isClosed() const
Returns true if the curve is closed.
void writeFilledCircle(const QString &layer, const QColor &color, const QgsPoint &pt, double radius)
Write filled circle (as hatch)
ExportResult
The result of an export as dxf operation.
@ DeviceNotWritableError
Device not writable error.
@ Success
Successful export.
@ EmptyExtentError
Empty extent, no extent given and no extent could be derived from layers.
@ InvalidDeviceError
Invalid device error.
void writeCircle(const QString &layer, const QColor &color, const QgsPoint &pt, double radius, const QString &lineStyleName, double width)
Write circle (as polyline)
static double mapUnitScaleFactor(double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
ExportResult writeToFile(QIODevice *d, const QString &codec)
Export to a dxf file in the given encoding.
void writeLine(const QgsPoint &pt1, const QgsPoint &pt2, const QString &layer, const QString &lineStyleName, const QColor &color, double width=-1)
Write line (as a polyline)
void writeGroup(int code, int i)
Write a tuple of group code and integer value.
QString layerName(const QString &id, const QgsFeature &f) const
Gets layer name for feature.
void setFlags(QgsDxfExport::Flags flags)
Sets the export flags.
@ FlagNoMText
Export text as TEXT elements. If not set, text will be exported as MTEXT elements.
void writeInt(int i)
Write an integer value.
void writeMText(const QString &layer, const QString &text, const QgsPoint &pt, double width, double angle, const QColor &color)
Write mtext (MTEXT)
QgsDxfExport()
Constructor for QgsDxfExport.
int writeHandle(int code=5, int handle=0)
Write a tuple of group code and a handle.
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination CRS, or an invalid CRS if no reprojection will be done.
HAlign
Horizontal alignments.
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Set destination CRS.
void addLayers(const QList< QgsDxfExport::DxfLayer > &layers)
Add layers to export.
static QString dxfLayerName(const QString &name)
Returns cleaned layer name for use in DXF.
void writeDouble(double d)
Write a floating point value.
void writeText(const QString &layer, const QString &text, const QgsPoint &pt, double size, double angle, const QColor &color, QgsDxfExport::HAlign hali=QgsDxfExport::HAlign::Undefined, QgsDxfExport::VAlign vali=QgsDxfExport::VAlign::Undefined)
Write text (TEXT)
void writeString(const QString &s)
Write a string value.
void writePolygon(const QgsRingSequence &polygon, const QString &layer, const QString &hatchPattern, const QColor &color)
Draw dxf filled polygon (HATCH)
void drawLabel(const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings) override
Add a label to the dxf output.
static QString dxfEncoding(const QString &name)
Returns DXF encoding for Qt encoding.
static int closestColorMatch(QRgb color)
Gets DXF palette index of nearest entry for given color.
void writePoint(const QString &layer, const QColor &color, const QgsPoint &pt)
Write point.
Qgis::DistanceUnit mapUnits() const
Retrieve map units.
Q_DECL_DEPRECATED void registerDxfLayer(const QString &layerId, QgsFeatureId fid, const QString &layer)
Register name of layer for feature.
QgsDxfExport::Flags flags() const
Returns the export flags.
VAlign
Vertical alignments.
void clipValueToMapUnitScale(double &value, const QgsMapUnitScale &scale, double pixelToMMFactor) const
Clips value to scale minimum/maximum.
void writePolyline(const QgsPointSequence &line, const QString &layer, const QString &lineStyleName, const QColor &color, double width=-1)
Draw dxf primitives (LWPOLYLINE)
@ ContinuousPattern
The linetype pattern is generated continuously around the vertices of this polyline.
@ Closed
This is a closed polyline (or a polygon mesh closed in the M direction)
@ Curve
Curve-fit vertices have been added.
static QStringList encodings()
Returns list of available DXF encodings.
void setMapSettings(const QgsMapSettings &settings)
Set map settings and assign layer name attributes.
void writeGroupCode(int code)
Write a group code.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the scope.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QList< QgsExpressionContextScope * > scopes()
Returns a list of scopes contained within the stack.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Class for parsing and evaluation of expressions (formerly called "search strings").
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
@ SymbolLevels
Rendering with symbol levels (i.e. implements symbols(), symbolForFeature())
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
bool hasGeometry() const
Returns true if the feature has an associated geometry.
QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Container of fields for a vector layer.
int size() const
Returns number of items.
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
int numGeometries() const
Returns the number of geometries within the collection.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
QString geometryExpression() const
Gets the expression to generate this geometry.
QgsSymbol * subSymbol() override
Returns the symbol's sub symbol, if present.
A geometry is the spatial representation of a feature.
Does vector analysis using the geos library and handles import, export, exception handling*.
The QgsLabelFeature class describes a feature that should be used within the labeling engine.
QgsPointXY anchorPosition() const
In case of quadrand or aligned positioning, this is set to the anchor point.
QString labelText() const
Text of the label.
bool reverseDirectionSymbol() const
Returns true if direction symbols should be reversed.
DirectionSymbolPlacement directionSymbolPlacement() const
Returns the placement for direction symbols.
QString leftDirectionSymbol() const
Returns the string to use for left direction arrows.
@ SymbolLeftRight
Place direction symbols on left/right of label.
@ SymbolAbove
Place direction symbols on above label.
@ SymbolBelow
Place direction symbols on below label.
QString rightDirectionSymbol() const
Returns the string to use for right direction arrows.
bool addDirectionSymbol() const
Returns true if '<' or '>' (or custom strings set via leftDirectionSymbol and rightDirectionSymbol) w...
virtual void run(QgsRenderContext &context)=0
Runs the labeling job.
Line string geometry type, with support for z-dimension and m-values.
int numPoints() const override
Returns the number of points in the curve.
QgsPoint pointN(int i) const
Returns the specified point from inside the line string.
Base class for all map layer types.
bool isInScaleRange(double scale) const
Tests whether the layer should be visible at the specified scale.
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
QString title() const
Returns the title of the layer used by QGIS Server in GetCapabilities request.
The QgsMapSettings class contains configuration for rendering of the map.
QgsPointXY layerToMapCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from layer's CRS to output CRS
QList< QgsMapLayer * > layers(bool expandGroupLayers=false) const
Returns the list of layers which will be rendered in the map.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers to render in the map.
void setOutputDpi(double dpi)
Sets the dpi (dots per inch) used for conversion between real world units (e.g.
const QgsMapToPixel & mapToPixel() const
void setExtent(const QgsRectangle &rect, bool magnified=true)
Sets the coordinates of the rectangle which should be rendered.
QMap< QString, QString > layerStyleOverrides() const
Returns the map of map layer style overrides (key: layer ID, value: style name) where a different sty...
void setOutputSize(QSize size)
Sets the size of the resulting map image, in pixels.
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination crs (coordinate reference system) for the map render.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
Perform transforms between map coordinates and device coordinates.
double mapUnitsPerPixel() const
Returns the current map units per pixel.
Struct for storing maximum and minimum scales for measurements in map units.
bool minSizeMMEnabled
Whether the minimum size in mm should be respected.
double maxScale
The maximum scale, or 0.0 if unset.
double minScale
The minimum scale, or 0.0 if unset.
double maxSizeMM
The maximum size in millimeters, or 0.0 if unset.
bool maxSizeMMEnabled
Whether the maximum size in mm should be respected.
double minSizeMM
The minimum size in millimeters, or 0.0 if unset.
Abstract base class for marker symbol layers.
double size() const
Returns the symbol size.
virtual double dxfAngle(QgsSymbolRenderContext &context) const override
Gets angle.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets marker size.
Qgis::RenderUnit sizeUnit() const
Returns the units for the symbol's size.
Contains settings for how a map layer will be labeled.
void setFormat(const QgsTextFormat &format)
Sets the label text formatting settings, e.g., font settings, buffer settings, etc.
QString wrapChar
Wrapping character string.
Qgis::LabelPlacement placement
Label placement mode.
bool drawLabels
Whether to draw labels for this layer.
Qgis::LabelQuadrantPosition quadOffset
Sets the quadrant in which to offset labels from feature.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the label's property collection, used for data defined overrides.
Qgis::LabelMultiLineAlignment multilineAlign
Horizontal alignment of multi-line labels.
@ Hali
Horizontal alignment for data defined label position (Left, Center, Right)
@ Vali
Vertical alignment for data defined label position (Bottom, Base, Half, Cap, Top)
const QgsLabelLineSettings & lineSettings() const
Returns the label line settings, which contain settings related to how the label engine places and fo...
const QgsTextFormat & format() const
Returns the label text formatting settings, e.g., font settings, buffer settings, etc.
Point geometry type, with support for z-dimension and m-values.
static QgsProject * instance()
Returns the QgsProject singleton instance.
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
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.
QSet< int > propertyKeys() const override
Returns a list of property keys contained within the collection.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
A rectangle specified with double values.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double width() const
Returns the width of the rectangle.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
QgsPointXY center() const
Returns the center point of the rectangle.
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
bool isEmpty() const
Returns true if the rectangle has no area.
double height() const
Returns the height of the rectangle.
Contains information about the context of a rendering operation.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
void setExtent(const QgsRectangle &extent)
When rendering a map layer, calling this method sets the "clipping" extent for the layer (in the laye...
void setMapToPixel(const QgsMapToPixel &mtp)
Sets the context's map to pixel transform, which transforms between map coordinates and device coordi...
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
void setLabelingEngine(QgsLabelingEngine *engine)
Assigns the labeling engine.
void setRendererScale(double scale)
Sets the renderer map scale.
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr).
A simple line symbol layer, which renders lines using a line in a variety of styles (e....
bool useCustomDashPattern() const
Returns true if the line uses a custom dash pattern.
@ PropertyAngle
Symbol angle.
@ PropertySize
Symbol size.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets marker size.
virtual double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
virtual QString layerType() const =0
Returns a string that represents this layer type.
virtual double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
virtual bool writeDxf(QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift=QPointF(0.0, 0.0)) const
write as DXF
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual QVector< qreal > dxfCustomDashPattern(Qgis::RenderUnit &unit) const
Gets dash pattern.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
const QgsFeature * feature() const
Returns the current feature being rendered.
QgsExpressionContextScope * expressionContextScope()
This scope is always available when a symbol of this type is being rendered.
void setFeature(const QgsFeature *f)
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
QgsSymbolRenderContext * symbolRenderContext()
Returns the symbol render context.
QgsSymbolLayer * symbolLayer(int layer)
Returns the symbol layer at the specified index.
int symbolLayerCount() const
Returns the total number of symbol layers contained in the symbol.
Container for all settings relating to text rendering.
void setFont(const QFont &font)
Sets the font used for rendering text.
QColor color() const
Returns the color that text will be rendered in.
QFont font() const
Returns the font used for rendering text.
Class that adds extra information to QgsLabelFeature for text labels.
QFont definedFont() const
Font to be used for rendering.
const QMap< QgsPalLayerSettings::Property, QVariant > & dataDefinedValues() const
Gets data-defined values.
static Q_INVOKABLE double fromUnitToUnitFactor(Qgis::DistanceUnit fromUnit, Qgis::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
static bool isNull(const QVariant &variant)
Returns true if the specified variant should be considered a NULL value.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) override
Gets an iterator for features matching the specified request.
QgsFields fields() const
Returns the fields that will be available for features that are retrieved from this source.
Represents a vector layer which manages a vector based data sets.
QgsFields fields() const FINAL
Returns the list of fields of this layer.
QgsFeatureRenderer * renderer()
Returns the feature renderer used for rendering the features in the layer in 2D map views.
QgsRectangle extent() const FINAL
Returns the extent of the layer.
QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const FINAL
Calculates a list of unique values contained within an attribute in the layer.
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
QgsFeatureId featureId() const
Returns the unique ID of the feature.
QgsLabelFeature * feature()
Returns the parent feature.
LabelPosition is a candidate feature label position.
double getAlpha() const
Returns the angle to rotate text (in radians).
Quadrant getQuadrant() const
FeaturePart * getFeaturePart() const
Returns the feature corresponding to this labelposition.
double getX(int i=0) const
Returns the down-left x coordinate.
double getY(int i=0) const
Returns the down-left y coordinate.
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Contains geos related utilities and functions.
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
#define Q_NOWARN_DEPRECATED_POP
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
#define Q_NOWARN_DEPRECATED_PUSH
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
QVector< QgsRingSequence > QgsCoordinateSequence
QVector< QgsPointSequence > QgsRingSequence
QVector< QgsPoint > QgsPointSequence
#define DXF_HANDPLOTSTYLE
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
#define QgsDebugMsgLevel(str, level)
#define QgsDebugError(str)
QList< QgsSymbolLevel > QgsSymbolLevelOrder
QList< QgsSymbolLevelItem > QgsSymbolLevel
QList< QgsSymbol * > QgsSymbolList
QList< QgsSymbolLayer * > QgsSymbolLayerList
const QgsCoordinateReferenceSystem & crs
Holds information about each layer in a DXF job.
std::unique_ptr< QgsFeatureRenderer > renderer
QgsRenderContext renderContext
QgsCoordinateReferenceSystem crs
QgsVectorLayerFeatureSource featureSource
Layers and optional attribute index to split into multiple layers using attribute value as layer name...
QString splitLayerAttribute() const
If the split layer attribute is set, the vector layer will be split into several dxf layers,...