bool QgsCoordinateTransform::setFromCache( const QgsCoordinateReferenceSystem &src, const QgsCoordinateReferenceSystem &dest, int srcDatumTransform, int destDatumTransform )
{
if ( !src.isValid() || !dest.isValid() )
return false;
sCacheLock.lockForRead();
const QList< QgsCoordinateTransform > values = sTransforms.values( qMakePair( src.authid(), dest.authid() ) );
for ( auto valIt = values.constBegin(); valIt != values.constEnd(); ++valIt )
{
if ( ( *valIt ).sourceDatumTransformId() == srcDatumTransform &&
( *valIt ).destinationDatumTransformId() == destDatumTransform )
{
// need to save, and then restore the context... we don't want this to be cached or to use the values from the cache
QgsCoordinateTransformContext context = mContext;
#ifdef QGISDEBUG
bool hasContext = mHasContext;
#endif
*this = *valIt;
sCacheLock.unlock();
mContext = context;
#ifdef QGISDEBUG
mHasContext = hasContext;
#endif
return true;
}
}
sCacheLock.unlock();
return false;
}
void QgsDatumTransformDialog::updateTitle()
{
mLabelLayer->setText( mLayerName );
QgsCoordinateReferenceSystem crs;
crs.createFromString( mSrcCRSauthId );
mLabelSrcCrs->setText( QString( "%1 - %2" ).arg( mSrcCRSauthId ).arg( crs.isValid() ? crs.description() : tr( "unknown" ) ) );
crs.createFromString( mDestCRSauthId );
mLabelDstCrs->setText( QString( "%1 - %2" ).arg( mDestCRSauthId ).arg( crs.isValid() ? crs.description() : tr( "unknown" ) ) );
}
bool QgsCoordinateTransformContext::addSourceDestinationDatumTransform( const QgsCoordinateReferenceSystem &sourceCrs, const QgsCoordinateReferenceSystem &destinationCrs, int sourceTransform, int destinationTransform )
{
if ( !sourceCrs.isValid() || !destinationCrs.isValid() )
return false;
d.detach();
d->mLock.lockForWrite();
d->mSourceDestDatumTransforms.insert( qMakePair( sourceCrs.authid(), destinationCrs.authid() ), QgsDatumTransform::TransformPair( sourceTransform, destinationTransform ) );
d->mLock.unlock();
return true;
}
QString QgsProjectionSelectionWidget::crsOptionText( const QgsCoordinateReferenceSystem &crs )
{
if ( crs.isValid() )
return tr( "%1 - %2" ).arg( crs.authid(), crs.description() );
else
return tr( "invalid projection" );
}
void QgsProjectionSelectionWidget::setCrs( const QgsCoordinateReferenceSystem &crs )
{
if ( crs.isValid() )
{
if ( !optionVisible( QgsProjectionSelectionWidget::CurrentCrs ) )
setOptionVisible( QgsProjectionSelectionWidget::CurrentCrs, true );
mCrsComboBox->setItemText( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ),
crsOptionText( crs ) );
mCrsComboBox->blockSignals( true );
mCrsComboBox->setCurrentIndex( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ) );
mCrsComboBox->blockSignals( false );
}
else
{
int crsNotSetIndex = mCrsComboBox->findData( QgsProjectionSelectionWidget::CrsNotSet );
if ( crsNotSetIndex >= 0 )
{
mCrsComboBox->blockSignals( true );
mCrsComboBox->setCurrentIndex( crsNotSetIndex );
mCrsComboBox->blockSignals( false );
}
else
{
mCrsComboBox->setItemText( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ),
crsOptionText( crs ) );
}
}
if ( mCrs != crs )
{
mCrs = crs;
emit crsChanged( crs );
}
}
QString QgsArcGisServiceSourceSelect::getPreferredCrs( const QSet<QString> &crsSet ) const
{
if ( crsSet.size() < 1 )
{
return QString();
}
//first: project CRS
QgsCoordinateReferenceSystem projectRefSys = QgsProject::instance()->crs();
//convert to EPSG
QString ProjectCRS;
if ( projectRefSys.isValid() )
{
ProjectCRS = projectRefSys.authid();
}
if ( !ProjectCRS.isEmpty() && crsSet.contains( ProjectCRS ) )
{
return ProjectCRS;
}
//second: WGS84
if ( crsSet.contains( GEO_EPSG_CRS_AUTHID ) )
{
return GEO_EPSG_CRS_AUTHID;
}
//third: first entry in set
return *( crsSet.constBegin() );
}
void QgsExpression::initGeomCalculator( const QgsExpressionContext *context )
{
// Set the geometry calculator from the context if it has not been set by setGeomCalculator()
if ( context && ! d->mCalc )
{
QString ellipsoid = context->variable( QStringLiteral( "project_ellipsoid" ) ).toString();
QgsCoordinateReferenceSystem crs = context->variable( QStringLiteral( "_layer_crs" ) ).value<QgsCoordinateReferenceSystem>();
QgsCoordinateTransformContext tContext = context->variable( QStringLiteral( "_project_transform_context" ) ).value<QgsCoordinateTransformContext>();
if ( crs.isValid() )
{
d->mCalc = std::shared_ptr<QgsDistanceArea>( new QgsDistanceArea() );
d->mCalc->setEllipsoid( ellipsoid.isEmpty() ? GEO_NONE : ellipsoid );
d->mCalc->setSourceCrs( crs, tContext );
}
}
// Set the distance units from the context if it has not been set by setDistanceUnits()
if ( context && distanceUnits() == QgsUnitTypes::DistanceUnknownUnit )
{
QString distanceUnitsStr = context->variable( QStringLiteral( "project_distance_units" ) ).toString();
if ( ! distanceUnitsStr.isEmpty() )
setDistanceUnits( QgsUnitTypes::stringToDistanceUnit( distanceUnitsStr ) );
}
// Set the area units from the context if it has not been set by setAreaUnits()
if ( context && areaUnits() == QgsUnitTypes::AreaUnknownUnit )
{
QString areaUnitsStr = context->variable( QStringLiteral( "project_area_units" ) ).toString();
if ( ! areaUnitsStr.isEmpty() )
setAreaUnits( QgsUnitTypes::stringToAreaUnit( areaUnitsStr ) );
}
}
QgsRectangle QgsProcessingUtils::combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs )
{
QgsRectangle extent;
for ( const QgsMapLayer *layer : layers )
{
if ( !layer )
continue;
if ( crs.isValid() )
{
//transform layer extent to target CRS
Q_NOWARN_DEPRECATED_PUSH
QgsCoordinateTransform ct( layer->crs(), crs );
Q_NOWARN_DEPRECATED_POP
try
{
QgsRectangle reprojExtent = ct.transformBoundingBox( layer->extent() );
extent.combineExtentWith( reprojExtent );
}
catch ( QgsCsException & )
{
// can't reproject... what to do here? hmmm?
// let's ignore this layer for now, but maybe we should just use the original extent?
}
}
else
{
void QgsCustomProjectionDialog::buttonBox_accepted()
{
//Update the current CRS:
int i = leNameList->currentIndex().row();
if ( i != -1 )
{
mCustomCRSnames[i] = leName->text();
mCustomCRSparameters[i] = teParameters->toPlainText();
}
QgsDebugMsg( "We save the modified CRS." );
//Check if all CRS are valid:
QgsCoordinateReferenceSystem CRS;
for ( int i = 0; i < mCustomCRSids.size(); ++i )
{
CRS.createFromProj4( mCustomCRSparameters[i] );
if ( !CRS.isValid() )
{
QMessageBox::information( this, tr( "QGIS Custom Projection" ),
tr( "The proj4 definition of '%1' is not valid." ).arg( mCustomCRSnames[i] ) );
return;
}
}
//Modify the CRS changed:
bool saveSuccess = true;
for ( int i = 0; i < mCustomCRSids.size(); ++i )
{
CRS.createFromProj4( mCustomCRSparameters[i] );
//Test if we just added this CRS (if it has no existing ID)
if ( mCustomCRSids[i].isEmpty() )
{
saveSuccess &= saveCrs( CRS, mCustomCRSnames[i], QString(), true );
}
else
{
if ( mExistingCRSnames[mCustomCRSids[i]] != mCustomCRSnames[i] || mExistingCRSparameters[mCustomCRSids[i]] != mCustomCRSparameters[i] )
{
saveSuccess &= saveCrs( CRS, mCustomCRSnames[i], mCustomCRSids[i], false );
}
}
if ( ! saveSuccess )
{
QgsDebugMsg( QString( "Error when saving CRS '%1'" ).arg( mCustomCRSnames[i] ) );
}
}
QgsDebugMsg( "We remove the deleted CRS." );
for ( int i = 0; i < mDeletedCRSs.size(); ++i )
{
saveSuccess &= deleteCrs( mDeletedCRSs[i] );
if ( ! saveSuccess )
{
QgsDebugMsg( QString( "Problem for layer '%1'" ).arg( mCustomCRSparameters[i] ) );
}
}
if ( saveSuccess )
{
accept();
}
}
QString QgsCoordinateUtils::formatCoordinateForProject( const QgsPoint& point, const QgsCoordinateReferenceSystem& destCrs, int precision )
{
QString format = QgsProject::instance()->readEntry( "PositionPrecision", "/DegreeFormat", "MU" );
QgsPoint geo = point;
if ( format == "DM" || format == "DMS" || format == "D" )
{
// degrees
if ( destCrs.isValid() && !destCrs.geographicFlag() )
{
// need to transform to geographic coordinates
QgsCoordinateTransform ct( destCrs, QgsCoordinateReferenceSystem( GEOSRID ) );
try
{
geo = ct.transform( point );
}
catch ( QgsCsException& )
{
return QString();
}
}
if ( format == "DM" )
return geo.toDegreesMinutes( precision, true, true );
else if ( format == "DMS" )
return geo.toDegreesMinutesSeconds( precision, true, true );
else
return geo.toString( precision );
}
else
{
// coordinates in map units
return point.toString( precision );
}
}
QString QgsWFSSourceSelect::getPreferredCrs( const QSet<QString>& crsSet ) const
{
if ( crsSet.size() < 1 )
{
return "";
}
//first: project CRS
long ProjectCRSID = QgsProject::instance()->readNumEntry( "SpatialRefSys", "/ProjectCRSID", -1 );
//convert to EPSG
QgsCoordinateReferenceSystem projectRefSys = QgsCRSCache::instance()->crsBySrsId( ProjectCRSID );
QString ProjectCRS;
if ( projectRefSys.isValid() )
{
ProjectCRS = projectRefSys.authid();
}
if ( !ProjectCRS.isEmpty() && crsSet.contains( ProjectCRS ) )
{
return ProjectCRS;
}
//second: WGS84
if ( crsSet.contains( GEO_EPSG_CRS_AUTHID ) )
{
return GEO_EPSG_CRS_AUTHID;
}
//third: first entry in set
return *( crsSet.constBegin() );
}
void QgsProjectionSelectionWidget::addRecentCrs()
{
QStringList recentProjections = QgsCoordinateReferenceSystem::recentProjections();
int i = 0;
Q_FOREACH ( const QString& projection, recentProjections )
{
long srsid = projection.toLong();
//check if already shown
if ( crsIsShown( srsid ) )
{
continue;
}
i++;
QgsCoordinateReferenceSystem crs;
crs.createFromSrsId( srsid );
if ( crs.isValid() )
{
mCrsComboBox->addItem( tr( "%1 - %2" ).arg( crs.authid(), crs.description() ), QgsProjectionSelectionWidget::RecentCrs );
mCrsComboBox->setItemData( mCrsComboBox->count() - 1, QVariant(( long long )srsid ), Qt::UserRole + 1 );
}
if ( i >= 4 )
{
//limit to 4 recent projections to avoid clutter
break;
}
}
QgsGeometry QgsAtlasComposition::currentGeometry( const QgsCoordinateReferenceSystem& crs ) const
{
if ( !mCoverageLayer || !mCurrentFeature.isValid() || !mCurrentFeature.hasGeometry() )
{
return QgsGeometry();
}
if ( !crs.isValid() )
{
// no projection, return the native geometry
return mCurrentFeature.geometry();
}
QMap<long, QgsGeometry>::const_iterator it = mGeometryCache.constFind( crs.srsid() );
if ( it != mGeometryCache.constEnd() )
{
// we have it in cache, return it
return it.value();
}
if ( mCoverageLayer->crs() == crs )
{
return mCurrentFeature.geometry();
}
QgsGeometry transformed = mCurrentFeature.geometry();
transformed.transform( QgsCoordinateTransformCache::instance()->transform( mCoverageLayer->crs().authid(), crs.authid() ) );
mGeometryCache[crs.srsid()] = transformed;
return transformed;
}
void QgsConfigParser::appendExGeographicBoundingBox( QDomElement& layerElem,
QDomDocument& doc,
const QgsRectangle& layerExtent,
const QgsCoordinateReferenceSystem& layerCRS ) const
{
if ( layerElem.isNull() )
{
return;
}
QgsCoordinateReferenceSystem wgs84;
wgs84.createFromOgcWmsCrs( GEO_EPSG_CRS_AUTHID );
//Ex_GeographicBoundingBox
//transform the layers native CRS into WGS84
QgsCoordinateTransform exGeoTransform( layerCRS, wgs84 );
QgsRectangle wgs84BoundingRect = exGeoTransform.transformBoundingBox( layerExtent );
QDomElement ExGeoBBoxElement = doc.createElement( "EX_GeographicBoundingBox" );
QDomElement wBoundLongitudeElement = doc.createElement( "westBoundLongitude" );
QDomText wBoundLongitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.xMinimum() ) );
wBoundLongitudeElement.appendChild( wBoundLongitudeText );
ExGeoBBoxElement.appendChild( wBoundLongitudeElement );
QDomElement eBoundLongitudeElement = doc.createElement( "eastBoundLongitude" );
QDomText eBoundLongitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.xMaximum() ) );
eBoundLongitudeElement.appendChild( eBoundLongitudeText );
ExGeoBBoxElement.appendChild( eBoundLongitudeElement );
QDomElement sBoundLatitudeElement = doc.createElement( "southBoundLatitude" );
QDomText sBoundLatitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.yMinimum() ) );
sBoundLatitudeElement.appendChild( sBoundLatitudeText );
ExGeoBBoxElement.appendChild( sBoundLatitudeElement );
QDomElement nBoundLatitudeElement = doc.createElement( "northBoundLatitude" );
QDomText nBoundLatitudeText = doc.createTextNode( QString::number( wgs84BoundingRect.yMaximum() ) );
nBoundLatitudeElement.appendChild( nBoundLatitudeText );
ExGeoBBoxElement.appendChild( nBoundLatitudeElement );
//BoundingBox element
QDomElement bBoxElement = doc.createElement( "BoundingBox" );
if ( layerCRS.isValid() )
{
bBoxElement.setAttribute( "CRS", layerCRS.authid() );
}
bBoxElement.setAttribute( "minx", QString::number( layerExtent.xMinimum() ) );
bBoxElement.setAttribute( "miny", QString::number( layerExtent.yMinimum() ) );
bBoxElement.setAttribute( "maxx", QString::number( layerExtent.xMaximum() ) );
bBoxElement.setAttribute( "maxy", QString::number( layerExtent.yMaximum() ) );
QDomElement lastCRSElem = layerElem.lastChildElement( "CRS" );
if ( !lastCRSElem.isNull() )
{
layerElem.insertAfter( ExGeoBBoxElement, lastCRSElem );
layerElem.insertAfter( bBoxElement, ExGeoBBoxElement );
}
else
{
layerElem.appendChild( ExGeoBBoxElement );
layerElem.appendChild( bBoxElement );
}
}
QDomElement QgsWFSServer::createFeatureElem( QgsFeature* feat, QDomDocument& doc, QgsCoordinateReferenceSystem& crs, QMap< int, QgsField > fields, QSet<QString> hiddenAttributes ) /*const*/
{
//gml:FeatureMember
QDomElement featureElement = doc.createElement( "gml:featureMember"/*wfs:FeatureMember*/ );
//qgs:%TYPENAME%
QDomElement typeNameElement = doc.createElement( "qgs:" + mTypeName.replace( QString( " " ), QString( "_" ) )/*qgs:%TYPENAME%*/ );
typeNameElement.setAttribute( "fid", QString::number( feat->id() ) );
featureElement.appendChild( typeNameElement );
if ( mWithGeom )
{
//add geometry column (as gml)
QgsGeometry* geom = feat->geometry();
QDomElement geomElem = doc.createElement( "qgs:geometry" );
QDomElement gmlElem = createGeometryElem( geom, doc );
if ( !gmlElem.isNull() )
{
QgsRectangle box = geom->boundingBox();
QDomElement bbElem = doc.createElement( "gml:boundedBy" );
QDomElement boxElem = createBoxElem( &box, doc );
if ( crs.isValid() )
{
boxElem.setAttribute( "srsName", crs.authid() );
gmlElem.setAttribute( "srsName", crs.authid() );
}
bbElem.appendChild( boxElem );
typeNameElement.appendChild( bbElem );
geomElem.appendChild( gmlElem );
typeNameElement.appendChild( geomElem );
}
}
//read all attribute values from the feature
QgsAttributeMap featureAttributes = feat->attributeMap();
for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )
{
QString attributeName = fields[it.key()].name();
//skip attribute if it has edit type 'hidden'
if ( hiddenAttributes.contains( attributeName ) )
{
continue;
}
QDomElement fieldElem = doc.createElement( "qgs:" + attributeName.replace( QString( " " ), QString( "_" ) ) );
QDomText fieldText = doc.createTextNode( it->toString() );
fieldElem.appendChild( fieldText );
typeNameElement.appendChild( fieldElem );
}
return featureElement;
}
void QgsDatumTransformTableWidget::editDatumTransform()
{
QModelIndexList selectedIndexes = mTableView->selectionModel()->selectedIndexes();
if ( selectedIndexes.count() > 0 )
{
QgsCoordinateReferenceSystem sourceCrs;
QgsCoordinateReferenceSystem destinationCrs;
int sourceTransform = -1;
int destinationTransform = -1;
for ( QModelIndexList::const_iterator it = selectedIndexes.constBegin(); it != selectedIndexes.constEnd(); it ++ )
{
switch ( it->column() )
{
case QgsDatumTransformTableModel::SourceCrsColumn:
sourceCrs = QgsCoordinateReferenceSystem( mModel->data( *it, Qt::DisplayRole ).toString() );
break;
case QgsDatumTransformTableModel::DestinationCrsColumn:
destinationCrs = QgsCoordinateReferenceSystem( mModel->data( *it, Qt::DisplayRole ).toString() );
break;
case QgsDatumTransformTableModel::SourceTransformColumn:
sourceTransform = mModel->data( *it, Qt::UserRole ).toInt();
break;
case QgsDatumTransformTableModel::DestinationTransformColumn:
destinationTransform = mModel->data( *it, Qt::UserRole ).toInt();
break;
default:
break;
}
}
if ( sourceCrs.isValid() && destinationCrs.isValid() &&
( sourceTransform != -1 || destinationTransform != -1 ) )
{
QgsDatumTransformDialog dlg( sourceCrs, destinationCrs, qMakePair( sourceTransform, destinationTransform ) );
if ( dlg.exec() )
{
QPair< QPair<QgsCoordinateReferenceSystem, int>, QPair<QgsCoordinateReferenceSystem, int > > dt = dlg.selectedDatumTransforms();
QgsCoordinateTransformContext context = mModel->transformContext();
// QMap::insert takes care of replacing existing value
context.addSourceDestinationDatumTransform( sourceCrs, destinationCrs, dt.first.second, dt.second.second );
mModel->setTransformContext( context );
}
}
}
}
void QgsSpatialQueryDialog::zoomFeature( QgsVectorLayer* lyr, QgsFeatureId fid )
{
static QgsVectorLayer* lyrCheck = NULL;
static bool hasMsg = false;
if ( ! lyrCheck || lyrCheck != lyr )
{
lyrCheck = lyr;
hasMsg = true;
}
else
{
hasMsg = false;
}
QgsFeature feat;
if ( !lyr->getFeatures( QgsFeatureRequest().setFilterFid( fid ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( feat ) )
{
return;
}
if ( !feat.geometry() )
{
return;
}
// Set system reference
QgsCoordinateReferenceSystem srsSource = lyr->dataProvider()->crs();
QgsCoordinateReferenceSystem srcMapcanvas = mIface->mapCanvas()->mapSettings().destinationCrs();
if ( ! srsSource.isValid() )
{
if ( hasMsg )
{
QString crsMapcanvas = srcMapcanvas.authid();
bool isFly = mIface->mapCanvas()->mapSettings().hasCrsTransformEnabled();
QString msgFly = tr( "Map \"%1\" \"on the fly\" transformation." ).arg( isFly ? tr( "enable" ) : tr( "disable" ) );
QString msg = tr( "Coordinate reference system(CRS) of\n\"%1\" is invalid(see CRS of provider)." ).arg( lyr->name() );
msg.append( tr( "\n\nCRS of map is %1.\n%2." ).arg( crsMapcanvas ).arg( msgFly ) );
msg.append( "\n\nUsing CRS of map for all features!" );
QMessageBox::warning( this, tr( "Zoom to feature" ), msg, QMessageBox::Ok );
}
mIface->mapCanvas()->setExtent( feat.geometry()->boundingBox() );
}
else if ( srsSource == srcMapcanvas )
{
mIface->mapCanvas()->setExtent( feat.geometry()->boundingBox() );
}
else
{
QgsCoordinateTransform * coordTransform = new QgsCoordinateTransform( srsSource, srcMapcanvas );
QgsRectangle rectExtent = coordTransform->transform( feat.geometry()->boundingBox() );
delete coordTransform;
mIface->mapCanvas()->setExtent( rectExtent );
}
mIface->mapCanvas()->refresh();
} // void QgsSpatialQueryDialog::zoomFeatureTarget(QgsVectorLayer* lyr, int fid)
bool QgsCoordinateTransformContext::addSourceDatumTransform( const QgsCoordinateReferenceSystem &crs, int transform )
{
if ( !crs.isValid() )
return false;
d.detach();
d->mLock.lockForWrite();
d->mSourceDatumTransforms.insert( crs.authid(), transform );
d->mLock.unlock();
return true;
}
void QgsProjectionSelectionTreeWidget::setCrs( const QgsCoordinateReferenceSystem &crs )
{
if ( !crs.isValid() )
{
mCheckBoxNoProjection->setChecked( true );
}
else
{
mCheckBoxNoProjection->setChecked( false );
applySelection( AuthidColumn, crs.authid() );
}
}
void QgsGrassNewMapset::setCurrentRegion()
{
QgsDebugMsg( "entered" );
QgsRectangle ext = mIface->mapCanvas()->extent();
QgsCoordinateReferenceSystem srs = mIface->mapCanvas()->mapSettings().destinationCrs();
QgsDebugMsg( "srs = " + srs.toWkt() );
std::vector<QgsPoint> points;
// TODO: this is not perfect
points.push_back( QgsPoint( ext.xMinimum(), ext.yMinimum() ) );
points.push_back( QgsPoint( ext.xMaximum(), ext.yMaximum() ) );
// TODO add a method, this code is copy-paste from setSelectedRegion
if ( srs.isValid() && mCrs.isValid()
&& srs.srsid() != mCrs.srsid() )
{
QgsCoordinateTransform trans( srs, mCrs );
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 )
{
QgsGrass::warning( tr( "Cannot reproject region" ) );
return;
}
}
mNorthLineEdit->setText( QString::number( points[1].y() ) );
mSouthLineEdit->setText( QString::number( points[0].y() ) );
mEastLineEdit->setText( QString::number( points[1].x() ) );
mWestLineEdit->setText( QString::number( points[0].x() ) );
mRegionModified = true;
checkRegion();
drawRegion();
QgsDebugMsg( "setCurrentRegion - End" );
}
bool QgsAfsSourceSelect::connectToService( const QgsOwsConnection &connection )
{
QString errorTitle, errorMessage;
QVariantMap serviceInfoMap = QgsArcGisRestUtils::getServiceInfo( connection.uri().param( "url" ), errorTitle, errorMessage );
if ( serviceInfoMap.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to retrieve service capabilities:\n%1: %2" ).arg( errorTitle ).arg( errorMessage ) );
return false;
}
QStringList layerErrors;
foreach ( const QVariant& layerInfo, serviceInfoMap["layers"].toList() )
{
QVariantMap layerInfoMap = layerInfo.toMap();
if ( !layerInfoMap["id"].isValid() )
{
continue;
}
// Get layer info
QVariantMap layerData = QgsArcGisRestUtils::getLayerInfo( connection.uri().param( "url" ) + "/" + layerInfoMap["id"].toString(), errorTitle, errorMessage );
if ( layerData.isEmpty() )
{
layerErrors.append( tr( "Layer %1: %2 - %3" ).arg( layerInfoMap["id"].toString() ).arg( errorTitle ).arg( errorMessage ) );
continue;
}
// insert the typenames, titles and abstracts into the tree view
QStandardItem* idItem = new QStandardItem( layerData["id"].toString() );
QStandardItem* nameItem = new QStandardItem( layerData["name"].toString() );
QStandardItem* abstractItem = new QStandardItem( layerData["description"].toString() );
abstractItem->setToolTip( layerData["description"].toString() );
QStandardItem* cachedItem = new QStandardItem();
QStandardItem* filterItem = new QStandardItem();
cachedItem->setCheckable( true );
cachedItem->setCheckState( Qt::Checked );
QgsCoordinateReferenceSystem crs = QgsArcGisRestUtils::parseSpatialReference( serviceInfoMap["spatialReference"].toMap() );
if ( !crs.isValid() )
{
// If not spatial reference, just use WGS84
crs.createFromString( "EPSG:4326" );
}
mAvailableCRS[layerData["name"].toString()] = QList<QString>() << crs.authid();
mModel->appendRow( QList<QStandardItem*>() << idItem << nameItem << abstractItem << cachedItem << filterItem );
}
if ( !layerErrors.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to query some layers:\n%1" ).arg( layerErrors.join( "\n" ) ) );
}
return true;
}
void QgsDatumTransformTableModel::removeTransform( const QModelIndexList &indexes )
{
QgsCoordinateReferenceSystem sourceCrs;
QgsCoordinateReferenceSystem destinationCrs;
for ( QModelIndexList::const_iterator it = indexes.constBegin(); it != indexes.constEnd(); it ++ )
{
if ( it->column() == SourceCrsColumn )
{
sourceCrs = QgsCoordinateReferenceSystem( data( *it, Qt::DisplayRole ).toString() );
}
if ( it->column() == DestinationCrsColumn )
{
destinationCrs = QgsCoordinateReferenceSystem( data( *it, Qt::DisplayRole ).toString() );
}
if ( sourceCrs.isValid() && destinationCrs.isValid() )
{
mTransformContext.removeSourceDestinationDatumTransform( sourceCrs, destinationCrs );
reset();
break;
}
}
}
void QgsProjectionSelectionTreeWidget::updateBoundsPreview()
{
QTreeWidgetItem *lvi = lstCoordinateSystems->currentItem();
if ( !lvi || lvi->text( QgisCrsIdColumn ).isEmpty() )
return;
QgsCoordinateReferenceSystem currentCrs = crs();
if ( !currentCrs.isValid() )
return;
QgsRectangle rect = currentCrs.bounds();
if ( !qgsDoubleNear( rect.area(), 0.0 ) )
{
QgsGeometry geom;
if ( rect.xMinimum() > rect.xMaximum() )
{
QgsRectangle rect1 = QgsRectangle( -180, rect.yMinimum(), rect.xMaximum(), rect.yMaximum() );
QgsRectangle rect2 = QgsRectangle( rect.xMinimum(), rect.yMinimum(), 180, rect.yMaximum() );
geom = QgsGeometry::fromRect( rect1 );
geom.addPart( QgsGeometry::fromRect( rect2 ) );
}
else
{
geom = QgsGeometry::fromRect( rect );
}
mPreviewBand->setToGeometry( geom, nullptr );
mPreviewBand->setColor( QColor( 255, 0, 0, 65 ) );
QgsRectangle extent = geom.boundingBox();
extent.scale( 1.1 );
mAreaCanvas->setExtent( extent );
mAreaCanvas->refresh();
mPreviewBand->show();
QString extentString = tr( "Extent: %1, %2, %3, %4" )
.arg( rect.xMinimum(), 0, 'f', 2 )
.arg( rect.yMinimum(), 0, 'f', 2 )
.arg( rect.xMaximum(), 0, 'f', 2 )
.arg( rect.yMaximum(), 0, 'f', 2 );
QString proj4String = tr( "Proj4: %1" ).arg( selectedProj4String() );
teProjection->setText( extentString + "\n" + proj4String );
}
else
{
mPreviewBand->hide();
mAreaCanvas->zoomToFullExtent();
QString extentString = tr( "Extent: Extent not known" );
QString proj4String = tr( "Proj4: %1" ).arg( selectedProj4String() );
teProjection->setText( extentString + "\n" + proj4String );
}
}
void QgsProjectionSelectionWidget::setCrs( const QgsCoordinateReferenceSystem& crs )
{
if ( crs.isValid() )
{
mCrsComboBox->setItemText( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ),
tr( "Selected CRS (%1, %2)" ).arg( crs.authid(), crs.description() ) );
mCrsComboBox->blockSignals( true );
mCrsComboBox->setCurrentIndex( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ) );
mCrsComboBox->blockSignals( false );
}
else
{
mCrsComboBox->setItemText( mCrsComboBox->findData( QgsProjectionSelectionWidget::CurrentCrs ),
tr( "invalid projection" ) );
}
mCrs = crs;
}
QString QgsWMSLayerItem::createUri()
{
if ( mLayerProperty.name.isEmpty() )
return QString(); // layer collection
// Number of styles must match number of layers
mDataSourceUri.setParam( QStringLiteral( "layers" ), mLayerProperty.name );
QString style = !mLayerProperty.style.isEmpty() ? mLayerProperty.style.at( 0 ).name : QString();
mDataSourceUri.setParam( QStringLiteral( "styles" ), style );
QString format;
// get first supported by qt and server
QVector<QgsWmsSupportedFormat> formats( QgsWmsProvider::supportedFormats() );
const auto constFormats = formats;
for ( const QgsWmsSupportedFormat &f : constFormats )
{
if ( mCapabilitiesProperty.capability.request.getMap.format.indexOf( f.format ) >= 0 )
{
format = f.format;
break;
}
}
mDataSourceUri.setParam( QStringLiteral( "format" ), format );
QString crs;
// get first known if possible
QgsCoordinateReferenceSystem testCrs;
for ( const QString &c : qgis::as_const( mLayerProperty.crs ) )
{
testCrs = QgsCoordinateReferenceSystem::fromOgcWmsCrs( c );
if ( testCrs.isValid() )
{
crs = c;
break;
}
}
if ( crs.isEmpty() && !mLayerProperty.crs.isEmpty() )
{
crs = mLayerProperty.crs[0];
}
mDataSourceUri.setParam( QStringLiteral( "crs" ), crs );
//uri = rasterLayerPath + "|layers=" + layers.join( "," ) + "|styles=" + styles.join( "," ) + "|format=" + format + "|crs=" + crs;
return mDataSourceUri.encodedUri();
}
void QgsComposerMapGridWidget::on_mMapGridCRSButton_clicked()
{
if ( !mComposerMapGrid || !mComposerMap )
{
return;
}
QgsProjectionSelectionDialog crsDialog( this );
QgsCoordinateReferenceSystem crs = mComposerMapGrid->crs();
crsDialog.setCrs( crs.isValid() ? crs : mComposerMap->crs() );
if ( crsDialog.exec() == QDialog::Accepted )
{
mComposerMap->beginCommand( tr( "Grid CRS changed" ) );
mComposerMapGrid->setCrs( crsDialog.crs() );
mComposerMap->updateBoundingRect();
mMapGridCRSButton->setText( crsDialog.crs().authid() );
mComposerMap->endCommand();
}
}
void QgsComposerMapGridWidget::on_mMapGridCRSButton_clicked()
{
if ( !mComposerMapGrid || !mComposerMap )
{
return;
}
QgsGenericProjectionSelector crsDialog( this );
QgsCoordinateReferenceSystem crs = mComposerMapGrid->crs();
QString currentAuthId = crs.isValid() ? crs.authid() : mComposerMap->composition()->mapSettings().destinationCrs().authid();
crsDialog.setSelectedAuthId( currentAuthId );
if ( crsDialog.exec() == QDialog::Accepted )
{
mComposerMap->beginCommand( tr( "Grid CRS changed" ) );
QString selectedAuthId = crsDialog.selectedAuthId();
mComposerMapGrid->setCrs( QgsCoordinateReferenceSystem( selectedAuthId ) );
mComposerMap->updateBoundingRect();
mMapGridCRSButton->setText( selectedAuthId );
mComposerMap->endCommand();
}
}
void QgsProjectionSelectionWidget::setLayerCrs( const QgsCoordinateReferenceSystem &crs )
{
int layerItemIndex = mCrsComboBox->findData( QgsProjectionSelectionWidget::LayerCrs );
if ( crs.isValid() )
{
if ( layerItemIndex > -1 )
{
mCrsComboBox->setItemText( layerItemIndex, tr( "Layer CRS (%1, %2)" ).arg( crs.authid(), crs.description() ) );
}
else
{
mCrsComboBox->insertItem( firstRecentCrsIndex(), tr( "Layer CRS (%1, %2)" ).arg( crs.authid(), crs.description() ), QgsProjectionSelectionWidget::LayerCrs );
}
}
else
{
if ( layerItemIndex > -1 )
{
mCrsComboBox->removeItem( layerItemIndex );
}
}
mLayerCrs = crs;
}
void QgsProcessingDistanceWidgetWrapper::setUnitParameterValue( const QVariant &value )
{
QgsUnitTypes::DistanceUnit units = QgsUnitTypes::DistanceUnknownUnit;
// evaluate value to layer
QgsProcessingContext *context = nullptr;
std::unique_ptr< QgsProcessingContext > tmpContext;
if ( mProcessingContextGenerator )
context = mProcessingContextGenerator->processingContext();
if ( !context )
{
tmpContext = qgis::make_unique< QgsProcessingContext >();
context = tmpContext.get();
}
QgsCoordinateReferenceSystem crs = QgsProcessingParameters::parameterAsCrs( parameterDefinition(), value, *context );
if ( crs.isValid() )
{
units = crs.mapUnits();
}
setUnits( units );
}
bool QgsNorthArrowPlugin::calculateNorthDirection()
{
QgsMapCanvas& mapCanvas = *( qGisInterface->mapCanvas() );
bool goodDirn = false;
if ( mapCanvas.layerCount() > 0 )
{
QgsCoordinateReferenceSystem outputCRS = mapCanvas.mapRenderer()->destinationCrs();
if ( outputCRS.isValid() && !outputCRS.geographicFlag() )
{
// Use a geographic CRS to get lat/long to work out direction
QgsCoordinateReferenceSystem ourCRS;
ourCRS.createFromOgcWmsCrs( GEO_EPSG_CRS_AUTHID );
assert( ourCRS.isValid() );
QgsCoordinateTransform transform( outputCRS, ourCRS );
QgsRectangle extent = mapCanvas.extent();
QgsPoint p1( extent.center() );
// A point a bit above p1. XXX assumes that y increases up!!
// May need to involve the maptopixel transform if this proves
// to be a problem.
QgsPoint p2( p1.x(), p1.y() + extent.height() * 0.25 );
// project p1 and p2 to geographic coords
try
{
p1 = transform.transform( p1 );
p2 = transform.transform( p2 );
}
catch ( QgsCsException &e )
{
Q_UNUSED( e );
// just give up
QgsDebugMsg( "North Arrow: Transformation error, quitting" );
return false;
}
// Work out the value of the initial heading one takes to go
// from point p1 to point p2. The north direction is then that
// many degrees anti-clockwise or vertical.
// Take some care to not divide by zero, etc, and ensure that we
// get sensible results for all possible values for p1 and p2.
goodDirn = true;
double angle = 0.0;
// convert to radians for the equations below
p1.multiply( PI / 180.0 );
p2.multiply( PI / 180.0 );
double y = sin( p2.x() - p1.x() ) * cos( p2.y() );
double x = cos( p1.y() ) * sin( p2.y() ) -
sin( p1.y() ) * cos( p2.y() ) * cos( p2.x() - p1.x() );
if ( y > 0.0 )
{
if ( x > TOL )
angle = atan( y / x );
else if ( x < -TOL )
angle = PI - atan( -y / x );
else
angle = 0.5 * PI;
}
else if ( y < 0.0 )
{
if ( x > TOL )
angle = -atan( -y / x );
else if ( x < -TOL )
angle = atan( y / x ) - PI;
else
angle = 1.5 * PI;
}
else
{
if ( x > TOL )
angle = 0.0;
else if ( x < -TOL )
angle = PI;
else
{
angle = 0.0; // p1 = p2
goodDirn = false;
}
}
// And set the angle of the north arrow. Perhaps do something
// different if goodDirn = false.
mRotationInt = static_cast<int>( round( fmod( 360.0 - angle * 180.0 / PI, 360.0 ) ) );
}
else
{
// For geographic CRS and for when there are no layers, set the
// direction back to the default
mRotationInt = 0;
}
}
return goodDirn;
}
