void OsmNominatimRunner::search( const QString &searchTerm, const GeoDataLatLonBox &preferred )
{
QString base = "http://nominatim.openstreetmap.org/search?";
QString query = "q=%1&format=xml&addressdetails=1&accept-language=%2";
QString url = QString(base + query).arg(searchTerm).arg(MarbleLocale::languageCode());
if( !preferred.isEmpty() ) {
GeoDataCoordinates::Unit deg = GeoDataCoordinates::Degree;
QString viewbox( "&viewbox=%1,%2,%3,%4&bounded=1" ); // left, top, right, bottom
url += viewbox.arg(preferred.west(deg))
.arg(preferred.north(deg))
.arg(preferred.east(deg))
.arg(preferred.south(deg));
}
m_request.setUrl(QUrl(url));
m_request.setRawHeader("User-Agent", TinyWebBrowser::userAgent("Browser", "OsmNominatimRunner") );
QEventLoop eventLoop;
QTimer timer;
timer.setSingleShot( true );
timer.setInterval( 15000 );
connect( &timer, SIGNAL(timeout()),
&eventLoop, SLOT(quit()));
connect( this, SIGNAL(searchFinished(QVector<GeoDataPlacemark*>)),
&eventLoop, SLOT(quit()) );
// @todo FIXME Must currently be done in the main thread, see bug 257376
QTimer::singleShot( 0, this, SLOT(startSearch()) );
timer.start();
eventLoop.exec();
}
bool LocalMapLayer::isValidPerspective(const GeoDataLatLonBox &candidate) const
{
if (!mVisible || !mHasContent)
{ //any perspective is valid if no content is showing
return true;
}
GeoDataLatLonBox box = mLocalMapLogic->currentBox();
if (!candidate.contains(box) && !candidate.intersects(box))
{ //No relation - invalid perspective
return false;
}
//Acceptable scales
qreal d = diameter(box);
qreal zoomOutLimit = d * 4;
qreal zoomInLimit = d * 0.25;
qreal dCandidate = diameter(candidate);
if (dCandidate > zoomOutLimit || dCandidate < zoomInLimit)
{ //Box is too big or too small
return false;
}
return true;
}
void
MapScreen::perform_search(QString term, qreal distance)
{
GeoDataLatLonBox box;
GeoDataCoordinates location;
setCurrentIndex(indexOf(results_screen));
last_search_term = term;
last_search_distance = distance;
if (distance > MAX_DISTANCE) {
search_manager->findPlacemarks(term);
return;
}
location = navigation_screen->map_widget->focusPoint();
box.setNorth(location.latitude() - km_to_rad(distance));
box.setSouth(location.latitude() + km_to_rad(distance));
box.setEast(location.longitude() - km_to_rad(distance));
box.setWest(location.longitude() + km_to_rad(distance));
qDebug() << "Box north:" << box.north(GeoDataCoordinates::Degree);
qDebug() << "Box south:" << box.south(GeoDataCoordinates::Degree);
qDebug() << "Box west:" << box.west(GeoDataCoordinates::Degree);
qDebug() << "Box east:" << box.east(GeoDataCoordinates::Degree);
search_manager->findPlacemarks(term, box);
}
void TestGeoDataLatLonAltBox::testUnited()
{
QFETCH( GeoDataLatLonBox, box1 );
QFETCH( GeoDataLatLonBox, box2 );
QFETCH( GeoDataLatLonBox, expected );
GeoDataLatLonBox const result = box1 | box2;
QCOMPARE( result.north( GeoDataCoordinates::Degree ), expected.north( GeoDataCoordinates::Degree ) );
QCOMPARE( result.south( GeoDataCoordinates::Degree ), expected.south( GeoDataCoordinates::Degree ) );
QCOMPARE( result.west( GeoDataCoordinates::Degree ), expected.west( GeoDataCoordinates::Degree ) );
QCOMPARE( result.east( GeoDataCoordinates::Degree ), expected.east( GeoDataCoordinates::Degree ) );
}
GeoDataLatLonAltBox::GeoDataLatLonAltBox( const GeoDataLatLonBox &other, qreal minAltitude, qreal maxAltitude )
: GeoDataLatLonBox( other ),
d( new GeoDataLatLonAltBoxPrivate )
{
setWest( other.west() );
setEast( other.east() );
setNorth( other.north() );
setSouth( other.south() );
setRotation( other.rotation() );
d->m_minAltitude = minAltitude;
d->m_maxAltitude = maxAltitude;
}
QUrl CustomServerLayout::downloadUrl( const QUrl &prototypeUrl, const TileId &id ) const
{
const GeoDataLatLonBox bbox = id.toLatLonBox( m_textureLayer );
#if QT_VERSION < 0x050000
QString urlStr = prototypeUrl.toString();
#else
QString urlStr = prototypeUrl.toString( QUrl::DecodeReserved );
#endif
urlStr.replace( "{zoomLevel}", QString::number( id.zoomLevel() ) );
urlStr.replace( "{x}", QString::number( id.x() ) );
urlStr.replace( "{y}", QString::number( id.y() ) );
urlStr.replace( "{west}", QString::number( bbox.west( GeoDataCoordinates::Degree ), 'f', 12 ) );
urlStr.replace( "{south}", QString::number( bbox.south( GeoDataCoordinates::Degree ), 'f', 12 ) );
urlStr.replace( "{east}", QString::number( bbox.east( GeoDataCoordinates::Degree ), 'f', 12 ) );
urlStr.replace( "{north}", QString::number( bbox.north( GeoDataCoordinates::Degree ), 'f', 12 ) );
return QUrl( urlStr );
}
QUrl WmsServerLayout::downloadUrl( const QUrl &prototypeUrl, const Marble::TileId &tileId ) const
{
GeoDataLatLonBox box = tileId.toLatLonBox( m_textureLayer );
#if QT_VERSION < 0x050000
QUrl url = prototypeUrl;
#else
QUrlQuery url(prototypeUrl.query());
#endif
url.addQueryItem( "service", "WMS" );
url.addQueryItem( "request", "GetMap" );
url.addQueryItem( "version", "1.1.1" );
if ( !url.hasQueryItem( "styles" ) )
url.addQueryItem( "styles", "" );
if ( !url.hasQueryItem( "format" ) ) {
if ( m_textureLayer->fileFormat().toLower() == "jpg" )
url.addQueryItem( "format", "image/jpeg" );
else
url.addQueryItem( "format", "image/" + m_textureLayer->fileFormat().toLower() );
}
if ( !url.hasQueryItem( "srs" ) ) {
url.addQueryItem( "srs", epsgCode() );
}
if ( !url.hasQueryItem( "layers" ) )
url.addQueryItem( "layers", m_textureLayer->name() );
url.addQueryItem( "width", QString::number( m_textureLayer->tileSize().width() ) );
url.addQueryItem( "height", QString::number( m_textureLayer->tileSize().height() ) );
url.addQueryItem( "bbox", QString( "%1,%2,%3,%4" ).arg( QString::number( box.west( GeoDataCoordinates::Degree ), 'f', 12 ) )
.arg( QString::number( box.south( GeoDataCoordinates::Degree ), 'f', 12 ) )
.arg( QString::number( box.east( GeoDataCoordinates::Degree ), 'f', 12 ) )
.arg( QString::number( box.north( GeoDataCoordinates::Degree ), 'f', 12 ) ) );
#if QT_VERSION < 0x050000
return url;
#else
QUrl finalUrl = prototypeUrl;
finalUrl.setQuery(url);
return finalUrl;
#endif
}
DatabaseQuery::DatabaseQuery( const MarbleModel* model, const QString &searchTerm, const GeoDataLatLonBox &preferred ) :
m_queryType( BroadSearch ), m_resultFormat( AddressFormat ), m_searchTerm( searchTerm.trimmed() ),
m_category( OsmPlacemark::UnknownCategory )
{
if ( model && model->positionTracking()->status() == PositionProviderStatusAvailable ) {
m_position = model->positionTracking()->currentLocation();
m_resultFormat = DistanceFormat;
} else if ( !preferred.isEmpty() ) {
m_position = preferred.center();
m_resultFormat = AddressFormat;
} else {
m_resultFormat = AddressFormat;
}
QStringList terms = m_searchTerm.split(QLatin1Char(','), QString::SkipEmptyParts );
QRegExp streetAndHouse( "^(.*)\\s+(\\d+\\D?)$" );
if ( streetAndHouse.indexIn( terms.first() ) != -1 ) {
if ( streetAndHouse.capturedTexts().size() == 3 ) {
terms.removeFirst();
terms.push_front( streetAndHouse.capturedTexts().at( 1 ) );
terms.push_front( streetAndHouse.capturedTexts().at( 2 ) );
}
}
Q_ASSERT( terms.size() > 0 );
if ( terms.size() == 1 ) {
m_queryType = isPointOfInterest( m_searchTerm ) ? CategorySearch : BroadSearch;
} else if ( terms.size() == 2 ) {
m_street = terms.first().trimmed();
m_region = terms.last().trimmed();
m_queryType = isPointOfInterest( m_street ) ? CategorySearch : AddressSearch;
} else {
m_houseNumber = terms.first().trimmed();
m_street = terms.at( 1 ).trimmed();
m_region = terms.last().trimmed(); // skips 2, 3, ..., if any
m_queryType = AddressSearch;
}
}
bool ViewportParams::resolves ( const GeoDataLatLonBox &latLonBox ) const
{
return latLonBox.width() + latLonBox.height() > 2.0 * angularResolution();
}
void GroundOverlayFrame::update()
{
GeoDataLatLonBox overlayLatLonBox = m_overlay->latLonBox();
GeoDataPolygon *poly = dynamic_cast<GeoDataPolygon*>( placemark()->geometry() );
poly->outerBoundary().clear();
GeoDataCoordinates rotatedCoord;
GeoDataCoordinates northWest(overlayLatLonBox.west(), overlayLatLonBox.north());
rotatedCoord = northWest.rotateAround(overlayLatLonBox.center(), overlayLatLonBox.rotation());
poly->outerBoundary().append( rotatedCoord );
GeoDataCoordinates southWest(overlayLatLonBox.west(), overlayLatLonBox.south());
rotatedCoord = southWest.rotateAround(overlayLatLonBox.center(), overlayLatLonBox.rotation());
poly->outerBoundary().append( rotatedCoord );
GeoDataCoordinates southEast(overlayLatLonBox.east(), overlayLatLonBox.south());
rotatedCoord = southEast.rotateAround(overlayLatLonBox.center(), overlayLatLonBox.rotation());
poly->outerBoundary().append( rotatedCoord );
GeoDataCoordinates northEast(overlayLatLonBox.east(), overlayLatLonBox.north());
rotatedCoord = northEast.rotateAround(overlayLatLonBox.center(), overlayLatLonBox.rotation());
poly->outerBoundary().append( rotatedCoord );
}
void TestGeoDataLatLonAltBox::testDefaultConstruction()
{
GeoDataLatLonBox const latLonBox;
QCOMPARE( latLonBox.north(), 0.0 );
QCOMPARE( latLonBox.south(), 0.0 );
QCOMPARE( latLonBox.east(), 0.0 );
QCOMPARE( latLonBox.west(), 0.0 );
QCOMPARE( latLonBox.rotation(), 0.0 );
QCOMPARE( latLonBox.width(), 0.0 );
QCOMPARE( latLonBox.height(), 0.0 );
QVERIFY( !latLonBox.crossesDateLine() );
QCOMPARE( latLonBox.center(), GeoDataCoordinates( 0, 0 ) );
QVERIFY( latLonBox.isNull() );
QVERIFY( latLonBox.isEmpty() );
QVERIFY( (latLonBox|latLonBox).isNull() );
QVERIFY( (latLonBox|latLonBox).isEmpty() );
QVERIFY( !latLonBox.intersects( latLonBox ) );
GeoDataLatLonAltBox const latLonAltBox;
QCOMPARE( latLonAltBox.north(), 0.0 );
QCOMPARE( latLonAltBox.south(), 0.0 );
QCOMPARE( latLonAltBox.east(), 0.0 );
QCOMPARE( latLonAltBox.west(), 0.0 );
QCOMPARE( latLonAltBox.rotation(), 0.0 );
QCOMPARE( latLonAltBox.width(), 0.0 );
QCOMPARE( latLonAltBox.height(), 0.0 );
QVERIFY( !latLonAltBox.crossesDateLine() );
QCOMPARE( latLonAltBox.center(), GeoDataCoordinates( 0, 0, 0 ) );
QVERIFY( latLonAltBox.isNull() );
QVERIFY( latLonAltBox.isEmpty() );
QCOMPARE( latLonAltBox.minAltitude(), 0.0 );
QCOMPARE( latLonAltBox.maxAltitude(), 0.0 );
QCOMPARE( latLonAltBox.altitudeMode(), ClampToGround );
QVERIFY( (latLonAltBox|latLonAltBox).isNull() );
QVERIFY( (latLonAltBox|latLonAltBox).isEmpty() );
QVERIFY( !latLonAltBox.intersects( latLonAltBox ) );
}
QList< GeoGraphicsItem* > GeoGraphicsScene::items( const GeoDataLatLonBox &box, int zoomLevel ) const
{
if ( box.west() > box.east() ) {
// Handle boxes crossing the IDL by splitting it into two separate boxes
GeoDataLatLonBox left;
left.setWest( -M_PI );
left.setEast( box.east() );
left.setNorth( box.north() );
left.setSouth( box.south() );
GeoDataLatLonBox right;
right.setWest( box.west() );
right.setEast( M_PI );
right.setNorth( box.north() );
right.setSouth( box.south() );
QList< GeoGraphicsItem* > allItems = items( left, zoomLevel );
foreach( GeoGraphicsItem* item, items( right, zoomLevel ) ) {
if ( !allItems.contains( item ) ) {
allItems << item;
}
}
return allItems;
}
