QgsDatumTransform::TransformPair QgsCoordinateTransformContext::calculateDatumTransforms( const QgsCoordinateReferenceSystem &source, const QgsCoordinateReferenceSystem &destination ) const
{
QString srcKey = source.authid();
QString destKey = destination.authid();
d->mLock.lockForRead();
// highest priority is exact match for source/dest pair
QgsDatumTransform::TransformPair res = d->mSourceDestDatumTransforms.value( qMakePair( srcKey, destKey ), QgsDatumTransform::TransformPair( -1, -1 ) );
if ( res.sourceTransformId == -1 && res.destinationTransformId == -1 )
{
// try to reverse
QgsDatumTransform::TransformPair res2 = d->mSourceDestDatumTransforms.value( qMakePair( destKey, srcKey ), QgsDatumTransform::TransformPair( -1, -1 ) );
res = QgsDatumTransform::TransformPair( res2.destinationTransformId, res2.sourceTransformId );
}
d->mLock.unlock();
return res;
#ifdef singlesourcedest
// fallback to checking src and dest separately
int srcTransform = d->mSourceDatumTransforms.value( srcKey, -1 );
int destTransform = d->mDestDatumTransforms.value( destKey, -1 );
d->mLock.unlock();
return qMakePair( srcTransform, destTransform );
#endif
}
void QgsNewSpatialiteLayerDialog::pbnFindSRID_clicked()
{
// first get list of supported SRID from the selected SpatiaLite database
// to build filter for projection selector
sqlite3_database_unique_ptr database;
bool status = true;
int rc = database.open_v2( mDatabaseComboBox->currentText(), SQLITE_OPEN_READONLY, nullptr );
if ( rc != SQLITE_OK )
{
QMessageBox::warning( this, tr( "SpatiaLite Database" ), tr( "Unable to open the database" ) );
return;
}
// load up the srid table
sqlite3_statement_unique_ptr statement;
QString sql = QStringLiteral( "select auth_name || ':' || auth_srid from spatial_ref_sys order by srid asc" );
QSet<QString> myCRSs;
statement = database.prepare( sql, rc );
// XXX Need to free memory from the error msg if one is set
if ( rc == SQLITE_OK )
{
// get the first row of the result set
while ( sqlite3_step( statement.get() ) == SQLITE_ROW )
{
myCRSs.insert( statement.columnAsText( 0 ) );
}
}
else
{
// XXX query failed -- warn the user some how
QMessageBox::warning( nullptr, tr( "Error" ), tr( "Failed to load SRIDS: %1" ).arg( database.errorMessage() ) );
status = false;
}
if ( status )
{
// prepare projection selector
QgsProjectionSelectionDialog *mySelector = new QgsProjectionSelectionDialog( this );
mySelector->setMessage( QString() );
mySelector->setOgcWmsCrsFilter( myCRSs );
mySelector->setCrs( QgsCoordinateReferenceSystem::fromOgcWmsCrs( mCrsId ) );
if ( mySelector->exec() )
{
QgsCoordinateReferenceSystem srs = mySelector->crs();
QString crsId = srs.authid();
if ( crsId != mCrsId )
{
mCrsId = crsId;
leSRID->setText( srs.authid() + " - " + srs.description() );
}
}
delete mySelector;
}
}
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;
}
QgsNewSpatialiteLayerDialog::QgsNewSpatialiteLayerDialog( QWidget *parent, Qt::WindowFlags fl )
: QDialog( parent, fl )
{
setupUi( this );
QSettings settings;
restoreGeometry( settings.value( "/Windows/NewSpatiaLiteLayer/geometry" ).toByteArray() );
mAddAttributeButton->setIcon( QgsApplication::getThemeIcon( "/mActionNewAttribute.png" ) );
mRemoveAttributeButton->setIcon( QgsApplication::getThemeIcon( "/mActionDeleteAttribute.png" ) );
mTypeBox->addItem( tr( "Text data" ), "text" );
mTypeBox->addItem( tr( "Whole number" ), "integer" );
mTypeBox->addItem( tr( "Decimal number" ), "real" );
mPointRadioButton->setChecked( true );
// Populate the database list from the stored connections
settings.beginGroup( "/SpatiaLite/connections" );
QStringList keys = settings.childGroups();
QStringList::Iterator it = keys.begin();
mDatabaseComboBox->clear();
while ( it != keys.end() )
{
// retrieving the SQLite DB name and full path
QString text = settings.value( *it + "/sqlitepath", "###unknown###" ).toString();
mDatabaseComboBox->addItem( text );
++it;
}
settings.endGroup();
mOkButton = buttonBox->button( QDialogButtonBox::Ok );
mOkButton->setEnabled( false );
// Set the SRID box to a default of WGS84
QgsCoordinateReferenceSystem srs;
srs.createFromOgcWmsCrs( settings.value( "/Projections/layerDefaultCrs", GEO_EPSG_CRS_AUTHID ).toString() );
srs.validate();
mCrsId = srs.authid();
leSRID->setText( srs.authid() + " - " + srs.description() );
pbnFindSRID->setEnabled( mDatabaseComboBox->count() );
connect( mNameEdit, SIGNAL( textChanged( QString ) ), this, SLOT( nameChanged( QString ) ) );
connect( mAttributeView, SIGNAL( itemSelectionChanged() ), this, SLOT( selectionChanged() ) );
connect( leLayerName, SIGNAL( textChanged( const QString& text ) ), this, SLOT( checkOk() ) );
connect( checkBoxPrimaryKey, SIGNAL( clicked() ), this, SLOT( checkOk() ) );
mAddAttributeButton->setEnabled( false );
mRemoveAttributeButton->setEnabled( false );
}
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 );
}
}
void QgsOsgEarthTileSource::initialize( const std::string& referenceURI, const Profile* overrideProfile )
{
Q_UNUSED( referenceURI );
Q_UNUSED( overrideProfile );
setProfile( osgEarth::Registry::instance()->getGlobalGeodeticProfile() );
QgsCoordinateReferenceSystem destCRS;
destCRS.createFromOgcWmsCrs( GEO_EPSG_CRS_AUTHID );
QgsMapCanvas *c = mQGisIface->mapCanvas();
if ( c->mapSettings().destinationCrs().authid().compare( GEO_EPSG_CRS_AUTHID, Qt::CaseInsensitive ) != 0 )
{
// FIXME: crs from canvas or first layer?
QgsCoordinateReferenceSystem srcCRS( c->mapSettings().destinationCrs() );
QgsDebugMsg( QString( "transforming from %1 to %2" ).arg( srcCRS.authid() ).arg( destCRS.authid() ) );
mCoordTransform = new QgsCoordinateTransform( srcCRS, destCRS );
}
else
{
mCoordTransform = 0;
}
#ifdef USE_RENDERER
mMapRenderer = new QgsMapRenderer();
mMapRenderer->setDestinationCrs( destCRS );
mMapRenderer->setProjectionsEnabled( true );
mMapRenderer->setOutputUnits( c->mapRenderer()->outputUnits() );
mMapRenderer->setMapUnits( QGis::Degrees );
#else
mMapSettings.setDestinationCrs( destCRS );
mMapSettings.setCrsTransformEnabled( true );
mMapSettings.setMapUnits( QGis::Degrees );
#endif
}
QString QgsProjectionSelectionWidget::crsOptionText( const QgsCoordinateReferenceSystem &crs )
{
if ( crs.isValid() )
return tr( "%1 - %2" ).arg( crs.authid(), crs.description() );
else
return tr( "invalid projection" );
}
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;
}
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 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;
}
}
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() );
}
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 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() );
}
}
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 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;
}
void QgsNewVectorLayerDialog::on_pbnChangeSpatialRefSys_clicked()
{
QgsGenericProjectionSelector *mySelector = new QgsGenericProjectionSelector( this );
mySelector->setMessage();
mySelector->setSelectedCrsId( mCrsId );
if ( mySelector->exec() )
{
QgsCoordinateReferenceSystem srs;
srs.createFromOgcWmsCrs( mySelector->selectedAuthId() );
mCrsId = srs.srsid();
leSpatialRefSys->setText( srs.authid() + " - " + srs.description() );
}
else
{
QApplication::restoreOverrideCursor();
}
delete mySelector;
}
QString QgsCoordinateFormat::getDisplayString( const QgsPoint& p, const QgsCoordinateReferenceSystem& sSrs , Format format, const QString &epsg )
{
QgsPoint pTrans = QgsCoordinateTransformCache::instance()->transform( sSrs.authid(), epsg )->transform( p );
switch ( format )
{
case Default:
{
const QgsCoordinateReferenceSystem& crs = QgsCRSCache::instance()->crsByAuthId( epsg );
int prec = crs.mapUnits() == QGis::Degrees ? 4 : 0;
return QString( "%1, %2" ).arg( pTrans.x(), 0, 'f', prec ).arg( pTrans.y(), 0, 'f', prec );
}
case DegMinSec:
{
return pTrans.toDegreesMinutesSeconds( 1 );
}
case DegMin:
{
return pTrans.toDegreesMinutes( 3 );
}
case DecDeg:
{
return QString( "%1%2,%3%4" ).arg( pTrans.x(), 0, 'f', 5 ).arg( QChar( 176 ) )
.arg( pTrans.y(), 0, 'f', 5 ).arg( QChar( 176 ) );
}
case UTM:
{
QgsLatLonToUTM::UTMCoo coo = QgsLatLonToUTM::LL2UTM( pTrans );
return QString( "%1, %2 (zone %3%4)" ).arg( coo.easting ).arg( coo.northing ).arg( coo.zoneNumber ).arg( coo.zoneLetter );
}
case MGRS:
{
QgsLatLonToUTM::UTMCoo utm = QgsLatLonToUTM::LL2UTM( pTrans );
QgsLatLonToUTM::MGRSCoo mgrs = QgsLatLonToUTM::UTM2MGRS( utm );
if ( mgrs.letter100kID.isEmpty() )
return QString();
return QString( "%1%2%3 %4 %5" ).arg( mgrs.zoneNumber ).arg( mgrs.zoneLetter ).arg( mgrs.letter100kID ).arg( mgrs.easting, 5, 10, QChar( '0' ) ).arg( mgrs.northing, 5, 10, QChar( '0' ) );
}
}
return "";
}
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;
}
QgsOsgEarthTileSource::QgsOsgEarthTileSource( QgsMapCanvas* theCanvas, const TileSourceOptions& options ) //options = TileSourceOptions()
: TileSource( options )
, mCanvas( theCanvas )
, mCoordTransform( 0 )
#ifdef USE_RENDERER
, mMapRenderer( 0 )
#endif
{
setProfile( osgEarth::Registry::instance()->getGlobalGeodeticProfile() );
QgsCoordinateReferenceSystem destCRS;
destCRS.createFromOgcWmsCrs( GEO_EPSG_CRS_AUTHID );
if ( mCanvas->mapSettings().destinationCrs().authid().compare( GEO_EPSG_CRS_AUTHID, Qt::CaseInsensitive ) != 0 )
{
// FIXME: crs from canvas or first layer?
QgsCoordinateReferenceSystem srcCRS( mCanvas->mapSettings().destinationCrs() );
QgsDebugMsg( QString( "transforming from %1 to %2" ).arg( srcCRS.authid() ).arg( destCRS.authid() ) );
mCoordTransform = new QgsCoordinateTransform( srcCRS, destCRS );
}
else
{
mCoordTransform = 0;
}
#ifdef USE_RENDERER
mMapRenderer = new QgsMapRenderer();
mMapRenderer->setDestinationCrs( destCRS );
mMapRenderer->setProjectionsEnabled( true );
mMapRenderer->setOutputUnits( mCanvas->mapRenderer()->outputUnits() );
mMapRenderer->setMapUnits( QGis::Degrees );
#else
mMapSettings.setDestinationCrs( destCRS );
mMapSettings.setCrsTransformEnabled( true );
mMapSettings.setMapUnits( QGis::Degrees );
#endif
}
bool QgsAmsSourceSelect::connectToService( const QgsOwsConnection &connection )
{
QString errorTitle, errorMessage;
const QString authcfg = connection.uri().param( QStringLiteral( "authcfg" ) );
const QVariantMap serviceInfoMap = QgsArcGisRestUtils::getServiceInfo( connection.uri().param( QStringLiteral( "url" ) ), authcfg, errorTitle, errorMessage );
if ( serviceInfoMap.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to retrieve service capabilities:\n%1: %2" ).arg( errorTitle, errorMessage ) );
return false;
}
populateImageEncodings( serviceInfoMap[QStringLiteral( "supportedImageFormatTypes" )].toString().split( ',' ) );
QStringList layerErrors;
const QVariantList layersList = serviceInfoMap[QStringLiteral( "layers" )].toList();
for ( const QVariant &layerInfo : layersList )
{
QVariantMap layerInfoMap = layerInfo.toMap();
if ( !layerInfoMap[QStringLiteral( "id" )].isValid() )
{
continue;
}
// Get layer info
QVariantMap layerData = QgsArcGisRestUtils::getLayerInfo( connection.uri().param( QStringLiteral( "url" ) ) + "/" + layerInfoMap[QStringLiteral( "id" )].toString(),
authcfg, errorTitle, errorMessage );
if ( layerData.isEmpty() )
{
layerErrors.append( QStringLiteral( "Layer %1: %2 - %3" ).arg( layerInfoMap[QStringLiteral( "id" )].toString(), errorTitle, errorMessage ) );
continue;
}
// insert the typenames, titles and abstracts into the tree view
QStandardItem *idItem = new QStandardItem( layerData[QStringLiteral( "id" )].toString() );
idItem->setData( true, IsLayerRole );
bool ok = false;
int idInt = layerData[QStringLiteral( "id" )].toInt( &ok );
if ( ok )
{
// force display role to be int value, so that sorting works correctly
idItem->setData( idInt, Qt::DisplayRole );
}
QStandardItem *nameItem = new QStandardItem( layerData[QStringLiteral( "name" )].toString() );
QStandardItem *abstractItem = new QStandardItem( layerData[QStringLiteral( "description" )].toString() );
abstractItem->setToolTip( layerData[QStringLiteral( "description" )].toString() );
QgsCoordinateReferenceSystem crs = QgsArcGisRestUtils::parseSpatialReference( serviceInfoMap[QStringLiteral( "spatialReference" )].toMap() );
if ( !crs.isValid() )
{
layerErrors.append( tr( "Layer %1: unable to parse spatial reference" ).arg( layerInfoMap[QStringLiteral( "id" )].toString() ) );
continue;
}
mAvailableCRS[layerData[QStringLiteral( "name" )].toString()] = QList<QString>() << crs.authid();
mModel->appendRow( QList<QStandardItem *>() << idItem << nameItem << abstractItem );
}
if ( !layerErrors.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to query some layers:\n%1" ).arg( layerErrors.join( QStringLiteral( "\n" ) ) ) );
}
return true;
}
bool QgsWFSProvider::getCapabilities()
{
mCapabilities = 0;
QgsWFSCapabilities getCapabilities( mShared->mURI.uri() );
if ( !getCapabilities.requestCapabilities( true ) )
{
QgsMessageLog::logMessage( tr( "GetCapabilities failed for url %1: %2" ).
arg( dataSourceUri() ).arg( getCapabilities.errorMessage() ), tr( "WFS" ) );
return false;
}
const QgsWFSCapabilities::Capabilities caps = getCapabilities.capabilities();
mShared->mWFSVersion = caps.version;
if ( mShared->mURI.maxNumFeatures() > 0 )
mShared->mMaxFeatures = mShared->mURI.maxNumFeatures();
else
mShared->mMaxFeatures = caps.maxFeatures;
mShared->mMaxFeaturesServer = caps.maxFeatures;
mShared->mSupportsHits = caps.supportsHits;
mShared->mSupportsPaging = caps.supportsPaging;
//find the <FeatureType> for this layer
QString thisLayerName = mShared->mURI.typeName();
for ( int i = 0; i < caps.featureTypes.size(); i++ )
{
if ( thisLayerName == caps.featureTypes[i].name )
{
const QgsRectangle& r = caps.featureTypes[i].bboxLongLat;
if ( mShared->mSourceCRS.authid().isEmpty() && caps.featureTypes[i].crslist.size() != 0 )
{
mShared->mSourceCRS.createFromOgcWmsCrs( caps.featureTypes[i].crslist[0] );
}
if ( !r.isNull() )
{
QgsCoordinateReferenceSystem src;
src.createFromOgcWmsCrs( "CRS:84" );
QgsCoordinateTransform ct( src, mShared->mSourceCRS );
QgsDebugMsg( "latlon ext:" + r.toString() );
QgsDebugMsg( "src:" + src.authid() );
QgsDebugMsg( "dst:" + mShared->mSourceCRS.authid() );
mExtent = ct.transformBoundingBox( r, QgsCoordinateTransform::ForwardTransform );
QgsDebugMsg( "layer ext:" + mExtent.toString() );
}
if ( caps.featureTypes[i].insertCap )
{
mCapabilities |= QgsVectorDataProvider::AddFeatures;
}
if ( caps.featureTypes[i].updateCap )
{
mCapabilities |= QgsVectorDataProvider::ChangeAttributeValues;
mCapabilities |= QgsVectorDataProvider::ChangeGeometries;
}
if ( caps.featureTypes[i].deleteCap )
{
mCapabilities |= QgsVectorDataProvider::DeleteFeatures;
}
return true;
}
}
QgsMessageLog::logMessage( tr( "Could not find typename %1 in capabilites for url %2" ).
arg( thisLayerName ).arg( dataSourceUri() ), tr( "WFS" ) );
return false;
}
void QgsBrowserLayerProperties::setItem( QgsDataItem* item )
{
QgsLayerItem *layerItem = qobject_cast<QgsLayerItem*>( item );
if ( !layerItem )
return;
mNoticeLabel->clear();
QgsMapLayer::LayerType type = layerItem->mapLayerType();
QString layerMetadata = tr( "Error" );
QgsCoordinateReferenceSystem layerCrs;
// temporarily override /Projections/defaultBehaviour to avoid dialog prompt
QSettings settings;
QString defaultProjectionOption = settings.value( "/Projections/defaultBehaviour", "prompt" ).toString();
if ( settings.value( "/Projections/defaultBehaviour", "prompt" ).toString() == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", "useProject" );
}
// find root item
// we need to create a temporary layer to get metadata
// we could use a provider but the metadata is not as complete and "pretty" and this is easier
QgsDebugMsg( QString( "creating temporary layer using path %1" ).arg( layerItem->path() ) );
if ( type == QgsMapLayer::RasterLayer )
{
QgsDebugMsg( "creating raster layer" );
// should copy code from addLayer() to split uri ?
QgsRasterLayer* layer = new QgsRasterLayer( layerItem->uri(), layerItem->uri(), layerItem->providerKey() );
if ( layer )
{
if ( layer->isValid() )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
}
delete layer;
}
}
else if ( type == QgsMapLayer::VectorLayer )
{
QgsDebugMsg( "creating vector layer" );
QgsVectorLayer* layer = new QgsVectorLayer( layerItem->uri(), layerItem->name(), layerItem->providerKey() );
if ( layer )
{
if ( layer->isValid() )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
}
delete layer;
}
}
else if ( type == QgsMapLayer::PluginLayer )
{
// TODO: support display of properties for plugin layers
return;
}
// restore /Projections/defaultBehaviour
if ( defaultProjectionOption == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", defaultProjectionOption );
}
mNameLabel->setText( layerItem->name() );
mUriLabel->setText( layerItem->uri() );
mProviderLabel->setText( layerItem->providerKey() );
QString myStyle = QgsApplication::reportStyleSheet();
mMetadataTextBrowser->document()->setDefaultStyleSheet( myStyle );
mMetadataTextBrowser->setHtml( layerMetadata );
// report if layer was set to to project crs without prompt (may give a false positive)
if ( defaultProjectionOption == "prompt" )
{
QgsCoordinateReferenceSystem defaultCrs =
QgisApp::instance()->mapCanvas()->mapSettings().destinationCrs();
if ( layerCrs == defaultCrs )
mNoticeLabel->setText( "NOTICE: Layer srs set from project (" + defaultCrs.authid() + ')' );
}
if ( mNoticeLabel->text().isEmpty() )
{
mNoticeLabel->hide();
}
}
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 QgsCoordinateTransformContext::removeSourceDatumTransform( const QgsCoordinateReferenceSystem &crs )
{
d->mSourceDatumTransforms.remove( crs.authid() );
}
void QgsBrowserDockWidget::showProperties( )
{
QgsDebugMsg( "Entered" );
QgsDataItem* dataItem = mModel->dataItem( mBrowserView->currentIndex() );
if ( dataItem != NULL && dataItem->type() == QgsDataItem::Layer )
{
QgsLayerItem *layerItem = qobject_cast<QgsLayerItem*>( dataItem );
if ( layerItem != NULL )
{
QgsMapLayer::LayerType type = layerItem->mapLayerType();
QString layerMetadata = tr( "Error" );
QgsCoordinateReferenceSystem layerCrs;
QString notice;
// temporarily override /Projections/defaultBehaviour to avoid dialog prompt
QSettings settings;
QString defaultProjectionOption = settings.value( "/Projections/defaultBehaviour", "prompt" ).toString();
if ( settings.value( "/Projections/defaultBehaviour", "prompt" ).toString() == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", "useProject" );
}
// find root item
// we need to create a temporary layer to get metadata
// we could use a provider but the metadata is not as complete and "pretty" and this is easier
QgsDebugMsg( QString( "creating temporary layer using path %1" ).arg( layerItem->path() ) );
if ( type == QgsMapLayer::RasterLayer )
{
QgsDebugMsg( "creating raster layer" );
// should copy code from addLayer() to split uri ?
QgsRasterLayer* layer = new QgsRasterLayer( layerItem->uri(), layerItem->uri(), layerItem->providerKey() );
if ( layer != NULL )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
delete layer;
}
}
else if ( type == QgsMapLayer::VectorLayer )
{
QgsDebugMsg( "creating vector layer" );
QgsVectorLayer* layer = new QgsVectorLayer( layerItem->uri(), layerItem->name(), layerItem->providerKey() );
if ( layer != NULL )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
delete layer;
}
}
// restore /Projections/defaultBehaviour
if ( defaultProjectionOption == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", defaultProjectionOption );
}
// initialize dialog
QDialog *dialog = new QDialog( this );
Ui::QgsBrowserLayerPropertiesBase ui;
ui.setupUi( dialog );
dialog->setWindowTitle( tr( "Layer Properties" ) );
ui.leName->setText( layerItem->name() );
ui.leSource->setText( layerItem->path() );
ui.leProvider->setText( layerItem->providerKey() );
QString myStyle = QgsApplication::reportStyleSheet();
ui.txtbMetadata->document()->setDefaultStyleSheet( myStyle );
ui.txtbMetadata->setHtml( layerMetadata );
// report if layer was set to to project crs without prompt (may give a false positive)
if ( defaultProjectionOption == "prompt" )
{
QgsCoordinateReferenceSystem defaultCrs =
QgisApp::instance()->mapCanvas()->mapRenderer()->destinationCrs();
if ( layerCrs == defaultCrs )
ui.lblNotice->setText( "NOTICE: Layer srs set from project (" + defaultCrs.authid() + ")" );
}
dialog->show();
}
}
}
void QgsCoordinateTransformContext::removeDestinationDatumTransform( const QgsCoordinateReferenceSystem &crs )
{
d->mDestDatumTransforms.remove( crs.authid() );
}
void QgsCoordinateTransformContext::removeSourceDestinationDatumTransform( const QgsCoordinateReferenceSystem &sourceCrs, const QgsCoordinateReferenceSystem &destinationCrs )
{
d->mSourceDestDatumTransforms.remove( qMakePair( sourceCrs.authid(), destinationCrs.authid() ) );
}
