void QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, QgsStringMap props, bool firstRange ) const
{
if ( !mSymbol || props.value( QStringLiteral( "attribute" ), QLatin1String( "" ) ).isEmpty() )
return;
QString attrName = props[ QStringLiteral( "attribute" )];
QDomElement ruleElem = doc.createElement( QStringLiteral( "se:Rule" ) );
element.appendChild( ruleElem );
QDomElement nameElem = doc.createElement( QStringLiteral( "se:Name" ) );
nameElem.appendChild( doc.createTextNode( mLabel ) );
ruleElem.appendChild( nameElem );
QDomElement descrElem = doc.createElement( QStringLiteral( "se:Description" ) );
QDomElement titleElem = doc.createElement( QStringLiteral( "se:Title" ) );
QString descrStr = QStringLiteral( "range: %1 - %2" ).arg( qgsDoubleToString( mLowerValue ), qgsDoubleToString( mUpperValue ) );
titleElem.appendChild( doc.createTextNode( !mLabel.isEmpty() ? mLabel : descrStr ) );
descrElem.appendChild( titleElem );
ruleElem.appendChild( descrElem );
// create the ogc:Filter for the range
QString filterFunc = QStringLiteral( "\"%1\" %2 %3 AND \"%1\" <= %4" )
.arg( attrName.replace( '\"', QLatin1String( "\"\"" ) ),
firstRange ? QStringLiteral( ">=" ) : QStringLiteral( ">" ),
qgsDoubleToString( mLowerValue ),
qgsDoubleToString( mUpperValue ) );
QgsSymbolLayerUtils::createFunctionElement( doc, ruleElem, filterFunc );
mSymbol->toSld( doc, ruleElem, props );
}
void QgsMapCoordsDialog::maybeSetXY( const QgsPoint & xy, Qt::MouseButton button )
{
// Only LeftButton should set point
if ( Qt::LeftButton == button )
{
QgsPoint mapCoordPoint = xy;
if ( mQgisCanvas && mSnapToBackgroundLayerBox->isChecked() )
{
QgsPointLocator::Match m = mQgisCanvas->snappingUtils()->snapToMap( xy );
if ( m.isValid() )
mapCoordPoint = m.point();
}
leXCoord->clear();
leYCoord->clear();
leXCoord->setText( qgsDoubleToString( mapCoordPoint.x() ) );
leYCoord->setText( qgsDoubleToString( mapCoordPoint.y() ) );
}
parentWidget()->showNormal();
parentWidget()->activateWindow();
parentWidget()->raise();
mPointFromCanvasPushButton->setChecked( false );
buttonBox->button( QDialogButtonBox::Ok )->setFocus();
activateWindow();
raise();
}
void QgsVectorLayerSimpleLabeling::toSld( QDomNode &parent, const QgsStringMap &props ) const
{
if ( mSettings->drawLabels )
{
QDomDocument doc = parent.ownerDocument();
QDomElement ruleElement = doc.createElement( QStringLiteral( "se:Rule" ) );
parent.appendChild( ruleElement );
// scale dependencies
if ( mSettings->scaleVisibility )
{
QgsStringMap scaleProps = QgsStringMap();
// tricky here, the max scale is expressed as its denominator, but it's still the max scale
// in other words, the smallest scale denominator....
scaleProps.insert( "scaleMinDenom", qgsDoubleToString( mSettings->maximumScale ) );
scaleProps.insert( "scaleMaxDenom", qgsDoubleToString( mSettings->minimumScale ) );
QgsSymbolLayerUtils::applyScaleDependency( doc, ruleElement, scaleProps );
}
writeTextSymbolizer( ruleElement, *mSettings, props );
}
}
QString QgsPostgresFeatureIterator::whereClauseRect()
{
QgsRectangle rect = mRequest.filterRect();
if ( mSource->mSpatialColType == sctGeography )
{
rect = QgsRectangle( -180.0, -90.0, 180.0, 90.0 ).intersect( &rect );
}
if ( !rect.isFinite() )
{
QgsMessageLog::logMessage( QObject::tr( "Infinite filter rectangle specified" ), QObject::tr( "PostGIS" ) );
return "false";
}
QString qBox;
if ( mConn->majorVersion() < 2 )
{
qBox = QString( "setsrid('BOX3D(%1)'::box3d,%2)" )
.arg( rect.asWktCoordinates() )
.arg( mSource->mRequestedSrid.isEmpty() ? mSource->mDetectedSrid : mSource->mRequestedSrid );
}
else
{
qBox = QString( "st_makeenvelope(%1,%2,%3,%4,%5)" )
.arg( qgsDoubleToString( rect.xMinimum() ) )
.arg( qgsDoubleToString( rect.yMinimum() ) )
.arg( qgsDoubleToString( rect.xMaximum() ) )
.arg( qgsDoubleToString( rect.yMaximum() ) )
.arg( mSource->mRequestedSrid.isEmpty() ? mSource->mDetectedSrid : mSource->mRequestedSrid );
}
QString whereClause = QString( "%1 && %2" )
.arg( QgsPostgresConn::quotedIdentifier( mSource->mGeometryColumn ) )
.arg( qBox );
if ( mRequest.flags() & QgsFeatureRequest::ExactIntersect )
{
whereClause += QString( " AND %1(%2%3,%4)" )
.arg( mConn->majorVersion() < 2 ? "intersects" : "st_intersects" )
.arg( QgsPostgresConn::quotedIdentifier( mSource->mGeometryColumn ) )
.arg( mSource->mSpatialColType == sctGeography ? "::geometry" : "" )
.arg( qBox );
}
if ( !mSource->mRequestedSrid.isEmpty() && ( mSource->mRequestedSrid != mSource->mDetectedSrid || mSource->mRequestedSrid.toInt() == 0 ) )
{
whereClause += QString( " AND %1(%2%3)=%4" )
.arg( mConn->majorVersion() < 2 ? "srid" : "st_srid" )
.arg( QgsPostgresConn::quotedIdentifier( mSource->mGeometryColumn ) )
.arg( mSource->mSpatialColType == sctGeography ? "::geography" : "" )
.arg( mSource->mRequestedSrid );
}
if ( mSource->mRequestedGeomType != QGis::WKBUnknown && mSource->mRequestedGeomType != mSource->mDetectedGeomType )
{
whereClause += QString( " AND %1" ).arg( QgsPostgresConn::postgisTypeFilter( mSource->mGeometryColumn, mSource->mRequestedGeomType, mSource->mSpatialColType == sctGeography ) );
}
return whereClause;
}
QString QgsRectangle::asWktCoordinates() const
{
QString rep =
qgsDoubleToString( xmin ) + ' ' + qgsDoubleToString( ymin ) + ", " +
qgsDoubleToString( xmax ) + ' ' + qgsDoubleToString( ymax );
return rep;
}
QString QgsMargins::toString() const
{
if ( isNull() )
return QString();
else
return QStringLiteral( "%1,%2,%3,%4" ).arg( qgsDoubleToString( mLeft ), qgsDoubleToString( mTop ),
qgsDoubleToString( mRight ), qgsDoubleToString( mBottom ) );
}
QString QgsSpatiaLiteFeatureIterator::mbr( const QgsRectangle& rect )
{
return QString( "%1, %2, %3, %4" )
.arg( qgsDoubleToString( rect.xMinimum() ),
qgsDoubleToString( rect.yMinimum() ),
qgsDoubleToString( rect.xMaximum() ),
qgsDoubleToString( rect.yMaximum() ) );
}
void QgsAnnotationItem::_writeXml( QDomDocument& doc, QDomElement& itemElem ) const
{
if ( itemElem.isNull() )
{
return;
}
QDomElement annotationElem = doc.createElement( "AnnotationItem" );
annotationElem.setAttribute( "mapPositionFixed", mMapPositionFixed );
annotationElem.setAttribute( "mapPosX", qgsDoubleToString( mMapPosition.x() ) );
annotationElem.setAttribute( "mapPosY", qgsDoubleToString( mMapPosition.y() ) );
if ( mMapPositionCrs.isValid() )
mMapPositionCrs.writeXml( annotationElem, doc );
annotationElem.setAttribute( "offsetX", qgsDoubleToString( mOffsetFromReferencePoint.x() ) );
annotationElem.setAttribute( "offsetY", qgsDoubleToString( mOffsetFromReferencePoint.y() ) );
annotationElem.setAttribute( "frameWidth", qgsDoubleToString( mFrameSize.width() ) );
annotationElem.setAttribute( "frameHeight", qgsDoubleToString( mFrameSize.height() ) );
QPointF canvasPos = pos();
annotationElem.setAttribute( "canvasPosX", qgsDoubleToString( canvasPos.x() ) );
annotationElem.setAttribute( "canvasPosY", qgsDoubleToString( canvasPos.y() ) );
annotationElem.setAttribute( "frameBorderWidth", qgsDoubleToString( mFrameBorderWidth ) );
annotationElem.setAttribute( "frameColor", mFrameColor.name() );
annotationElem.setAttribute( "frameColorAlpha", mFrameColor.alpha() );
annotationElem.setAttribute( "frameBackgroundColor", mFrameBackgroundColor.name() );
annotationElem.setAttribute( "frameBackgroundColorAlpha", mFrameBackgroundColor.alpha() );
annotationElem.setAttribute( "visible", isVisible() );
if ( mMarkerSymbol )
{
QDomElement symbolElem = QgsSymbolLayerV2Utils::saveSymbol( "marker symbol", mMarkerSymbol, doc );
if ( !symbolElem.isNull() )
{
annotationElem.appendChild( symbolElem );
}
}
itemElem.appendChild( annotationElem );
}
QString QgsLineStringV2::asKML( int precision ) const
{
QString kml;
if ( isRing() )
{
kml.append( "<LinearRing>" );
}
else
{
kml.append( "<LineString>" );
}
bool z = is3D();
kml.append( "<altitudeMode>" );
if ( z )
{
kml.append( "absolute" );
}
else
{
kml.append( "clampToGround" );
}
kml.append( "</altitudeMode>" );
kml.append( "<coordinates>" );
int nPoints = mCoords.size();
for ( int i = 0; i < nPoints; ++i )
{
if ( i > 0 )
{
kml.append( " " );
}
kml.append( qgsDoubleToString( mCoords[i].x(), precision ) );
kml.append( "," );
kml.append( qgsDoubleToString( mCoords[i].y(), precision ) );
if ( z )
{
kml.append( "," );
kml.append( qgsDoubleToString( mZ[i], precision ) );
}
else
{
kml.append( ",0" );
}
}
kml.append( "</coordinates>" );
if ( isRing() )
{
kml.append( "</LinearRing>" );
}
else
{
kml.append( "</LineString>" );
}
return kml;
}
QString QgsWFSCapabilities::uriGetFeature( QString typeName, QString crsString, QString filter, QgsRectangle bBox ) const
{
//get CRS
if ( !crsString.isEmpty() )
{
crsString.prepend( "&SRSNAME=" );
}
QString filterString;
//if the xml comes from the dialog, it needs to be a string to pass the validity test
if ( filter.startsWith( "'" ) && filter.endsWith( "'" ) && filter.size() > 1 )
{
filter.chop( 1 );
filter.remove( 0, 1 );
}
if ( !filter.isEmpty() )
{
//test if filterString is already an OGC filter xml
QDomDocument filterDoc;
if ( !filterDoc.setContent( filter ) )
{
//if not, if must be a QGIS expression
QgsExpression filterExpression( filter );
QDomElement filterElem = QgsOgcUtils::expressionToOgcFilter( filterExpression, filterDoc );
if ( !filterElem.isNull() )
{
filterDoc.appendChild( filterElem );
}
}
filterString = "&FILTER=" + filterDoc.toString();
}
QString bBoxString;
if ( !bBox.isEmpty() )
{
bBoxString = QString( "&BBOX=%1,%2,%3,%4" )
.arg( qgsDoubleToString( bBox.xMinimum() ) )
.arg( qgsDoubleToString( bBox.yMinimum() ) )
.arg( qgsDoubleToString( bBox.xMaximum() ) )
.arg( qgsDoubleToString( bBox.yMaximum() ) );
}
QString uri = mBaseUrl;
//add a wfs layer to the map
uri += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=" + typeName + crsString + bBoxString + filterString;
QgsDebugMsg( uri );
return uri;
}
QString QgsRectangle::asWktPolygon() const
{
QString rep =
QString( "POLYGON((" ) +
qgsDoubleToString( xmin ) + ' ' + qgsDoubleToString( ymin ) + ", " +
qgsDoubleToString( xmax ) + ' ' + qgsDoubleToString( ymin ) + ", " +
qgsDoubleToString( xmax ) + ' ' + qgsDoubleToString( ymax ) + ", " +
qgsDoubleToString( xmin ) + ' ' + qgsDoubleToString( ymax ) + ", " +
qgsDoubleToString( xmin ) + ' ' + qgsDoubleToString( ymin ) +
QString( "))" );
return rep;
}
QString QgsSpatiaLiteFeatureIterator::whereClauseRect()
{
QgsRectangle rect = mRequest.filterRect();
QString whereClause;
if ( mRequest.flags() & QgsFeatureRequest::ExactIntersect )
{
// we are requested to evaluate a true INTERSECT relationship
whereClause += QString( "Intersects(%1, BuildMbr(%2)) AND " ).arg( QgsSpatiaLiteProvider::quotedIdentifier( mSource->mGeometryColumn ), mbr( rect ) );
}
if ( mSource->mVShapeBased )
{
// handling a VirtualShape layer
whereClause += QString( "MbrIntersects(%1, BuildMbr(%2))" ).arg( QgsSpatiaLiteProvider::quotedIdentifier( mSource->mGeometryColumn ), mbr( rect ) );
}
else if ( rect.isFinite() )
{
if ( mSource->spatialIndexRTree )
{
// using the RTree spatial index
QString mbrFilter = QString( "xmin <= %1 AND " ).arg( qgsDoubleToString( rect.xMaximum() ) );
mbrFilter += QString( "xmax >= %1 AND " ).arg( qgsDoubleToString( rect.xMinimum() ) );
mbrFilter += QString( "ymin <= %1 AND " ).arg( qgsDoubleToString( rect.yMaximum() ) );
mbrFilter += QString( "ymax >= %1" ).arg( qgsDoubleToString( rect.yMinimum() ) );
QString idxName = QString( "idx_%1_%2" ).arg( mSource->mIndexTable, mSource->mIndexGeometry );
whereClause += QString( "%1 IN (SELECT pkid FROM %2 WHERE %3)" )
.arg( quotedPrimaryKey(),
QgsSpatiaLiteProvider::quotedIdentifier( idxName ),
mbrFilter );
}
else if ( mSource->spatialIndexMbrCache )
{
// using the MbrCache spatial index
QString idxName = QString( "cache_%1_%2" ).arg( mSource->mIndexTable, mSource->mIndexGeometry );
whereClause += QString( "%1 IN (SELECT rowid FROM %2 WHERE mbr = FilterMbrIntersects(%3))" )
.arg( quotedPrimaryKey(),
QgsSpatiaLiteProvider::quotedIdentifier( idxName ),
mbr( rect ) );
}
else
{
// using simple MBR filtering
whereClause += QString( "MbrIntersects(%1, BuildMbr(%2))" ).arg( QgsSpatiaLiteProvider::quotedIdentifier( mSource->mGeometryColumn ), mbr( rect ) );
}
}
else
{
whereClause = "1";
}
return whereClause;
}
//the format defaults to "PNG" if not specified
void QgsMapCanvas::saveAsImage( const QString& theFileName, QPixmap * theQPixmap, const QString& theFormat )
{
//
//check if the optional QPaintDevice was supplied
//
if ( theQPixmap != NULL )
{
// render
QPainter painter;
painter.begin( theQPixmap );
QgsMapRendererCustomPainterJob job( mSettings, &painter );
job.start();
job.waitForFinished();
emit renderComplete( &painter );
painter.end();
theQPixmap->save( theFileName, theFormat.toLocal8Bit().data() );
}
else //use the map view
{
mMap->contentImage().save( theFileName, theFormat.toLocal8Bit().data() );
}
//create a world file to go with the image...
QgsRectangle myRect = mapSettings().visibleExtent();
QString myHeader;
// note: use 17 places of precision for all numbers output
//Pixel XDim
myHeader += qgsDoubleToString( mapUnitsPerPixel() ) + "\r\n";
//Rotation on y axis - hard coded
myHeader += "0 \r\n";
//Rotation on x axis - hard coded
myHeader += "0 \r\n";
//Pixel YDim - almost always negative - see
//http://en.wikipedia.org/wiki/World_file#cite_note-2
myHeader += '-' + qgsDoubleToString( mapUnitsPerPixel() ) + "\r\n";
//Origin X (center of top left cell)
myHeader += qgsDoubleToString( myRect.xMinimum() + ( mapUnitsPerPixel() / 2 ) ) + "\r\n";
//Origin Y (center of top left cell)
myHeader += qgsDoubleToString( myRect.yMaximum() - ( mapUnitsPerPixel() / 2 ) ) + "\r\n";
QFileInfo myInfo = QFileInfo( theFileName );
// allow dotted names
QString myWorldFileName = myInfo.absolutePath() + '/' + myInfo.completeBaseName() + '.' + theFormat + 'w';
QFile myWorldFile( myWorldFileName );
if ( !myWorldFile.open( QIODevice::WriteOnly ) ) //don't use QIODevice::Text
{
return;
}
QTextStream myStream( &myWorldFile );
myStream << myHeader;
} // saveAsImage
QString QgsCircle::toString( int pointPrecision, int radiusPrecision, int azimuthPrecision ) const
{
QString rep;
if ( isEmpty() )
rep = QStringLiteral( "Empty" );
else
rep = QStringLiteral( "Circle (Center: %1, Radius: %2, Azimuth: %3)" )
.arg( mCenter.asWkt( pointPrecision ), 0, 's' )
.arg( qgsDoubleToString( mSemiMajorAxis, radiusPrecision ), 0, 'f' )
.arg( qgsDoubleToString( mAzimuth, azimuthPrecision ), 0, 'f' );
return rep;
}
QString QgsRegularPolygon::toString( int pointPrecision, int radiusPrecision, int anglePrecision ) const
{
QString rep;
if ( isEmpty() )
rep = QStringLiteral( "Empty" );
else
rep = QStringLiteral( "RegularPolygon (Center: %1, First Vertex: %2, Radius: %3, Azimuth: %4)" )
.arg( mCenter.asWkt( pointPrecision ), 0, 's' )
.arg( mFirstVertex.asWkt( pointPrecision ), 0, 's' )
.arg( qgsDoubleToString( mRadius, radiusPrecision ), 0, 'f' )
.arg( qgsDoubleToString( mCenter.azimuth( mFirstVertex ), anglePrecision ), 0, 'f' );
// TODO: inclination
// .arg( qgsDoubleToString( mCenter.inclination(mFirstVertex), anglePrecision ), 0, 'f' );
return rep;
}
void QgsMapSettings::writeXML( QDomNode& theNode, QDomDocument& theDoc )
{
// units
theNode.appendChild( QgsXmlUtils::writeMapUnits( mapUnits(), theDoc ) );
// Write current view extents
theNode.appendChild( QgsXmlUtils::writeRectangle( extent(), theDoc ) );
// Write current view rotation
QDomElement rotNode = theDoc.createElement( "rotation" );
rotNode.appendChild(
theDoc.createTextNode( qgsDoubleToString( rotation() ) )
);
theNode.appendChild( rotNode );
// projections enabled
QDomElement projNode = theDoc.createElement( "projections" );
projNode.appendChild( theDoc.createTextNode( QString::number( hasCrsTransformEnabled() ) ) );
theNode.appendChild( projNode );
// destination CRS
QDomElement srsNode = theDoc.createElement( "destinationsrs" );
theNode.appendChild( srsNode );
destinationCrs().writeXML( srsNode, theDoc );
//render map tile
QDomElement renderMapTileElem = theDoc.createElement( "rendermaptile" );
QDomText renderMapTileText = theDoc.createTextNode( testFlag( QgsMapSettings::RenderMapTile ) ? "1" : "0" );
renderMapTileElem.appendChild( renderMapTileText );
theNode.appendChild( renderMapTileElem );
mDatumTransformStore.writeXML( theNode, theDoc );
}
void QgsMapSettings::writeXml( QDomNode &node, QDomDocument &doc )
{
// units
node.appendChild( QgsXmlUtils::writeMapUnits( mapUnits(), doc ) );
// Write current view extents
node.appendChild( QgsXmlUtils::writeRectangle( extent(), doc ) );
// Write current view rotation
QDomElement rotNode = doc.createElement( QStringLiteral( "rotation" ) );
rotNode.appendChild(
doc.createTextNode( qgsDoubleToString( rotation() ) )
);
node.appendChild( rotNode );
// destination CRS
if ( mDestCRS.isValid() )
{
QDomElement srsNode = doc.createElement( QStringLiteral( "destinationsrs" ) );
node.appendChild( srsNode );
mDestCRS.writeXml( srsNode, doc );
}
//render map tile
QDomElement renderMapTileElem = doc.createElement( QStringLiteral( "rendermaptile" ) );
QDomText renderMapTileText = doc.createTextNode( testFlag( QgsMapSettings::RenderMapTile ) ? "1" : "0" );
renderMapTileElem.appendChild( renderMapTileText );
node.appendChild( renderMapTileElem );
}
void QgsMapCoordsDialog::maybeSetXY( const QgsPoint & xy, Qt::MouseButton button )
{
// Only LeftButton should set point
if ( Qt::LeftButton == button )
{
QgsPoint mapCoordPoint = xy;
if ( mQgisCanvas && mSnapToBackgroundLayerBox->isChecked() )
{
const QgsMapToPixel* mtp = mQgisCanvas->getCoordinateTransform();
if ( mtp )
{
QgsPoint canvasPos = mtp->transform( xy.x(), xy.y() );
QPoint snapStartPoint( canvasPos.x(), canvasPos.y() );
QgsMapCanvasSnapper snapper( mQgisCanvas );
QList<QgsSnappingResult> snapResults;
if ( snapper.snapToBackgroundLayers( snapStartPoint, snapResults ) == 0 )
{
if ( snapResults.size() > 0 )
{
mapCoordPoint = snapResults.at( 0 ).snappedVertex;
}
}
}
}
leXCoord->clear();
leYCoord->clear();
leXCoord->setText( qgsDoubleToString( mapCoordPoint.x() ) );
leYCoord->setText( qgsDoubleToString( mapCoordPoint.y() ) );
}
parentWidget()->showNormal();
parentWidget()->activateWindow();
parentWidget()->raise();
mPointFromCanvasPushButton->setChecked( false );
buttonBox->button( QDialogButtonBox::Ok )->setFocus();
activateWindow();
raise();
}
QDomElement QgsXmlUtils::writeRectangle( const QgsRectangle& rect, QDomDocument& doc )
{
QDomElement xMin = doc.createElement( "xmin" );
QDomElement yMin = doc.createElement( "ymin" );
QDomElement xMax = doc.createElement( "xmax" );
QDomElement yMax = doc.createElement( "ymax" );
QDomText xMinText = doc.createTextNode( qgsDoubleToString( rect.xMinimum() ) );
QDomText yMinText = doc.createTextNode( qgsDoubleToString( rect.yMinimum() ) );
QDomText xMaxText = doc.createTextNode( qgsDoubleToString( rect.xMaximum() ) );
QDomText yMaxText = doc.createTextNode( qgsDoubleToString( rect.yMaximum() ) );
xMin.appendChild( xMinText );
yMin.appendChild( yMinText );
xMax.appendChild( xMaxText );
yMax.appendChild( yMaxText );
QDomElement extentNode = doc.createElement( "extent" );
extentNode.appendChild( xMin );
extentNode.appendChild( yMin );
extentNode.appendChild( xMax );
extentNode.appendChild( yMax );
return extentNode;
}
void QgsAnnotation::_writeXml( QDomElement &itemElem, QDomDocument &doc, const QgsReadWriteContext &context ) const
{
if ( itemElem.isNull() )
{
return;
}
QDomElement annotationElem = doc.createElement( QStringLiteral( "AnnotationItem" ) );
annotationElem.setAttribute( QStringLiteral( "mapPositionFixed" ), mHasFixedMapPosition );
annotationElem.setAttribute( QStringLiteral( "mapPosX" ), qgsDoubleToString( mMapPosition.x() ) );
annotationElem.setAttribute( QStringLiteral( "mapPosY" ), qgsDoubleToString( mMapPosition.y() ) );
if ( mMapPositionCrs.isValid() )
mMapPositionCrs.writeXml( annotationElem, doc );
annotationElem.setAttribute( QStringLiteral( "offsetX" ), qgsDoubleToString( mOffsetFromReferencePoint.x() ) );
annotationElem.setAttribute( QStringLiteral( "offsetY" ), qgsDoubleToString( mOffsetFromReferencePoint.y() ) );
annotationElem.setAttribute( QStringLiteral( "frameWidth" ), qgsDoubleToString( mFrameSize.width() ) );
annotationElem.setAttribute( QStringLiteral( "frameHeight" ), qgsDoubleToString( mFrameSize.height() ) );
annotationElem.setAttribute( QStringLiteral( "canvasPosX" ), qgsDoubleToString( mRelativePosition.x() ) );
annotationElem.setAttribute( QStringLiteral( "canvasPosY" ), qgsDoubleToString( mRelativePosition.y() ) );
annotationElem.setAttribute( QStringLiteral( "contentsMargin" ), mContentsMargins.toString() );
annotationElem.setAttribute( QStringLiteral( "visible" ), isVisible() );
if ( mMapLayer )
{
annotationElem.setAttribute( QStringLiteral( "mapLayer" ), mMapLayer->id() );
}
if ( mMarkerSymbol )
{
QDomElement symbolElem = QgsSymbolLayerUtils::saveSymbol( QStringLiteral( "marker symbol" ), mMarkerSymbol.get(), doc, context );
if ( !symbolElem.isNull() )
{
annotationElem.appendChild( symbolElem );
}
}
if ( mFillSymbol )
{
QDomElement fillElem = doc.createElement( QStringLiteral( "fillSymbol" ) );
QDomElement symbolElem = QgsSymbolLayerUtils::saveSymbol( QStringLiteral( "fill symbol" ), mFillSymbol.get(), doc, context );
if ( !symbolElem.isNull() )
{
fillElem.appendChild( symbolElem );
annotationElem.appendChild( fillElem );
}
}
itemElem.appendChild( annotationElem );
}
void QgsMapRenderer::adjustExtentToSize()
{
double myHeight = mSize.height();
double myWidth = mSize.width();
QgsMapToPixel newCoordXForm;
if ( !myWidth || !myHeight )
{
mScale = 1.0;
newCoordXForm.setParameters( 0, 0, 0, 0 );
return;
}
// calculate the translation and scaling parameters
// mapUnitsPerPixel = map units per pixel
double mapUnitsPerPixelY = mExtent.height() / myHeight;
double mapUnitsPerPixelX = mExtent.width() / myWidth;
mMapUnitsPerPixel = mapUnitsPerPixelY > mapUnitsPerPixelX ? mapUnitsPerPixelY : mapUnitsPerPixelX;
// calculate the actual extent of the mapCanvas
double dxmin, dxmax, dymin, dymax, whitespace;
if ( mapUnitsPerPixelY > mapUnitsPerPixelX )
{
dymin = mExtent.yMinimum();
dymax = mExtent.yMaximum();
whitespace = (( myWidth * mMapUnitsPerPixel ) - mExtent.width() ) * 0.5;
dxmin = mExtent.xMinimum() - whitespace;
dxmax = mExtent.xMaximum() + whitespace;
}
else
{
dxmin = mExtent.xMinimum();
dxmax = mExtent.xMaximum();
whitespace = (( myHeight * mMapUnitsPerPixel ) - mExtent.height() ) * 0.5;
dymin = mExtent.yMinimum() - whitespace;
dymax = mExtent.yMaximum() + whitespace;
}
QgsDebugMsg( QString( "Map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mapUnitsPerPixelX ) ).arg( qgsDoubleToString( mapUnitsPerPixelY ) ) );
QgsDebugMsg( QString( "Pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( myWidth ) ).arg( qgsDoubleToString( myHeight ) ) );
QgsDebugMsg( QString( "Extent dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mExtent.width() ) ).arg( qgsDoubleToString( mExtent.height() ) ) );
QgsDebugMsg( mExtent.toString() );
// update extent
mExtent.setXMinimum( dxmin );
mExtent.setXMaximum( dxmax );
mExtent.setYMinimum( dymin );
mExtent.setYMaximum( dymax );
QgsDebugMsg( QString( "Adjusted map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mExtent.width() / myWidth ) ).arg( qgsDoubleToString( mExtent.height() / myHeight ) ) );
QgsDebugMsg( QString( "Recalced pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mExtent.width() / mMapUnitsPerPixel ) ).arg( qgsDoubleToString( mExtent.height() / mMapUnitsPerPixel ) ) );
// update the scale
updateScale();
QgsDebugMsg( QString( "Scale (assuming meters as map units) = 1:%1" ).arg( qgsDoubleToString( mScale ) ) );
newCoordXForm.setParameters( mMapUnitsPerPixel, dxmin, dymin, myHeight );
mRenderContext.setMapToPixel( newCoordXForm );
mRenderContext.setExtent( mExtent );
}
QUrl QgsWFSFeatureDownloader::buildURL( int startIndex, int maxFeatures, bool forHits )
{
QUrl getFeatureUrl( mShared->mURI.baseURL() );
getFeatureUrl.addQueryItem( QStringLiteral( "REQUEST" ), QStringLiteral( "GetFeature" ) );
getFeatureUrl.addQueryItem( QStringLiteral( "VERSION" ), mShared->mWFSVersion );
QString typenames;
if ( mShared->mLayerPropertiesList.isEmpty() )
{
typenames = mShared->mURI.typeName();
}
else
{
Q_FOREACH ( const QgsOgcUtils::LayerProperties layerProperties, mShared->mLayerPropertiesList )
{
if ( !typenames.isEmpty() )
typenames += QLatin1String( "," );
typenames += layerProperties.mName;
}
}
if ( mShared->mWFSVersion.startsWith( QLatin1String( "2.0" ) ) )
getFeatureUrl.addQueryItem( QStringLiteral( "TYPENAMES" ), typenames );
else
getFeatureUrl.addQueryItem( QStringLiteral( "TYPENAME" ), typenames );
if ( forHits )
{
getFeatureUrl.addQueryItem( QStringLiteral( "RESULTTYPE" ), QStringLiteral( "hits" ) );
}
else if ( maxFeatures > 0 )
{
if ( mSupportsPaging )
{
// Note: always include the STARTINDEX, even for zero, has some (likely buggy)
// implementations do not return the same results if STARTINDEX=0 is specified
// or not.
// For example http://demo.opengeo.org/geoserver/wfs?SERVICE=WFS&REQUEST=GetFeature&VERSION=2.0.0&TYPENAMES=ne:ne_10m_admin_0_countries&STARTINDEX=0&COUNT=253
// doesn't include ne_10m_admin_0_countries.99, as expected since it is
// at index 254.
getFeatureUrl.addQueryItem( QStringLiteral( "STARTINDEX" ), QString::number( startIndex ) );
}
if ( mShared->mWFSVersion.startsWith( QLatin1String( "2.0" ) ) )
getFeatureUrl.addQueryItem( QStringLiteral( "COUNT" ), QString::number( maxFeatures ) );
else
getFeatureUrl.addQueryItem( QStringLiteral( "MAXFEATURES" ), QString::number( maxFeatures ) );
}
QString srsName( mShared->srsName() );
if ( !srsName.isEmpty() && !forHits )
{
getFeatureUrl.addQueryItem( QStringLiteral( "SRSNAME" ), srsName );
}
// In case we must issue a BBOX and we have a filter, we must combine
// both as a single filter, as both BBOX and FILTER aren't supported together
if ( !mShared->mRect.isNull() && !mShared->mWFSFilter.isEmpty() )
{
double minx = mShared->mRect.xMinimum();
double miny = mShared->mRect.yMinimum();
double maxx = mShared->mRect.xMaximum();
double maxy = mShared->mRect.yMaximum();
QString filterBbox( QStringLiteral( "intersects_bbox($geometry, geomFromWKT('LINESTRING(%1 %2,%3 %4)'))" ).
arg( minx ).arg( miny ).arg( maxx ).arg( maxy ) );
QgsExpression bboxExp( filterBbox );
QgsOgcUtils::GMLVersion gmlVersion;
QgsOgcUtils::FilterVersion filterVersion;
bool honourAxisOrientation = false;
if ( mShared->mWFSVersion.startsWith( QLatin1String( "1.0" ) ) )
{
gmlVersion = QgsOgcUtils::GML_2_1_2;
filterVersion = QgsOgcUtils::FILTER_OGC_1_0;
}
else if ( mShared->mWFSVersion.startsWith( QLatin1String( "1.1" ) ) )
{
honourAxisOrientation = !mShared->mURI.ignoreAxisOrientation();
gmlVersion = QgsOgcUtils::GML_3_1_0;
filterVersion = QgsOgcUtils::FILTER_OGC_1_1;
}
else
{
honourAxisOrientation = !mShared->mURI.ignoreAxisOrientation();
gmlVersion = QgsOgcUtils::GML_3_2_1;
filterVersion = QgsOgcUtils::FILTER_FES_2_0;
}
QDomDocument doc;
QString geometryAttribute( mShared->mGeometryAttribute );
if ( mShared->mLayerPropertiesList.size() > 1 )
geometryAttribute = mShared->mURI.typeName() + "/" + geometryAttribute;
QDomElement bboxElem = QgsOgcUtils::expressionToOgcFilter( bboxExp, doc,
gmlVersion, filterVersion, geometryAttribute, mShared->srsName(),
honourAxisOrientation, mShared->mURI.invertAxisOrientation() );
doc.appendChild( bboxElem );
QDomNode bboxNode = bboxElem.firstChildElement();
bboxNode = bboxElem.removeChild( bboxNode );
QDomDocument filterDoc;
( void )filterDoc.setContent( mShared->mWFSFilter, true );
QDomNode filterNode = filterDoc.firstChildElement().firstChildElement();
filterNode = filterDoc.firstChildElement().removeChild( filterNode );
QDomElement andElem = doc.createElement( ( filterVersion == QgsOgcUtils::FILTER_FES_2_0 ) ? "fes:And" : "ogc:And" );
andElem.appendChild( bboxNode );
andElem.appendChild( filterNode );
doc.firstChildElement().appendChild( andElem );
getFeatureUrl.addQueryItem( QStringLiteral( "FILTER" ), sanitizeFilter( doc.toString() ) );
}
else if ( !mShared->mRect.isNull() )
{
bool invertAxis = false;
if ( !mShared->mWFSVersion.startsWith( QLatin1String( "1.0" ) ) && !mShared->mURI.ignoreAxisOrientation() &&
mShared->mSourceCRS.hasAxisInverted() )
{
invertAxis = true;
}
if ( mShared->mURI.invertAxisOrientation() )
{
invertAxis = !invertAxis;
}
QString bbox( QString( ( invertAxis ) ? "%2,%1,%4,%3" : "%1,%2,%3,%4" )
.arg( qgsDoubleToString( mShared->mRect.xMinimum() ),
qgsDoubleToString( mShared->mRect.yMinimum() ),
qgsDoubleToString( mShared->mRect.xMaximum() ),
qgsDoubleToString( mShared->mRect.yMaximum() ) ) );
// Some servers like Geomedia need the srsname to be explicitly appended
// otherwise they are confused and do not interpret it properly
if ( !mShared->mWFSVersion.startsWith( QLatin1String( "1.0" ) ) )
{
// but it is illegal in WFS 1.0 and some servers definitely not like
// it. See #15464
bbox += "," + mShared->srsName();
}
getFeatureUrl.addQueryItem( QStringLiteral( "BBOX" ), bbox );
}
else if ( !mShared->mWFSFilter.isEmpty() )
{
getFeatureUrl.addQueryItem( QStringLiteral( "FILTER" ), sanitizeFilter( mShared->mWFSFilter ) );
}
if ( !mShared->mSortBy.isEmpty() && !forHits )
{
getFeatureUrl.addQueryItem( QStringLiteral( "SORTBY" ), mShared->mSortBy );
}
if ( !forHits && !mShared->mURI.outputFormat().isEmpty() )
{
getFeatureUrl.addQueryItem( QStringLiteral( "OUTPUTFORMAT" ), mShared->mURI.outputFormat() );
}
else if ( !forHits && mShared->mWFSVersion.startsWith( QLatin1String( "1.0" ) ) )
{
QStringList list;
list << QStringLiteral( "text/xml; subtype=gml/3.2.1" );
list << QStringLiteral( "application/gml+xml; version=3.2" );
list << QStringLiteral( "text/xml; subtype=gml/3.1.1" );
list << QStringLiteral( "application/gml+xml; version=3.1" );
list << QStringLiteral( "text/xml; subtype=gml/3.0.1" );
list << QStringLiteral( "application/gml+xml; version=3.0" );
list << QStringLiteral( "GML3" );
Q_FOREACH ( const QString &format, list )
{
if ( mShared->mCaps.outputFormats.contains( format ) )
{
getFeatureUrl.addQueryItem( QStringLiteral( "OUTPUTFORMAT" ),
format );
break;
}
}
}
void QgsMapSettings::updateDerived()
{
QgsRectangle extent = mExtent;
if ( extent.isEmpty() || !extent.isFinite() )
{
mValid = false;
return;
}
// Don't allow zooms where the current extent is so small that it
// can't be accurately represented using a double (which is what
// currentExtent uses). Excluding 0 avoids a divide by zero and an
// infinite loop when rendering to a new canvas. Excluding extents
// greater than 1 avoids doing unnecessary calculations.
// The scheme is to compare the width against the mean x coordinate
// (and height against mean y coordinate) and only allow zooms where
// the ratio indicates that there is more than about 12 significant
// figures (there are about 16 significant figures in a double).
if ( extent.width() > 0 &&
extent.height() > 0 &&
extent.width() < 1 &&
extent.height() < 1 )
{
// Use abs() on the extent to avoid the case where the extent is
// symmetrical about 0.
double xMean = ( qAbs( extent.xMinimum() ) + qAbs( extent.xMaximum() ) ) * 0.5;
double yMean = ( qAbs( extent.yMinimum() ) + qAbs( extent.yMaximum() ) ) * 0.5;
double xRange = extent.width() / xMean;
double yRange = extent.height() / yMean;
static const double minProportion = 1e-12;
if ( xRange < minProportion || yRange < minProportion )
{
mValid = false;
return;
}
}
double myHeight = mSize.height();
double myWidth = mSize.width();
if ( !myWidth || !myHeight )
{
mValid = false;
return;
}
// calculate the translation and scaling parameters
double mapUnitsPerPixelY = mExtent.height() / myHeight;
double mapUnitsPerPixelX = mExtent.width() / myWidth;
mMapUnitsPerPixel = mapUnitsPerPixelY > mapUnitsPerPixelX ? mapUnitsPerPixelY : mapUnitsPerPixelX;
// calculate the actual extent of the mapCanvas
double dxmin = mExtent.xMinimum(), dxmax = mExtent.xMaximum(),
dymin = mExtent.yMinimum(), dymax = mExtent.yMaximum(), whitespace;
if ( mapUnitsPerPixelY > mapUnitsPerPixelX )
{
whitespace = (( myWidth * mMapUnitsPerPixel ) - mExtent.width() ) * 0.5;
dxmin -= whitespace;
dxmax += whitespace;
}
else
{
whitespace = (( myHeight * mMapUnitsPerPixel ) - mExtent.height() ) * 0.5;
dymin -= whitespace;
dymax += whitespace;
}
mVisibleExtent.set( dxmin, dymin, dxmax, dymax );
// update the scale
mScaleCalculator.setDpi( mDpi );
mScale = mScaleCalculator.calculate( mVisibleExtent, mSize.width() );
mMapToPixel.setParameters( mapUnitsPerPixel(),
visibleExtent().center().x(),
visibleExtent().center().y(),
outputSize().width(),
outputSize().height(),
mRotation );
#if 1 // set visible extent taking rotation in consideration
if ( mRotation )
{
QgsPoint p1 = mMapToPixel.toMapCoordinates( QPoint( 0, 0 ) );
QgsPoint p2 = mMapToPixel.toMapCoordinates( QPoint( 0, myHeight ) );
QgsPoint p3 = mMapToPixel.toMapCoordinates( QPoint( myWidth, 0 ) );
QgsPoint p4 = mMapToPixel.toMapCoordinates( QPoint( myWidth, myHeight ) );
dxmin = std::min( p1.x(), std::min( p2.x(), std::min( p3.x(), p4.x() ) ) );
dymin = std::min( p1.y(), std::min( p2.y(), std::min( p3.y(), p4.y() ) ) );
dxmax = std::max( p1.x(), std::max( p2.x(), std::max( p3.x(), p4.x() ) ) );
dymax = std::max( p1.y(), std::max( p2.y(), std::max( p3.y(), p4.y() ) ) );
mVisibleExtent.set( dxmin, dymin, dxmax, dymax );
}
#endif
QgsDebugMsg( QString( "Map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mapUnitsPerPixelX ), qgsDoubleToString( mapUnitsPerPixelY ) ) );
QgsDebugMsg( QString( "Pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mSize.width() ), qgsDoubleToString( mSize.height() ) ) );
QgsDebugMsg( QString( "Extent dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mExtent.width() ), qgsDoubleToString( mExtent.height() ) ) );
QgsDebugMsg( mExtent.toString() );
QgsDebugMsg( QString( "Adjusted map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mVisibleExtent.width() / myWidth ), qgsDoubleToString( mVisibleExtent.height() / myHeight ) ) );
QgsDebugMsg( QString( "Recalced pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mVisibleExtent.width() / mMapUnitsPerPixel ), qgsDoubleToString( mVisibleExtent.height() / mMapUnitsPerPixel ) ) );
QgsDebugMsg( QString( "Scale (assuming meters as map units) = 1:%1" ).arg( qgsDoubleToString( mScale ) ) );
QgsDebugMsg( QString( "Rotation: %1 degrees" ).arg( mRotation ) );
mValid = true;
}
void QgsAbstractVectorLayerLabeling::writeTextSymbolizer( QDomNode &parent, QgsPalLayerSettings &settings, const QgsStringMap &props ) const
{
QDomDocument doc = parent.ownerDocument();
// text symbolizer
QDomElement textSymbolizerElement = doc.createElement( QStringLiteral( "se:TextSymbolizer" ) );
parent.appendChild( textSymbolizerElement );
// label
QgsTextFormat format = settings.format();
QFont font = format.font();
QDomElement labelElement = doc.createElement( QStringLiteral( "se:Label" ) );
textSymbolizerElement.appendChild( labelElement );
if ( settings.isExpression )
{
labelElement.appendChild( doc.createComment( QStringLiteral( "SE Export for %1 not implemented yet" ).arg( settings.getLabelExpression()->dump() ) ) );
labelElement.appendChild( doc.createTextNode( "Placeholder" ) );
}
else
{
if ( font.capitalization() == QFont::AllUppercase )
{
appendSimpleFunction( doc, labelElement, QStringLiteral( "strToUpperCase" ), settings.fieldName );
}
else if ( font.capitalization() == QFont::AllLowercase )
{
appendSimpleFunction( doc, labelElement, QStringLiteral( "strToLowerCase" ), settings.fieldName );
}
else if ( font.capitalization() == QFont::Capitalize )
{
appendSimpleFunction( doc, labelElement, QStringLiteral( "strCapitalize" ), settings.fieldName );
}
else
{
QDomElement propertyNameElement = doc.createElement( QStringLiteral( "ogc:PropertyName" ) );
propertyNameElement.appendChild( doc.createTextNode( settings.fieldName ) );
labelElement.appendChild( propertyNameElement );
}
}
// font
QDomElement fontElement = doc.createElement( QStringLiteral( "se:Font" ) );
textSymbolizerElement.appendChild( fontElement );
fontElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "font-family" ), font.family() ) );
double fontSize = QgsSymbolLayerUtils::rescaleUom( format.size(), format.sizeUnit(), props );
fontElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "font-size" ), QString::number( fontSize ) ) );
if ( format.font().italic() )
{
fontElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "font-style" ), QStringLiteral( "italic" ) ) );
}
if ( format.font().bold() )
{
fontElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "font-weight" ), QStringLiteral( "bold" ) ) );
}
// label placement
QDomElement labelPlacement = doc.createElement( QStringLiteral( "se:LabelPlacement" ) );
textSymbolizerElement.appendChild( labelPlacement );
double maxDisplacement = 0;
double repeatDistance = 0;
switch ( settings.placement )
{
case QgsPalLayerSettings::OverPoint:
{
QDomElement pointPlacement = doc.createElement( "se:PointPlacement" );
labelPlacement.appendChild( pointPlacement );
// anchor point
QPointF anchor = quadOffsetToSldAnchor( settings.quadOffset );
QgsSymbolLayerUtils::createAnchorPointElement( doc, pointPlacement, anchor );
// displacement
if ( settings.xOffset > 0 || settings.yOffset > 0 )
{
QgsUnitTypes::RenderUnit offsetUnit = settings.offsetUnits;
double dx = QgsSymbolLayerUtils::rescaleUom( settings.xOffset, offsetUnit, props );
double dy = QgsSymbolLayerUtils::rescaleUom( settings.yOffset, offsetUnit, props );
QgsSymbolLayerUtils::createDisplacementElement( doc, pointPlacement, QPointF( dx, dy ) );
}
// rotation
if ( settings.angleOffset != 0 )
{
QDomElement rotation = doc.createElement( "se:Rotation" );
pointPlacement.appendChild( rotation );
rotation.appendChild( doc.createTextNode( QString::number( settings.angleOffset ) ) );
}
}
break;
case QgsPalLayerSettings::AroundPoint:
case QgsPalLayerSettings::OrderedPositionsAroundPoint:
{
QDomElement pointPlacement = doc.createElement( "se:PointPlacement" );
labelPlacement.appendChild( pointPlacement );
// SLD cannot do either, but let's do a best effort setting the distance using
// anchor point and displacement
QgsSymbolLayerUtils::createAnchorPointElement( doc, pointPlacement, QPointF( 0, 0.5 ) );
QgsUnitTypes::RenderUnit distUnit = settings.distUnits;
double radius = QgsSymbolLayerUtils::rescaleUom( settings.dist, distUnit, props );
double offset = std::sqrt( radius * radius / 2 ); // make it start top/right
maxDisplacement = radius + 1; // lock the distance
QgsSymbolLayerUtils::createDisplacementElement( doc, pointPlacement, QPointF( offset, offset ) );
}
break;
case QgsPalLayerSettings::Horizontal:
case QgsPalLayerSettings::Free:
{
// still a point placement (for "free" it's a fallback, there is no SLD equivalent)
QDomElement pointPlacement = doc.createElement( "se:PointPlacement" );
labelPlacement.appendChild( pointPlacement );
QgsSymbolLayerUtils::createAnchorPointElement( doc, pointPlacement, QPointF( 0.5, 0.5 ) );
QgsUnitTypes::RenderUnit distUnit = settings.distUnits;
double dist = QgsSymbolLayerUtils::rescaleUom( settings.dist, distUnit, props );
QgsSymbolLayerUtils::createDisplacementElement( doc, pointPlacement, QPointF( 0, dist ) );
break;
}
case QgsPalLayerSettings::Line:
case QgsPalLayerSettings::Curved:
case QgsPalLayerSettings::PerimeterCurved:
{
QDomElement linePlacement = doc.createElement( "se:LinePlacement" );
labelPlacement.appendChild( linePlacement );
// perpendicular distance if required
if ( settings.dist > 0 )
{
QgsUnitTypes::RenderUnit distUnit = settings.distUnits;
double dist = QgsSymbolLayerUtils::rescaleUom( settings.dist, distUnit, props );
QDomElement perpendicular = doc.createElement( "se:PerpendicularOffset" );
linePlacement.appendChild( perpendicular );
perpendicular.appendChild( doc.createTextNode( qgsDoubleToString( dist, 2 ) ) );
}
// repeat distance if required
if ( settings.repeatDistance > 0 )
{
QDomElement repeat = doc.createElement( "se:Repeat" );
linePlacement.appendChild( repeat );
repeat.appendChild( doc.createTextNode( QStringLiteral( "true" ) ) );
QDomElement gap = doc.createElement( "se:Gap" );
linePlacement.appendChild( gap );
repeatDistance = QgsSymbolLayerUtils::rescaleUom( settings.repeatDistance, settings.repeatDistanceUnit, props );
gap.appendChild( doc.createTextNode( qgsDoubleToString( repeatDistance, 2 ) ) );
}
// always generalized
QDomElement generalize = doc.createElement( "se:GeneralizeLine" );
linePlacement.appendChild( generalize );
generalize.appendChild( doc.createTextNode( QStringLiteral( "true" ) ) );
}
break;
}
// halo
QgsTextBufferSettings buffer = format.buffer();
if ( buffer.enabled() )
{
QDomElement haloElement = doc.createElement( QStringLiteral( "se:Halo" ) );
textSymbolizerElement.appendChild( haloElement );
QDomElement radiusElement = doc.createElement( QStringLiteral( "se:Radius" ) );
haloElement.appendChild( radiusElement );
// the SLD uses a radius, which is actually half of the link thickness the buffer size specifies
double radius = QgsSymbolLayerUtils::rescaleUom( buffer.size(), buffer.sizeUnit(), props ) / 2;
radiusElement.appendChild( doc.createTextNode( qgsDoubleToString( radius ) ) );
QDomElement fillElement = doc.createElement( QStringLiteral( "se:Fill" ) );
haloElement.appendChild( fillElement );
fillElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "fill" ), buffer.color().name() ) );
if ( buffer.opacity() != 1 )
{
fillElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "fill-opacity" ), QString::number( buffer.opacity() ) ) );
}
}
// fill
QDomElement fillElement = doc.createElement( QStringLiteral( "se:Fill" ) );
textSymbolizerElement.appendChild( fillElement );
fillElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "fill" ), format.color().name() ) );
if ( format.opacity() != 1 )
{
fillElement.appendChild( QgsSymbolLayerUtils::createSvgParameterElement( doc, QStringLiteral( "fill-opacity" ), QString::number( format.opacity() ) ) );
}
// background graphic (not supported by SE 1.1, but supported by the GeoTools ecosystem as an extension)
QgsTextBackgroundSettings background = format.background();
if ( background.enabled() )
{
std::unique_ptr<QgsMarkerSymbolLayer> layer = backgroundToMarkerLayer( background );
layer->writeSldMarker( doc, textSymbolizerElement, props );
}
// priority and zIndex, the default values are 0 and 5 in qgis (and between 0 and 10),
// in the GeoTools ecosystem there is a single priority value set at 1000 by default
if ( settings.priority != 5 || settings.zIndex > 0 )
{
QDomElement priorityElement = doc.createElement( QStringLiteral( "se:Priority" ) );
textSymbolizerElement.appendChild( priorityElement );
int priority = 500 + 1000 * settings.zIndex + ( settings.priority - 5 ) * 100;
if ( settings.priority == 0 && settings.zIndex > 0 )
{
// small adjustment to make sure labels in z index n+1 are all above level n despite the priority value
priority += 1;
}
priorityElement.appendChild( doc.createTextNode( QString::number( priority ) ) );
}
// vendor options for text appearance
if ( font.underline() )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "underlineText" ), QStringLiteral( "true" ) );
textSymbolizerElement.appendChild( vo );
}
if ( font.strikeOut() )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "strikethroughText" ), QStringLiteral( "true" ) );
textSymbolizerElement.appendChild( vo );
}
// vendor options for text positioning
if ( maxDisplacement > 0 )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "maxDisplacement" ), qgsDoubleToString( maxDisplacement, 2 ) );
textSymbolizerElement.appendChild( vo );
}
if ( settings.placement == QgsPalLayerSettings::Curved || settings.placement == QgsPalLayerSettings::PerimeterCurved )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "followLine" ), QStringLiteral( "true" ) );
textSymbolizerElement.appendChild( vo );
if ( settings.maxCurvedCharAngleIn > 0 || settings.maxCurvedCharAngleOut > 0 )
{
// SLD has no notion for this, the GeoTools ecosystem can only do a single angle
double angle = std::min( std::fabs( settings.maxCurvedCharAngleIn ), std::fabs( settings.maxCurvedCharAngleOut ) );
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "maxAngleDelta" ), qgsDoubleToString( angle ) );
textSymbolizerElement.appendChild( vo );
}
}
if ( repeatDistance > 0 )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "repeat" ), qgsDoubleToString( repeatDistance, 2 ) );
textSymbolizerElement.appendChild( vo );
}
// miscellaneous options
if ( settings.displayAll )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "conflictResolution" ), QStringLiteral( "false" ) );
textSymbolizerElement.appendChild( vo );
}
if ( settings.upsidedownLabels == QgsPalLayerSettings::ShowAll )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "forceLeftToRight" ), QStringLiteral( "false" ) );
textSymbolizerElement.appendChild( vo );
}
if ( settings.mergeLines )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "group" ), QStringLiteral( "yes" ) );
textSymbolizerElement.appendChild( vo );
if ( settings.labelPerPart )
{
QDomElement vo = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "labelAllGroup" ), QStringLiteral( "true" ) );
textSymbolizerElement.appendChild( vo );
}
}
// background symbol resize handling
if ( background.enabled() )
{
// enable resizing if needed
switch ( background.sizeType() )
{
case QgsTextBackgroundSettings::SizeBuffer:
{
QString resizeType;
if ( background.type() == QgsTextBackgroundSettings::ShapeRectangle || background.type() == QgsTextBackgroundSettings::ShapeEllipse )
{
resizeType = QStringLiteral( "stretch" );
}
else
{
resizeType = QStringLiteral( "proportional" );
}
QDomElement voResize = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "graphic-resize" ), resizeType );
textSymbolizerElement.appendChild( voResize );
// now hadle margin
QSizeF size = background.size();
if ( size.width() > 0 || size.height() > 0 )
{
double x = QgsSymbolLayerUtils::rescaleUom( size.width(), background.sizeUnit(), props );
double y = QgsSymbolLayerUtils::rescaleUom( size.height(), background.sizeUnit(), props );
// in case of ellipse qgis pads the size generously to make sure the text is inside the ellipse
// the following seems to do the trick and keep visual output similar
if ( background.type() == QgsTextBackgroundSettings::ShapeEllipse )
{
x += fontSize / 2;
y += fontSize;
}
QString resizeSpec = QString( "%1 %2" ).arg( qgsDoubleToString( x, 2 ), qgsDoubleToString( y, 2 ) );
QDomElement voMargin = QgsSymbolLayerUtils::createVendorOptionElement( doc, QStringLiteral( "graphic-margin" ), resizeSpec );
textSymbolizerElement.appendChild( voMargin );
}
break;
}
case QgsTextBackgroundSettings::SizeFixed:
case QgsTextBackgroundSettings::SizePercent:
// nothing to do here
break;
}
}
}
QString QgsGrassRegion::formatResolution( double v )
{
return qgsDoubleToString( v, mCrs.mapUnits() == QgsUnitTypes::DistanceDegrees ? 10 : 4 );
}
QString QgsGrassRegion::formatExtent( double v )
{
// format with precision approximately to meters
// max length of degree of latitude on pole is 111694 m
return qgsDoubleToString( v, mCrs.mapUnits() == QgsUnitTypes::DistanceDegrees ? 6 : 1 );
}
bool QgsRenderChecker::runTest( QString theTestName,
unsigned int theMismatchCount )
{
if ( mExpectedImageFile.isEmpty() )
{
qDebug( "QgsRenderChecker::runTest failed - Expected Image File not set." );
mReport = "<table>"
"<tr><td>Test Result:</td><td>Expected Result:</td></tr>\n"
"<tr><td>Nothing rendered</td>\n<td>Failed because Expected "
"Image File not set.</td></tr></table>\n";
return false;
}
//
// Load the expected result pixmap
//
QImage myExpectedImage( mExpectedImageFile );
mMatchTarget = myExpectedImage.width() * myExpectedImage.height();
//
// Now render our layers onto a pixmap
//
mMapSettings.setBackgroundColor( qRgb( 152, 219, 249 ) );
mMapSettings.setFlag( QgsMapSettings::Antialiasing );
mMapSettings.setOutputSize( QSize( myExpectedImage.width(), myExpectedImage.height() ) );
QTime myTime;
myTime.start();
QgsMapRendererSequentialJob job( mMapSettings );
job.start();
job.waitForFinished();
mElapsedTime = myTime.elapsed();
QImage myImage = job.renderedImage();
//
// Save the pixmap to disk so the user can make a
// visual assessment if needed
//
mRenderedImageFile = QDir::tempPath() + QDir::separator() +
theTestName + "_result.png";
myImage.setDotsPerMeterX( myExpectedImage.dotsPerMeterX() );
myImage.setDotsPerMeterY( myExpectedImage.dotsPerMeterY() );
myImage.save( mRenderedImageFile, "PNG", 100 );
//create a world file to go with the image...
QFile wldFile( QDir::tempPath() + QDir::separator() + theTestName + "_result.wld" );
if ( wldFile.open( QIODevice::WriteOnly ) )
{
QgsRectangle r = mMapSettings.extent();
QTextStream stream( &wldFile );
stream << QString( "%1\r\n0 \r\n0 \r\n%2\r\n%3\r\n%4\r\n" )
.arg( qgsDoubleToString( mMapSettings.mapUnitsPerPixel() ) )
.arg( qgsDoubleToString( -mMapSettings.mapUnitsPerPixel() ) )
.arg( qgsDoubleToString( r.xMinimum() + mMapSettings.mapUnitsPerPixel() / 2.0 ) )
.arg( qgsDoubleToString( r.yMaximum() - mMapSettings.mapUnitsPerPixel() / 2.0 ) );
}
return compareImages( theTestName, theMismatchCount );
}
/**************************** REGION ********************************/
void QgsGrassNewMapset::setRegionPage()
{
QgsDebugMsg( "entered" );
// Set defaults
if ( !mRegionModified )
{
setGrassRegionDefaults();
}
// Create new projection
QgsCoordinateReferenceSystem newCrs;
if ( mProjRadioButton->isChecked() )
{
QgsDebugMsg( QString( "selectedCrsId() = %1" ).arg( mProjectionSelector->selectedCrsId() ) );
if ( mProjectionSelector->selectedCrsId() > 0 )
{
newCrs.createFromSrsId( mProjectionSelector->selectedCrsId() );
if ( ! newCrs.isValid() )
{
QgsGrass::warning( tr( "Cannot create projection." ) );
}
}
}
// Reproject previous region if it was modified
// and if previous and current projection is valid
if ( mRegionModified && newCrs.isValid() && mCrs.isValid()
&& newCrs.srsid() != mCrs.srsid() )
{
QgsCoordinateTransform trans( mCrs, newCrs );
double n = mNorthLineEdit->text().toDouble();
double s = mSouthLineEdit->text().toDouble();
double e = mEastLineEdit->text().toDouble();
double w = mWestLineEdit->text().toDouble();
std::vector<QgsPoint> points;
// TODO: this is not perfect
points.push_back( QgsPoint( w, s ) );
points.push_back( QgsPoint( e, n ) );
bool ok = true;
for ( int i = 0; i < 2; i++ )
{
try
{
points[i] = trans.transform( points[i] );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsDebugMsg( "Cannot transform point" );
ok = false;
break;
}
}
if ( ok )
{
int precision = newCrs.mapUnits() == QGis::Degrees ? 6 : 1;
mNorthLineEdit->setText( qgsDoubleToString( points[1].y(), precision ) );
mSouthLineEdit->setText( qgsDoubleToString( points[0].y(), precision ) );
mEastLineEdit->setText( qgsDoubleToString( points[1].x(), precision ) );
mWestLineEdit->setText( qgsDoubleToString( points[0].x(), precision ) );
}
else
{
QgsGrass::warning( tr( "Cannot reproject previously set region, default region set." ) );
setGrassRegionDefaults();
}
}
// Set current region projection
mCrs = newCrs;
// Enable / disable region selection widgets
if ( mNoProjRadioButton->isChecked() )
{
mRegionMap->hide();
mCurrentRegionButton->hide();
mRegionsComboBox->hide();
mRegionButton->hide();
mSetRegionFrame->hide();
}
else
{
mRegionMap->show();
mCurrentRegionButton->show();
mRegionsComboBox->show();
mRegionButton->show();
mSetRegionFrame->show();
QgsRectangle ext = mIface->mapCanvas()->extent();
if ( ext.xMinimum() >= ext.xMaximum() || ext.yMinimum() >= ext.yMaximum() )
{
mCurrentRegionButton->setEnabled( false );
}
}
checkRegion();
if ( !mNoProjRadioButton->isChecked() )
{
drawRegion();
}
}
QString QgsPoint::wellKnownText() const
{
return QStringLiteral( "POINT(%1 %2)" ).arg( qgsDoubleToString( m_x ), qgsDoubleToString( m_y ) );
}
void QgsMssqlFeatureIterator::BuildStatement( const QgsFeatureRequest& request )
{
// build sql statement
mStatement = QString( "SELECT " );
mStatement += QString( "[%1]" ).arg( mSource->mFidColName );
mFidCol = mSource->mFields.indexFromName( mSource->mFidColName );
mAttributesToFetch.append( mFidCol );
bool subsetOfAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes;
foreach ( int i, subsetOfAttributes ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList() )
{
QString fieldname = mSource->mFields[i].name();
if ( mSource->mFidColName == fieldname )
continue;
mStatement += QString( ",[%1]" ).arg( fieldname );
mAttributesToFetch.append( i );
}
// get geometry col
if ( !( request.flags() & QgsFeatureRequest::NoGeometry ) && mSource->isSpatial() )
{
mStatement += QString( ",[%1]" ).arg( mSource->mGeometryColName );
}
mStatement += QString( "FROM [%1].[%2]" ).arg( mSource->mSchemaName, mSource->mTableName );
bool filterAdded = false;
// set spatial filter
if ( request.filterType() == QgsFeatureRequest::FilterRect && mSource->isSpatial() && !request.filterRect().isEmpty() )
{
// polygons should be CCW for SqlGeography
QString r;
QTextStream foo( &r );
foo.setRealNumberPrecision( 8 );
foo.setRealNumberNotation( QTextStream::FixedNotation );
foo << qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() ) << ", "
<< qgsDoubleToString( request.filterRect().xMaximum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() ) << ", "
<< qgsDoubleToString( request.filterRect().xMaximum() ) << " " << qgsDoubleToString( request.filterRect().yMaximum() ) << ", "
<< qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMaximum() ) << ", "
<< qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() );
mStatement += QString( " where [%1].STIntersects([%2]::STGeomFromText('POLYGON((%3))',%4)) = 1" ).arg(
mSource->mGeometryColName, mSource->mGeometryColType, r, QString::number( mSource->mSRId ) );
filterAdded = true;
}
// set fid filter
if ( request.filterType() == QgsFeatureRequest::FilterFid && !mSource->mFidColName.isEmpty() )
{
QString fidfilter = QString( " [%1] = %2" ).arg( mSource->mFidColName, QString::number( request.filterFid() ) );
// set attribute filter
if ( !filterAdded )
mStatement += " WHERE ";
else
mStatement += " AND ";
mStatement += fidfilter;
filterAdded = true;
}
if ( !mSource->mSqlWhereClause.isEmpty() )
{
if ( !filterAdded )
mStatement += " WHERE (" + mSource->mSqlWhereClause + ")";
else
mStatement += " AND (" + mSource->mSqlWhereClause + ")";
}
QgsDebugMsg( mStatement );
#if 0
if ( fieldCount == 0 )
{
QgsDebugMsg( "QgsMssqlProvider::select no fields have been requested" );
mStatement.clear();
}
#endif
}
