QGIS API Documentation 3.28.0-Firenze (ed3ad0430f)
qgsnominatimgeocoder.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsnominatimgeocoder.cpp
3 ---------------
4 Date : December 2020
5 Copyright : (C) 2020 by Mathieu Pellerin
6 Email : nirvn dot asia at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
18#include "qgsgeocodercontext.h"
19#include "qgslogger.h"
22#include <QDateTime>
23#include <QUrl>
24#include <QUrlQuery>
25#include <QMutex>
26#include <QNetworkRequest>
27#include <QJsonDocument>
28#include <QJsonArray>
29
30QMutex QgsNominatimGeocoder::sMutex;
31typedef QMap< QUrl, QList< QgsGeocoderResult > > CachedGeocodeResult;
32Q_GLOBAL_STATIC( CachedGeocodeResult, sCachedResults )
33qint64 QgsNominatimGeocoder::sLastRequestTimestamp = 0;
34
35QgsNominatimGeocoder::QgsNominatimGeocoder( const QString &countryCodes, const QString &endpoint )
37 , mCountryCodes( countryCodes )
38 , mEndpoint( QStringLiteral( "https://nominatim.qgis.org/search" ) )
39{
40 if ( !endpoint.isEmpty() )
41 mEndpoint = endpoint;
42}
43
44QgsGeocoderInterface::Flags QgsNominatimGeocoder::flags() const
45{
47}
48
50{
51 QgsFields fields;
52 fields.append( QgsField( QStringLiteral( "osm_type" ), QVariant::String ) );
53 fields.append( QgsField( QStringLiteral( "display_name" ), QVariant::String ) );
54 fields.append( QgsField( QStringLiteral( "place_id" ), QVariant::String ) );
55 fields.append( QgsField( QStringLiteral( "class" ), QVariant::String ) );
56 fields.append( QgsField( QStringLiteral( "type" ), QVariant::String ) );
57 fields.append( QgsField( QStringLiteral( "road" ), QVariant::String ) );
58 fields.append( QgsField( QStringLiteral( "village" ), QVariant::String ) );
59 fields.append( QgsField( QStringLiteral( "city_district" ), QVariant::String ) );
60 fields.append( QgsField( QStringLiteral( "town" ), QVariant::String ) );
61 fields.append( QgsField( QStringLiteral( "city" ), QVariant::String ) );
62 fields.append( QgsField( QStringLiteral( "state" ), QVariant::String ) );
63 fields.append( QgsField( QStringLiteral( "country" ), QVariant::String ) );
64 fields.append( QgsField( QStringLiteral( "postcode" ), QVariant::String ) );
65 return fields;
66}
67
69{
70 return QgsWkbTypes::Point;
71}
72
73QList<QgsGeocoderResult> QgsNominatimGeocoder::geocodeString( const QString &string, const QgsGeocoderContext &context, QgsFeedback *feedback ) const
74{
75 QgsRectangle bounds;
76 if ( !context.areaOfInterest().isEmpty() )
77 {
78 QgsGeometry g = context.areaOfInterest();
79 const QgsCoordinateTransform ct( context.areaOfInterestCrs(), QgsCoordinateReferenceSystem( QStringLiteral( "EPSG:4326" ) ), context.transformContext() );
80 try
81 {
82 g.transform( ct );
83 bounds = g.boundingBox();
84 }
85 catch ( QgsCsException & )
86 {
87 QgsDebugMsg( "Could not transform geocode bounds to WGS84" );
88 }
89 }
90
91 const QUrl url = requestUrl( string, bounds );
92
93 const QMutexLocker locker( &sMutex );
94 const auto it = sCachedResults()->constFind( url );
95 if ( it != sCachedResults()->constEnd() )
96 {
97 return *it;
98 }
99
100 while ( QDateTime::currentMSecsSinceEpoch() - sLastRequestTimestamp < 1000 / mRequestsPerSecond )
101 {
102 QThread::msleep( 50 );
103 if ( feedback && feedback->isCanceled() )
104 return QList<QgsGeocoderResult>();
105 }
106
107 QNetworkRequest request( url );
108 QgsSetRequestInitiatorClass( request, QStringLiteral( "QgsNominatimGeocoder" ) );
109
111 const QgsBlockingNetworkRequest::ErrorCode errorCode = newReq.get( request, false, feedback );
112
113 sLastRequestTimestamp = QDateTime::currentMSecsSinceEpoch();
114
115 if ( errorCode != QgsBlockingNetworkRequest::NoError )
116 {
117 return QList<QgsGeocoderResult>() << QgsGeocoderResult::errorResult( newReq.errorMessage() );
118 }
119
120 // Parse data
121 QJsonParseError err;
122 const QJsonDocument doc = QJsonDocument::fromJson( newReq.reply().content(), &err );
123 if ( doc.isNull() )
124 {
125 return QList<QgsGeocoderResult>() << QgsGeocoderResult::errorResult( err.errorString() );
126 }
127
128 const QVariantList results = doc.array().toVariantList();
129 if ( results.isEmpty() )
130 {
131 sCachedResults()->insert( url, QList<QgsGeocoderResult>() );
132 return QList<QgsGeocoderResult>();
133 }
134
135 QList< QgsGeocoderResult > matches;
136 matches.reserve( results.size() );
137 for ( const QVariant &result : results )
138 {
139 matches << jsonToResult( result.toMap() );
140 }
141
142 sCachedResults()->insert( url, matches );
143
144 return matches;
145}
146
147QUrl QgsNominatimGeocoder::requestUrl( const QString &address, const QgsRectangle &bounds ) const
148{
149 QUrl res( mEndpoint );
150 QUrlQuery query;
151 query.addQueryItem( QStringLiteral( "format" ), QStringLiteral( "json" ) );
152 query.addQueryItem( QStringLiteral( "addressdetails" ), QStringLiteral( "1" ) );
153 if ( !bounds.isNull() )
154 {
155 query.addQueryItem( QStringLiteral( "viewbox" ), QStringLiteral( "%1,%2,%3,%4" ).arg( bounds.xMinimum() )
156 .arg( bounds.yMinimum() )
157 .arg( bounds.xMaximum() )
158 .arg( bounds.yMaximum() ) );
159 }
160 if ( !mCountryCodes.isEmpty() )
161 {
162 query.addQueryItem( QStringLiteral( "countrycodes" ), mCountryCodes.toLower() );
163 }
164 query.addQueryItem( QStringLiteral( "q" ), address );
165 res.setQuery( query );
166
167 return res;
168}
169
171{
172 const double latitude = json.value( QStringLiteral( "lat" ) ).toDouble();
173 const double longitude = json.value( QStringLiteral( "lon" ) ).toDouble();
174
175 const QgsGeometry geom = QgsGeometry::fromPointXY( QgsPointXY( longitude, latitude ) );
176
177 QgsGeocoderResult res( json.value( QStringLiteral( "display_name" ) ).toString(),
178 geom,
179 QgsCoordinateReferenceSystem( QStringLiteral( "EPSG:4326" ) ) );
180
181 QVariantMap attributes;
182
183 if ( json.contains( QStringLiteral( "display_name" ) ) )
184 attributes.insert( QStringLiteral( "display_name" ), json.value( QStringLiteral( "display_name" ) ).toString() );
185 if ( json.contains( QStringLiteral( "place_id" ) ) )
186 attributes.insert( QStringLiteral( "place_id" ), json.value( QStringLiteral( "place_id" ) ).toString() );
187 if ( json.contains( QStringLiteral( "osm_type" ) ) )
188 attributes.insert( QStringLiteral( "osm_type" ), json.value( QStringLiteral( "osm_type" ) ).toString() );
189 if ( json.contains( QStringLiteral( "class" ) ) )
190 attributes.insert( QStringLiteral( "class" ), json.value( QStringLiteral( "class" ) ).toString() );
191 if ( json.contains( QStringLiteral( "type" ) ) )
192 attributes.insert( QStringLiteral( "type" ), json.value( QStringLiteral( "type" ) ).toString() );
193
194 if ( json.contains( QStringLiteral( "address" ) ) )
195 {
196 const QVariantMap address_components = json.value( QStringLiteral( "address" ) ).toMap();
197 if ( address_components.contains( QStringLiteral( "road" ) ) )
198 attributes.insert( QStringLiteral( "road" ), address_components.value( QStringLiteral( "road" ) ).toString() );
199 if ( address_components.contains( QStringLiteral( "village" ) ) )
200 attributes.insert( QStringLiteral( "village" ), address_components.value( QStringLiteral( "village" ) ).toString() );
201 if ( address_components.contains( QStringLiteral( "city_district" ) ) )
202 attributes.insert( QStringLiteral( "city_district" ), address_components.value( QStringLiteral( "city_district" ) ).toString() );
203 if ( address_components.contains( QStringLiteral( "town" ) ) )
204 attributes.insert( QStringLiteral( "town" ), address_components.value( QStringLiteral( "town" ) ).toString() );
205 if ( address_components.contains( QStringLiteral( "city" ) ) )
206 attributes.insert( QStringLiteral( "city" ), address_components.value( QStringLiteral( "city" ) ).toString() );
207 if ( address_components.contains( QStringLiteral( "state" ) ) )
208 {
209 attributes.insert( QStringLiteral( "state" ), address_components.value( QStringLiteral( "state" ) ).toString() );
210 res.setGroup( address_components.value( QStringLiteral( "state" ) ).toString() );
211 }
212 if ( address_components.contains( QStringLiteral( "country" ) ) )
213 attributes.insert( QStringLiteral( "country" ), address_components.value( QStringLiteral( "country" ) ).toString() );
214 if ( address_components.contains( QStringLiteral( "postcode" ) ) )
215 attributes.insert( QStringLiteral( "postcode" ), address_components.value( QStringLiteral( "postcode" ) ).toString() );
216 }
217
218 if ( json.contains( QStringLiteral( "boundingbox" ) ) )
219 {
220 const QVariantList boundingBox = json.value( QStringLiteral( "boundingbox" ) ).toList();
221 if ( boundingBox.size() == 4 )
222 res.setViewport( QgsRectangle( boundingBox.at( 2 ).toDouble(),
223 boundingBox.at( 0 ).toDouble(),
224 boundingBox.at( 3 ).toDouble(),
225 boundingBox.at( 1 ).toDouble() ) );
226 }
227
228 res.setAdditionalAttributes( attributes );
229 return res;
230}
231
233{
234 return mEndpoint;
235}
236
237void QgsNominatimGeocoder::setEndpoint( const QString &endpoint )
238{
239 mEndpoint = endpoint;
240}
241
243{
244 return mCountryCodes;
245}
246
247void QgsNominatimGeocoder::setCountryCodes( const QString &countryCodes )
248{
249 mCountryCodes = countryCodes;
250}
A thread safe class for performing blocking (sync) network requests, with full support for QGIS proxy...
ErrorCode get(QNetworkRequest &request, bool forceRefresh=false, QgsFeedback *feedback=nullptr)
Performs a "get" operation on the specified request.
QString errorMessage() const
Returns the error message string, after a get(), post(), head() or put() request has been made.
@ NoError
No error was encountered.
QgsNetworkReplyContent reply() const
Returns the content of the network reply, after a get(), post(), head() or put() request has been mad...
This class represents a coordinate reference system (CRS).
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:54
Encapsulate a field in an attribute table or data source.
Definition: qgsfield.h:51
Container of fields for a vector layer.
Definition: qgsfields.h:45
bool append(const QgsField &field, FieldOrigin origin=OriginProvider, int originIndex=-1)
Appends a field. The field must have unique name, otherwise it is rejected (returns false)
Definition: qgsfields.cpp:59
Encapsulates the context of a geocoding operation.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which should be used whenever the geocoder constructs a coo...
QgsCoordinateReferenceSystem areaOfInterestCrs() const
Returns the coordinate reference system for the area of interest, which can be used to indicate the d...
QgsGeometry areaOfInterest() const
Returns the optional area of interest, which can be used to indicate the desired geographic area wher...
Interface for geocoders.
Definition: qgsgeocoder.h:37
@ GeocodesStrings
Can geocode string input values.
Represents a matching result from a geocoder search.
void setAdditionalAttributes(const QVariantMap &attributes)
Setss additional attributes generated during the geocode, which may be added to features being geocod...
void setGroup(const QString &group)
Sets the optional group value for the result.
void setViewport(const QgsRectangle &viewport)
Sets the suggested viewport for the result, which reflects a recommended map extent for displaying th...
static QgsGeocoderResult errorResult(const QString &errorMessage)
Creates an invalid error result, with the specified errorMessage string.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
Qgis::GeometryOperationResult transform(const QgsCoordinateTransform &ct, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool transformZ=false) SIP_THROW(QgsCsException)
Transforms this geometry as described by the coordinate transform ct.
static QgsGeometry fromPointXY(const QgsPointXY &point) SIP_HOLDGIL
Creates a new geometry from a QgsPointXY object.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
QByteArray content() const
Returns the reply content.
QList< QgsGeocoderResult > geocodeString(const QString &string, const QgsGeocoderContext &context, QgsFeedback *feedback=nullptr) const override
Geocodes a string.
QgsGeocoderResult jsonToResult(const QVariantMap &json) const
Converts a JSON result returned from the Nominatim service to a geocoder result object.
QgsNominatimGeocoder(const QString &countryCodes=QString(), const QString &endpoint=QString())
Constructor for QgsNominatimGeocoder.
QString countryCodes() const
Returns the optional region bias which will be used to prioritize results in a certain region.
QString endpoint() const
Returns the API endpoint used for requests.
QgsFields appendedFields() const override
Returns a set of newly created fields which will be appended to existing features during the geocode ...
void setEndpoint(const QString &endpoint)
Sets a specific API endpoint to use for requests.
Flags flags() const override
Returns the geocoder's capability flags.
void setCountryCodes(const QString &countryCodes)
Sets the optional region bias which will be used to prioritize results in a certain region.
QgsWkbTypes::Type wkbType() const override
Returns the WKB type of geometries returned by the geocoder.
QUrl requestUrl(const QString &address, const QgsRectangle &bounds=QgsRectangle()) const
Returns the URL generated for geocoding the specified address.
A class to represent a 2D point.
Definition: qgspointxy.h:59
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
Definition: qgsrectangle.h:479
Type
The WKB type describes the number of dimensions a geometry has.
Definition: qgswkbtypes.h:70
Q_GLOBAL_STATIC(QReadWriteLock, sDefinitionCacheLock)
QMap< QUrl, QList< QgsGeocoderResult > > CachedGeocodeResult
#define QgsDebugMsg(str)
Definition: qgslogger.h:38
#define QgsSetRequestInitiatorClass(request, _class)
QMap< QUrl, QList< QgsGeocoderResult > > CachedGeocodeResult