67#define strcasecmp( a, b ) stricmp( a, b )
79 mMapSettings = settings;
94 QList<QgsMapLayer *> layerList;
96 mLayerNameAttribute.clear();
98 layerList.reserve( layers.size() );
99 for (
const DxfLayer &dxfLayer : layers )
101 layerList << dxfLayer.layer();
102 if ( dxfLayer.layerOutputAttributeIndex() >= 0 )
103 mLayerNameAttribute.insert( dxfLayer.layer()->id(), dxfLayer.layerOutputAttributeIndex() );
137 if ( !mForce2d && p.
is3D() && std::isfinite( p.
z() ) )
144 int minDist = std::numeric_limits<int>::max();
146 for (
int i = 1; i < static_cast< int >(
sizeof( sDxfColors ) /
sizeof( *sDxfColors ) ) && minDist > 0; ++i )
148 int dist = color_distance( color.rgba(), i );
149 if ( dist >= minDist )
156 if ( minDist == 0 && minDistAt != 7 )
160 if ( color.alpha() == 255 )
164 int c = ( color.red() & 0xff ) * 0x10000 + ( color.green() & 0xff ) * 0x100 + ( color.blue() & 0xff );
166 if ( transparencyCode != -1 && color.alpha() < 255 )
167 writeGroup( transparencyCode, 0x2000000 | color.alpha() );
172 mTextStream << QStringLiteral(
"%1\n" ).arg( code, 3, 10, QChar(
' ' ) );
177 mTextStream << QStringLiteral(
"%1\n" ).arg( i, 6, 10, QChar(
' ' ) );
183 if ( !s.contains(
'.' ) )
184 s += QLatin1String(
".0" );
185 mTextStream << s <<
'\n';
190 mTextStream << s <<
'\n';
200 if ( !d->isOpen() && !d->open( QIODevice::WriteOnly | QIODevice::Truncate ) )
205 mTextStream.setDevice( d );
206#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
207 mTextStream.setCodec( encoding.toLocal8Bit() );
209 mTextStream.setEncoding( QStringConverter::encodingForName( encoding.toLocal8Bit() ).value_or( QStringConverter::Utf8 ) );
217 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
232 mExtent = layerExtent;
268void QgsDxfExport::writeHeader(
const QString &codepage )
270 writeGroup( 999, QStringLiteral(
"DXF created from QGIS" ) );
276 writeGroup( 9, QStringLiteral(
"$ACADVER" ) );
288 writeGroup( 9, QStringLiteral(
"$LTSCALE" ) );
300 writeGroup( 9, QStringLiteral(
"$PSLTSCALE" ) );
303 writeGroup( 9, QStringLiteral(
"$HANDSEED" ) );
306 writeGroup( 9, QStringLiteral(
"$DWGCODEPAGE" ) );
315 handle = mNextHandleId++;
317 Q_ASSERT_X( handle <
DXF_HANDMAX,
"QgsDxfExport::writeHandle(int, int)",
"DXF handle too large" );
319 writeGroup( code, QString::number( handle, 16 ) );
323void QgsDxfExport::writeTables()
330 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > slList;
333 slList = symbolLayers( context );
341 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
344 writeDefaultLinetypes();
347 for (
const auto &symbolLayer : std::as_const( slList ) )
349 writeSymbolLayerLinetype( symbolLayer.first );
356 writeGroup( 2, QStringLiteral(
"BLOCK_RECORD" ) );
359 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
362 const QStringList blockStrings = QStringList() << QStringLiteral(
"*Model_Space" ) << QStringLiteral(
"*Paper_Space" ) << QStringLiteral(
"*Paper_Space0" );
363 for (
const QString &block : blockStrings )
365 writeGroup( 0, QStringLiteral(
"BLOCK_RECORD" ) );
367 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
368 writeGroup( 100, QStringLiteral(
"AcDbBlockTableRecord" ) );
373 for (
const auto &symbolLayer : std::as_const( slList ) )
379 if ( hasDataDefinedProperties( ml, symbolLayer.second ) )
382 QString name = QStringLiteral(
"symbolLayer%1" ).arg( i++ );
383 writeGroup( 0, QStringLiteral(
"BLOCK_RECORD" ) );
385 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
386 writeGroup( 100, QStringLiteral(
"AcDbBlockTableRecord" ) );
396 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
400 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
401 writeGroup( 100, QStringLiteral(
"AcDbRegAppTableRecord" ) );
410 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
418 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
426 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
430 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
431 writeGroup( 100, QStringLiteral(
"AcDbViewportTableRecord" ) );
470 writeGroup( 2, QStringLiteral(
"DIMSTYLE" ) );
472 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
473 writeGroup( 100, QStringLiteral(
"AcDbDimStyleTable" ) );
477 QSet<QString> layerNames;
478 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
481 if ( !layerIsScaleBasedVisible( ml ) )
488 int attrIdx = mLayerNameAttribute.value( vl->
id(), -1 );
495 const QSet<QVariant> values = vl->
uniqueValues( attrIdx );
496 for (
const QVariant &v : values )
508 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
513 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
514 writeGroup( 100, QStringLiteral(
"AcDbLayerTableRecord" ) );
518 writeGroup( 6, QStringLiteral(
"CONTINUOUS" ) );
521 for (
const QString &
layerName : std::as_const( layerNames ) )
525 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
526 writeGroup( 100, QStringLiteral(
"AcDbLayerTableRecord" ) );
530 writeGroup( 6, QStringLiteral(
"CONTINUOUS" ) );
539 writeGroup( 100, QStringLiteral(
"AcDbSymbolTable" ) );
545 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
546 writeGroup( 100, QStringLiteral(
"AcDbTextStyleTableRecord" ) );
547 writeGroup( 2, QStringLiteral(
"STANDARD" ) );
554 writeGroup( 3, QStringLiteral(
"romans.shx" ) );
562void QgsDxfExport::writeBlocks()
567 static const QStringList blockStrings = QStringList() << QStringLiteral(
"*Model_Space" ) << QStringLiteral(
"*Paper_Space" ) << QStringLiteral(
"*Paper_Space0" );
568 for (
const QString &block : blockStrings )
572 writeGroup( 330, QString::number( mBlockHandles[ block ], 16 ) );
573 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
575 writeGroup( 100, QStringLiteral(
"AcDbBlockBegin" ) );
583 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
585 writeGroup( 100, QStringLiteral(
"AcDbBlockEnd" ) );
591 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > slList;
594 slList = symbolLayers( ct );
597 for (
const auto &symbolLayer : std::as_const( slList ) )
607 if ( hasDataDefinedProperties( ml, symbolLayer.second ) )
612 QString block( QStringLiteral(
"symbolLayer%1" ).arg( mBlockCounter++ ) );
613 mBlockHandle = QString::number( mBlockHandles[ block ], 16 );
618 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
620 writeGroup( 100, QStringLiteral(
"AcDbBlockBegin" ) );
633 ml->
writeDxf( *
this,
mapUnitScaleFactor( mSymbologyScale, ml->
sizeUnit(), mMapUnits, ctx.renderContext().mapToPixel().mapUnitsPerPixel() ), QStringLiteral(
"0" ), ctx );
637 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
639 writeGroup( 100, QStringLiteral(
"AcDbBlockEnd" ) );
641 mPointSymbolBlocks.insert( ml, block );
647void QgsDxfExport::writeEntities()
650 writeGroup( 2, QStringLiteral(
"ENTITIES" ) );
652 mBlockHandle = QString::number( mBlockHandles[ QStringLiteral(
"*Model_Space" )], 16 );
661 job->renderer->usingSymbolLevels() )
663 writeEntitiesSymbolLevels( job );
681 QString lName(
dxfLayerName( job->splitLayerAttribute.isNull() ? job->layerTitle : fet.
attribute( job->splitLayerAttribute ).toString() ) );
683 sctx.setFeature( &fet );
685 if ( !job->renderer->willRenderFeature( fet, mRenderContext ) )
690 addFeature( sctx, ct, lName,
nullptr,
nullptr );
694 const QgsSymbolList symbolList = job->renderer->symbolsForFeature( fet, mRenderContext );
695 bool hasSymbology = symbolList.size() > 0;
707 bool isGeometryGenerator = ( symbolLayer->layerType() == QLatin1String(
"GeometryGenerator" ) );
708 if ( isGeometryGenerator )
710 addGeometryGeneratorSymbolLayer( sctx, ct, lName, symbolLayer,
true );
714 addFeature( sctx, ct, lName, symbolLayer, symbol );
719 else if ( hasSymbology )
730 addGeometryGeneratorSymbolLayer( sctx, ct, lName, s->
symbolLayer( 0 ),
false );
734 addFeature( sctx, ct, lName, s->
symbolLayer( 0 ), s );
738 if ( job->labelProvider )
740 job->labelProvider->registerFeature( fet, mRenderContext );
745 else if ( job->ruleBasedLabelProvider )
747 job->ruleBasedLabelProvider->registerFeature( fet, mRenderContext );
756 QImage image( 10, 10, QImage::Format_ARGB32_Premultiplied );
757 image.setDotsPerMeterX( 96 / 25.4 * 1000 );
758 image.setDotsPerMeterY( 96 / 25.4 * 1000 );
759 QPainter painter( &image );
767void QgsDxfExport::prepareRenderers()
769 Q_ASSERT( mJobs.empty() );
777 mExtent.
height() * mFactor, 0 ) );
783 mLabelingEngine = std::make_unique<QgsDefaultLabelingEngine>();
784 mLabelingEngine->setMapSettings( mMapSettings );
787 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
797 if ( !layerIsScaleBasedVisible( vl ) )
800 QString splitLayerAttribute;
801 int splitLayerAttributeIndex = mLayerNameAttribute.value( vl->
id(), -1 );
803 if ( splitLayerAttributeIndex >= 0 && splitLayerAttributeIndex < fields.
size() )
804 splitLayerAttribute = fields.
at( splitLayerAttributeIndex ).
name();
810void QgsDxfExport::writeEntitiesSymbolLevels(
DxfLayerJob *job )
812 QHash< QgsSymbol *, QList<QgsFeature> > features;
834 featureSymbol = job->
renderer->symbolForFeature( fet, ctx );
835 if ( !featureSymbol )
840 QHash< QgsSymbol *, QList<QgsFeature> >::iterator it = features.find( featureSymbol );
841 if ( it == features.end() )
843 it = features.insert( featureSymbol, QList<QgsFeature>() );
845 it.value().append( fet );
853 for (
int j = 0; j < symbol->symbolLayerCount(); j++ )
855 int level = symbol->symbolLayer( j )->renderingPass();
856 if ( level < 0 || level >= 1000 )
859 while ( level >= levels.count() )
861 levels[level].append( item );
870 QHash< QgsSymbol *, QList<QgsFeature> >::iterator levelIt = features.find( item.symbol() );
871 if ( levelIt == features.end() )
876 int llayer = item.layer();
877 const QList<QgsFeature> &featureList = levelIt.value();
878 for (
const QgsFeature &feature : featureList )
880 sctx.setFeature( &feature );
881 addFeature( sctx, ct, job->
layerName, levelIt.key()->symbolLayer( llayer ), levelIt.key() );
887void QgsDxfExport::stopRenderers()
893void QgsDxfExport::writeEndFile()
900void QgsDxfExport::startSection()
905void QgsDxfExport::endSection()
930 QHash< const QgsSymbolLayer *, QString >::const_iterator blockIt = mPointSymbolBlocks.constFind( symbolLayer );
931 if ( !symbolLayer || blockIt == mPointSymbolBlocks.constEnd() )
949 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
950 writeGroup( 100, QStringLiteral(
"AcDbBlockReference" ) );
963 QgsDebugMsg( QStringLiteral(
"writePolyline: empty line layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
969 QgsDebugMsg( QStringLiteral(
"writePolyline: line too short layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
973 if ( mForce2d || !line.at( 0 ).is3D() )
975 bool polygon = line[0] == line[ line.size() - 1 ];
979 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
982 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
983 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
991 for (
int i = 0; i < n; i++ )
996 writeGroup( 0, QStringLiteral(
"POLYLINE" ) );
999 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1003 writeGroup( 100, QStringLiteral(
"AcDb3dPolyline" ) );
1007 for (
int i = 0; i < n; i++ )
1012 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1015 writeGroup( 100, QStringLiteral(
"AcDbVertex" ) );
1016 writeGroup( 100, QStringLiteral(
"AcDb3dPolylineVertex" ) );
1024 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1030void QgsDxfExport::appendCurve(
const QgsCurve &
c, QVector<QgsPoint> &points, QVector<double> &bulges )
1035 appendLineString( *
dynamic_cast<const QgsLineString *
>( &
c ), points, bulges );
1039 appendCircularString( *
dynamic_cast<const QgsCircularString *
>( &
c ), points, bulges );
1043 appendCompoundCurve( *
dynamic_cast<const QgsCompoundCurve *
>( &
c ), points, bulges );
1047 QgsDebugMsg( QStringLiteral(
"Unexpected curve type %1" ).arg(
c.wktTypeStr() ) );
1052void QgsDxfExport::appendLineString(
const QgsLineString &ls, QVector<QgsPoint> &points, QVector<double> &bulges )
1054 for (
int i = 0; i < ls.
numPoints(); i++ )
1057 if ( !points.isEmpty() && points.last() == p )
1065void QgsDxfExport::appendCircularString(
const QgsCircularString &cs, QVector<QgsPoint> &points, QVector<double> &bulges )
1067 for (
int i = 0; i < cs.
numPoints() - 2; i += 2 )
1073 if ( points.isEmpty() || points.last() != p1 )
1075 else if ( !bulges.isEmpty() )
1076 bulges.removeLast();
1078 double a = ( M_PI - ( p1 - p2 ).
angle() + ( p3 - p2 ).
angle() ) / 2.0;
1079 bulges << sin( a ) / cos( a );
1086void QgsDxfExport::appendCompoundCurve(
const QgsCompoundCurve &cc, QVector<QgsPoint> &points, QVector<double> &bulges )
1088 for (
int i = 0; i < cc.
nCurves(); i++ )
1092 appendCurve( *
c, points, bulges );
1101 QgsDebugMsg( QStringLiteral(
"writePolyline: empty line layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
1107 QgsDebugMsg( QStringLiteral(
"writePolyline: line too short layer=%1 lineStyleName=%2" ).arg( layer, lineStyleName ) );
1111 QVector<QgsPoint> points;
1112 QVector<double> bulges;
1113 appendCurve( curve, points, bulges );
1115 if ( mForce2d || !curve.
is3D() )
1117 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
1120 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1121 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
1126 QgsDxfExport::DxfPolylineFlags polylineFlags;
1128 polylineFlags.setFlag( QgsDxfExport::DxfPolylineFlag::Closed );
1130 polylineFlags.setFlag( QgsDxfExport::DxfPolylineFlag::Curve );
1134 polylineFlags.setFlag( QgsDxfExport::DxfPolylineFlag::ContinuousPattern );
1136 writeGroup( 70,
static_cast<int>( polylineFlags ) );
1139 for (
int i = 0; i < points.size(); i++ )
1142 if ( bulges[i] != 0.0 )
1148 writeGroup( 0, QStringLiteral(
"POLYLINE" ) );
1151 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1155 writeGroup( 100, QStringLiteral(
"AcDb3dPolyline" ) );
1159 for (
int i = 0; i < points.size(); i++ )
1164 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1167 writeGroup( 100, QStringLiteral(
"AcDbVertex" ) );
1168 writeGroup( 100, QStringLiteral(
"AcDb3dPolylineVertex" ) );
1170 if ( bulges[i] != 0.0 )
1178 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1189 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1192 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1198 writeGroup( 70, hatchPattern == QLatin1String(
"SOLID" ) );
1202 for (
int i = 0; i < polygon.size(); ++i )
1209 for (
int j = 0; j < polygon[i].size(); ++j )
1228 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1231 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1237 writeGroup( 70, hatchPattern == QLatin1String(
"SOLID" ) );
1240 QVector<QVector<QgsPoint>> points;
1241 QVector<QVector<double>> bulges;
1244 points.reserve( ringCount + 1 );
1245 bulges.reserve( ringCount + 1 );
1247 points << QVector<QgsPoint>();
1248 bulges << QVector<double>();
1249 appendCurve( *polygon.
exteriorRing(), points.last(), bulges.last() );
1251 for (
int i = 0; i < ringCount; i++ )
1253 points << QVector<QgsPoint>();
1254 bulges << QVector<double>();
1255 appendCurve( *polygon.
interiorRing( i ), points.last(), bulges.last() );
1258 bool hasBulges =
false;
1259 for (
int i = 0; i < points.size() && !hasBulges; ++i )
1260 for (
int j = 0; j < points[i].size() && !hasBulges; ++j )
1261 hasBulges = bulges[i][j] != 0.0;
1265 for (
int i = 0; i < points.size(); ++i )
1272 for (
int j = 0; j < points[i].size(); ++j )
1296 double lblX = label->
getX();
1297 double lblY = label->
getY();
1322 switch ( offsetQuad )
1324 case Qgis::LabelQuadrantPosition::AboveLeft:
1328 case Qgis::LabelQuadrantPosition::Above:
1332 case Qgis::LabelQuadrantPosition::AboveRight:
1336 case Qgis::LabelQuadrantPosition::Left:
1340 case Qgis::LabelQuadrantPosition::Over:
1344 case Qgis::LabelQuadrantPosition::Right:
1348 case Qgis::LabelQuadrantPosition::BelowLeft:
1352 case Qgis::LabelQuadrantPosition::Below:
1356 case Qgis::LabelQuadrantPosition::BelowRight:
1372 const QString haliString = exprVal.toString();
1373 if ( haliString.compare( QLatin1String(
"Center" ), Qt::CaseInsensitive ) == 0 )
1377 else if ( haliString.compare( QLatin1String(
"Right" ), Qt::CaseInsensitive ) == 0 )
1391 const QString valiString = exprVal.toString();
1392 if ( valiString.compare( QLatin1String(
"Bottom" ), Qt::CaseInsensitive ) != 0 )
1394 if ( valiString.compare( QLatin1String(
"Base" ), Qt::CaseInsensitive ) == 0 )
1398 else if ( valiString.compare( QLatin1String(
"Half" ), Qt::CaseInsensitive ) == 0 )
1417 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1418 writeGroup( 100, QStringLiteral(
"AcDbPoint" ) );
1429 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1432 writeGroup( 100, QStringLiteral(
"AcDbHatch" ) );
1463 writeGroup( 0, QStringLiteral(
"LWPOLYLINE" ) );
1467 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1468 writeGroup( 100, QStringLiteral(
"AcDbPolyline" ) );
1487 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1490 writeGroup( 100, QStringLiteral(
"AcDbText" ) );
1501 writeGroup( 7, QStringLiteral(
"STANDARD" ) );
1502 writeGroup( 100, QStringLiteral(
"AcDbText" ) );
1511#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1512 if ( !mTextStream.codec()->canEncode( text ) )
1515 QgsDebugMsg( QStringLiteral(
"could not encode:%1" ).arg( text ) );
1522 writeGroup( 100, QStringLiteral(
"AcDbEntity" ) );
1523 writeGroup( 100, QStringLiteral(
"AcDbMText" ) );
1530 while ( t.length() > 250 )
1546 writeGroup( 7, QStringLiteral(
"STANDARD" ) );
1561 geom.transform( ct );
1568 if ( mSymbologyExport !=
NoSymbology && symbolLayer )
1570 penColor = colorFromSymbolLayer( symbolLayer, ctx );
1574 Qt::PenStyle penStyle( Qt::SolidLine );
1575 Qt::BrushStyle brushStyle( Qt::NoBrush );
1577 double offset = 0.0;
1579 if ( mSymbologyExport !=
NoSymbology && symbolLayer )
1581 width = symbolLayer->
dxfWidth( *
this, ctx );
1582 offset = symbolLayer->
dxfOffset( *
this, ctx );
1591 QString lineStyleName = QStringLiteral(
"CONTINUOUS" );
1594 lineStyleName = lineStyleFromSymbolLayer( symbolLayer );
1600 writePoint( geom.constGet()->coordinateSequence().at( 0 ).at( 0 ).at( 0 ), layer, penColor, ctx, symbolLayer, symbol,
angle );
1607 for (
int i = 0; i < cs.size(); i++ )
1609 writePoint( cs.at( i ).at( 0 ).at( 0 ), layer, penColor, ctx, symbolLayer, symbol,
angle );
1614 if ( penStyle != Qt::NoPen )
1617 std::unique_ptr< QgsAbstractGeometry > tempGeom;
1630 tempGeom.reset(
geos.offsetCurve( offset, 0, Qgis::JoinStyle::Miter, 2.0 ) );
1632 sourceGeom = tempGeom.get();
1634 sourceGeom = geom.constGet();
1640 writePolyline( *curve, layer, lineStyleName, penColor, width );
1652 writePolyline( *curve, layer, lineStyleName, penColor, width );
1667 tempGeom.reset(
geos.buffer( offset, 0, Qgis::EndCapStyle::Flat, Qgis::JoinStyle::Miter, 2.0 ) );
1669 sourceGeom = tempGeom.get();
1671 sourceGeom = geom.constGet();
1690 Q_ASSERT( polygon );
1708 if ( brushStyle != Qt::NoBrush )
1711 std::unique_ptr< QgsAbstractGeometry > tempGeom;
1719 Q_ASSERT( polygon );
1720 writePolygon( *polygon, layer, QStringLiteral(
"SOLID" ), brushColor );
1733 Q_ASSERT( polygon );
1734 writePolygon( *polygon, layer, QStringLiteral(
"SOLID" ), brushColor );
1751 return symbolLayer->
dxfColor( ctx );
1754QString QgsDxfExport::lineStyleFromSymbolLayer(
const QgsSymbolLayer *symbolLayer )
1756 QString lineStyleName = QStringLiteral(
"CONTINUOUS" );
1759 return lineStyleName;
1762 QHash< const QgsSymbolLayer *, QString >::const_iterator lineTypeIt = mLineStyles.constFind( symbolLayer );
1763 if ( lineTypeIt != mLineStyles.constEnd() )
1765 lineStyleName = lineTypeIt.value();
1766 return lineStyleName;
1770 return lineNameFromPenStyle( symbolLayer->
dxfPenStyle() );
1777 int current_distance = std::numeric_limits<int>::max();
1778 for (
int i = 1; i < static_cast< int >(
sizeof( sDxfColors ) /
sizeof( *sDxfColors ) ); ++i )
1780 int dist = color_distance( pixel, i );
1781 if ( dist < current_distance )
1783 current_distance = dist;
1792int QgsDxfExport::color_distance( QRgb p1,
int index )
1794 if ( index > 255 || index < 0 )
1799 double redDiff = qRed( p1 ) - sDxfColors[index][0];
1800 double greenDiff = qGreen( p1 ) - sDxfColors[index][1];
1801 double blueDiff = qBlue( p1 ) - sDxfColors[index][2];
1803 QgsDebugMsg( QStringLiteral(
"color_distance( r:%1 g:%2 b:%3 <=> i:%4 r:%5 g:%6 b:%7 ) => %8" )
1804 .arg( qRed( p1 ) ).arg( qGreen( p1 ) ).arg( qBlue( p1 ) )
1806 .arg( mDxfColors[index][0] )
1807 .arg( mDxfColors[index][1] )
1808 .arg( mDxfColors[index][2] )
1809 .arg( redDiff * redDiff + greenDiff * greenDiff + blueDiff * blueDiff ) );
1811 return redDiff * redDiff + greenDiff * greenDiff + blueDiff * blueDiff;
1814QRgb QgsDxfExport::createRgbEntry( qreal r, qreal g, qreal b )
1816 return QColor::fromRgbF( r, g, b ).rgb();
1821 return mRenderContext;
1836 return mapUnitsPerPixel;
1850 double minSizeMU = std::numeric_limits<double>::lowest();
1853 minSizeMU = scale.
minSizeMM * pixelToMMFactor * mapUnitsPerPixel;
1857 minSizeMU = std::max( minSizeMU, value );
1859 value = std::max( value, minSizeMU );
1861 double maxSizeMU = std::numeric_limits<double>::max();
1864 maxSizeMU = scale.
maxSizeMM * pixelToMMFactor * mapUnitsPerPixel;
1868 maxSizeMU = std::min( maxSizeMU, value );
1870 value = std::min( value, maxSizeMU );
1873QList< QPair< QgsSymbolLayer *, QgsSymbol * > > QgsDxfExport::symbolLayers(
QgsRenderContext &context )
1875 QList< QPair< QgsSymbolLayer *, QgsSymbol * > > symbolLayers;
1886 maxSymbolLayers = 1;
1888 for (
int i = 0; i < maxSymbolLayers; ++i )
1890 symbolLayers.append( qMakePair( symbol->
symbolLayer( i ), symbol ) );
1895 return symbolLayers;
1898void QgsDxfExport::writeDefaultLinetypes()
1901 for (
const QString <ype : { QStringLiteral(
"ByLayer" ), QStringLiteral(
"ByBlock" ), QStringLiteral(
"CONTINUOUS" ) } )
1905 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
1906 writeGroup( 100, QStringLiteral(
"AcDbLinetypeTableRecord" ) );
1909 writeGroup( 3, QStringLiteral(
"Defaultstyle" ) );
1915 double das = dashSize();
1916 double dss = dashSeparatorSize();
1917 double dos = dotSize();
1919 QVector<qreal> dashVector( 2 );
1920 dashVector[0] = das;
1921 dashVector[1] = dss;
1924 QVector<qreal> dotVector( 2 );
1929 QVector<qreal> dashDotVector( 4 );
1930 dashDotVector[0] = das;
1931 dashDotVector[1] = dss;
1932 dashDotVector[2] = dos;
1933 dashDotVector[3] = dss;
1936 QVector<qreal> dashDotDotVector( 6 );
1937 dashDotDotVector[0] = das;
1938 dashDotDotVector[1] = dss;
1939 dashDotDotVector[2] = dos;
1940 dashDotDotVector[3] = dss;
1941 dashDotDotVector[4] = dos;
1942 dashDotDotVector[5] = dss;
1946void QgsDxfExport::writeSymbolLayerLinetype(
const QgsSymbolLayer *symbolLayer )
1955 if ( !customLinestyle.isEmpty() )
1957 QString name = QStringLiteral(
"symbolLayer%1" ).arg( mSymbolLayerCounter++ );
1958 writeLinetype( name, customLinestyle, unit );
1959 mLineStyles.insert( symbolLayer, name );
1963int QgsDxfExport::nLineTypes(
const QList< QPair< QgsSymbolLayer *, QgsSymbol * > > &symbolLayers )
1966 for (
const auto &symbolLayer : symbolLayers )
1980void QgsDxfExport::writeLinetype(
const QString &styleName,
const QVector<qreal> &pattern,
QgsUnitTypes::RenderUnit u )
1983 for ( qreal size : pattern )
1991 writeGroup( 100, QStringLiteral(
"AcDbSymbolTableRecord" ) );
1992 writeGroup( 100, QStringLiteral(
"AcDbLinetypeTableRecord" ) );
2001 for ( qreal size : pattern )
2004 double segmentLength = ( isGap ? -size : size );
2030 geomExpr.prepare( &expressionContext );
2038 symbolExpressionContextScope->
setFeature( f );
2043 for (
int i = 0; i < nSymbolLayers; ++i )
2045 addFeature( ctx, ct, layer, symbol->
symbolLayer( i ), symbol );
2054 if ( !sl || !symbol )
2067double QgsDxfExport::dashSize()
const
2069 double size = mSymbologyScale * 0.002;
2070 return sizeToMapUnits( size );
2073double QgsDxfExport::dotSize()
const
2075 double size = mSymbologyScale * 0.0006;
2076 return sizeToMapUnits( size );
2079double QgsDxfExport::dashSeparatorSize()
const
2081 double size = mSymbologyScale * 0.0006;
2082 return sizeToMapUnits( size );
2085double QgsDxfExport::sizeToMapUnits(
double s )
const
2091QString QgsDxfExport::lineNameFromPenStyle( Qt::PenStyle style )
2096 return QStringLiteral(
"DASH" );
2098 return QStringLiteral(
"DOT" );
2099 case Qt::DashDotLine:
2100 return QStringLiteral(
"DASHDOT" );
2101 case Qt::DashDotDotLine:
2102 return QStringLiteral(
"DASHDOTDOT" );
2105 return QStringLiteral(
"CONTINUOUS" );
2111 if ( name.isEmpty() )
2112 return QStringLiteral(
"0" );
2137 layerName.replace( QLatin1String(
"\r\n" ), QLatin1String(
"_" ) );
2144bool QgsDxfExport::layerIsScaleBasedVisible(
const QgsMapLayer *layer )
const
2158 const QList< QgsMapLayer * > layers = mMapSettings.
layers();
2162 if ( vl && vl->
id() ==
id )
2164 int attrIdx = mLayerNameAttribute.value( vl->
id(), -1 );
2169 return QStringLiteral(
"0" );
2174 const QList< QByteArray > codecs = QTextCodec::availableCodecs();
2175 for (
const QByteArray &codec : codecs )
2177 if ( name != codec )
2181 for ( i = 0; i < static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) && name != DXF_ENCODINGS[i][1]; ++i )
2184 if ( i ==
static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) )
2187 return DXF_ENCODINGS[i][0];
2196 const QList< QByteArray > codecs = QTextCodec::availableCodecs();
2198 for (
const QByteArray &codec : codecs )
2201 for ( i = 0; i < static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) && strcasecmp( codec.data(), DXF_ENCODINGS[i][1] ) != 0; ++i )
2204 if ( i <
static_cast< int >(
sizeof( DXF_ENCODINGS ) /
sizeof( *DXF_ENCODINGS ) ) )
2216 return mLayerTitleAsName && !vl->
title().isEmpty() ? vl->
title() : vl->
name();
2234 const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues = lf->
dataDefinedValues();
2239 QgsDebugMsgLevel( QStringLiteral(
"PAL font definedFont: %1, Style: %2" ).arg( dFont.toString(), dFont.styleName() ), 4 );
2245 if ( tmpLyr.
multilineAlign == Qgis::LabelMultiLineAlignment::FollowPlacement )
2269 QgsPalLabeling::dataDefinedTextStyle( tmpLyr, ddValues );
2272 QgsPalLabeling::dataDefinedTextBuffer( tmpLyr, ddValues );
2275 QgsPalLabeling::dataDefinedTextFormatting( tmpLyr, ddValues );
2281 QString dxfLayer = mDxfLayerNames[layerId][fid];
2283 QString wrapchr = tmpLyr.
wrapChar.isEmpty() ? QStringLiteral(
"\n" ) : tmpLyr.
wrapChar;
2288 bool prependSymb =
false;
2306 prependSymb =
false;
2315 symb = symb + wrapchr;
2319 prependSymb =
false;
2320 symb = wrapchr + symb;
2329 txt.prepend( symb );
2339 txt.replace( QChar( QChar::LineFeed ),
' ' );
2340 txt.replace( QChar( QChar::CarriageReturn ),
' ' );
2345 txt.replace( QString( QChar( QChar::CarriageReturn ) ) + QString( QChar( QChar::LineFeed ) ), QStringLiteral(
"\\P" ) );
2346 txt.replace( QChar( QChar::CarriageReturn ), QStringLiteral(
"\\P" ) );
2347 txt = txt.replace( wrapchr, QLatin1String(
"\\P" ) );
2348 txt.replace( QLatin1String(
" " ), QLatin1String(
"\\~" ) );
2352 txt.prepend(
"\\L" ).append(
"\\l" );
2357 txt.prepend(
"\\O" ).append(
"\\o" );
2362 txt.prepend(
"\\K" ).append(
"\\k" );
2365 txt.prepend( QStringLiteral(
"\\f%1|i%2|b%3;\\H%4;" )
2367 .arg( tmpLyr.
format().
font().italic() ? 1 : 0 )
2368 .arg( tmpLyr.
format().
font().bold() ? 1 : 0 )
2369 .arg( label->
getHeight() / ( 1 + txt.count( QStringLiteral(
"\\P" ) ) ) * 0.75 ) );
2377 if ( !mDxfLayerNames.contains( layerId ) )
2378 mDxfLayerNames[ layerId ] = QMap<QgsFeatureId, QString>();
2380 mDxfLayerNames[layerId][fid] =
layerName;
2396 QString splitLayerFieldName;
2398 if ( mLayerOutputAttributeIndex >= 0 && mLayerOutputAttributeIndex < fields.
size() )
2400 splitLayerFieldName = fields.
at( mLayerOutputAttributeIndex ).
name();
2403 return splitLayerFieldName;
@ DynamicRotation
Rotation of symbol may be changed during rendering and symbol should not be cached.
@ 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'...
LabelQuadrantPosition
Label quadrant positions.
Abstract base class for all geometries.
bool is3D() const SIP_HOLDGIL
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.
QgsPoint pointN(int i) const SIP_HOLDGIL
Returns the point at index i within the circular string.
int numPoints() const override SIP_HOLDGIL
Returns the number of points in the curve.
Compound curve geometry type.
const QgsCurve * curveAt(int i) const SIP_HOLDGIL
Returns the curve at the specified index.
int nCurves() const SIP_HOLDGIL
Returns the number of curves in the geometry.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Q_GADGET QgsUnitTypes::DistanceUnit mapUnits
Curve polygon geometry type.
const QgsCurve * interiorRing(int i) const SIP_HOLDGIL
Retrieves an interior ring from the curve polygon.
const QgsCurve * exteriorRing() const SIP_HOLDGIL
Returns the curve polygon's exterior ring.
int numInteriorRings() const SIP_HOLDGIL
Returns the number of interior rings contained with the curve polygon.
Abstract base class for curved geometry type.
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 SIP_HOLDGIL
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.
@ SymbolLayerSymbology
Exports one feature per symbol layer (considering symbol levels)
@ NoSymbology
Export only data.
void writeCircle(const QString &layer, const QColor &color, const QgsPoint &pt, double radius, const QString &lineStyleName, double width)
Write circle (as polyline)
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)
static double mapUnitScaleFactor(double scale, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
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.
QgsUnitTypes::DistanceUnit mapUnits() const
Retrieve map units.
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.
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)
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 SIP_HOLDGIL
Returns the number of geometries within the collection.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
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 SIP_HOLDGIL
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.
QgsUnitTypes::RenderUnit sizeUnit() const
Returns the units for the symbol's size.
double size() const
Returns the symbol 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.
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 yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
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 is empty.
QgsPointXY center() const SIP_HOLDGIL
Returns the center point 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.
virtual double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
virtual QVector< qreal > dxfCustomDashPattern(QgsUnitTypes::RenderUnit &unit) const
Gets dash pattern.
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
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
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.
Qgis::SymbolRenderHints renderHints() const
Returns the rendering hint flags for the symbol.
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.
DistanceUnit
Units of distance.
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
RenderUnit
Rendering size units.
@ RenderMillimeters
Millimeters.
@ RenderMapUnits
Map 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.
Type
The WKB type describes the number of dimensions a geometry has.
static Type flatType(Type type) SIP_HOLDGIL
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 rad).
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)
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,...