void GosmoreRunner::reverseGeocoding( const GeoDataCoordinates &coordinates )
{
if ( !d->m_gosmoreMapFile.exists() )
{
emit reverseGeocodingFinished( coordinates, GeoDataPlacemark() );
return;
}
QString queryString = "flat=%1&flon=%2&tlat=%1&tlon=%2&fastest=1&v=motorcar";
double lon = coordinates.longitude( GeoDataCoordinates::Degree );
double lat = coordinates.latitude( GeoDataCoordinates::Degree );
queryString = queryString.arg( lat, 0, 'f', 8).arg(lon, 0, 'f', 8 );
QByteArray output = d->retrieveWaypoints( queryString );
GeoDataPlacemark placemark;
placemark.setCoordinate( coordinates );
QStringList lines = QString::fromUtf8( output ).split( '\r' );
if ( lines.size() > 2 ) {
QStringList fields = lines.at( lines.size()-2 ).split(',');
if ( fields.size() >= 5 ) {
QString road = fields.last().trimmed();
placemark.setAddress( road );
GeoDataExtendedData extendedData;
extendedData.addValue( GeoDataData( "road", road ) );
placemark.setExtendedData( extendedData );
}
}
emit reverseGeocodingFinished( coordinates, placemark );
}
GeoDataExtendedData OsmNominatimRunner::extractChildren(const QDomNode &node)
{
GeoDataExtendedData data;
QDomNodeList nodes = node.childNodes();
for (int i=0, n=nodes.length(); i<n; ++i) {
QDomNode child = nodes.item(i);
data.addValue( GeoDataData( child.nodeName(), child.toElement().text() ) );
}
return data;
}
QVector<GeoDataPlacemark*> GosmoreRunnerPrivate::parseGosmoreInstructions( const QByteArray &content )
{
// Determine gosmore version
QStringList lines = QString::fromUtf8(content).split(QLatin1Char('\r'));
if ( lines.size() > 2 ) {
const QStringList fields = lines.at(lines.size()-2).split(QLatin1Char(','));
m_parser.setFieldIndex( WaypointParser::RoadName, fields.size()-1 );
if ( fields.size() < 5 || fields.size() > 6 ) {
// Can happen when gosmore changes the output format, returns garbage
// or the last street name contains a comma. We may still parse it correctly, just try.
mDebug() << "Unexpected number of fields. This gosmore version may be unsupported.";
}
}
QVector<GeoDataPlacemark*> result;
QTextStream stream( content );
stream.setCodec("UTF8");
stream.setAutoDetectUnicode( true );
RoutingInstructions directions = InstructionTransformation::process( m_parser.parse( stream ) );
for( int i=0; i<directions.size(); ++i ) {
GeoDataPlacemark* placemark = new GeoDataPlacemark( directions[i].instructionText() );
GeoDataExtendedData extendedData;
GeoDataData turnType;
turnType.setName(QStringLiteral("turnType"));
turnType.setValue( qVariantFromValue<int>( int( directions[i].turnType() ) ) );
extendedData.addValue( turnType );
GeoDataData roadName;
roadName.setName(QStringLiteral("roadName"));
roadName.setValue( directions[i].roadName() );
extendedData.addValue( roadName );
placemark->setExtendedData( extendedData );
Q_ASSERT( !directions[i].points().isEmpty() );
GeoDataLineString* geometry = new GeoDataLineString;
QVector<RoutingWaypoint> items = directions[i].points();
for (int j=0; j<items.size(); ++j ) {
RoutingPoint point = items[j].point();
GeoDataCoordinates coordinates( point.lon(), point.lat(), 0.0, GeoDataCoordinates::Degree );
geometry->append( coordinates );
}
placemark->setGeometry( geometry );
result.push_back( placemark );
}
return result;
}
OsmRelationEditorDialog::OsmRelationEditorDialog( OsmPlacemarkData *relationData, QWidget *parent ) :
QDialog( parent )
{
m_relationData = relationData;
QVBoxLayout *layout = new QVBoxLayout( this );
// Name input area
QHBoxLayout *nameLayout = new QHBoxLayout();
QLabel *nameLabel = new QLabel( tr( "Name" ), this );
m_nameLineEdit = new QLineEdit( this );
m_nameLineEdit->setText(relationData->tagValue(QStringLiteral("name")));
nameLayout->addWidget( nameLabel );
nameLayout->addWidget( m_nameLineEdit );
layout->addLayout( nameLayout );
// Tag editor area
// A dummy placemark is needed because the OsmTagEditorWidget works with placemarks
m_dummyPlacemark = new GeoDataPlacemark();
// "osmRelaation=yes" entry is added to its ExtendedData to let the widget know
// its special relation status
GeoDataExtendedData extendedData;
extendedData.addValue(GeoDataData(QStringLiteral("osmRelation"), QStringLiteral("yes")));
m_dummyPlacemark->setExtendedData( extendedData );
m_dummyPlacemark->setOsmData( *m_relationData );
OsmObjectManager::initializeOsmData( m_dummyPlacemark );
m_tagEditor = new OsmTagEditorWidget( m_dummyPlacemark, this );
layout->addWidget( m_tagEditor );
// Button box area
m_buttonBox = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this );
layout->addWidget( m_buttonBox );
QObject::connect( m_buttonBox, SIGNAL( accepted() ),
this, SLOT( checkFields() ) );
connect(m_buttonBox, SIGNAL(rejected()), SLOT(reject()));
}
GeoDataDocument* MapQuestRunner::parse( const QByteArray &content ) const
{
QDomDocument xml;
if ( !xml.setContent( content ) ) {
mDebug() << "Cannot parse xml file with routing instructions.";
return 0;
}
// mDebug() << xml.toString(2);
QDomElement root = xml.documentElement();
GeoDataDocument* result = new GeoDataDocument();
result->setName( "MapQuest" );
GeoDataPlacemark* routePlacemark = new GeoDataPlacemark;
routePlacemark->setName( "Route" );
GeoDataLineString* routeWaypoints = new GeoDataLineString;
QDomNodeList shapePoints = root.elementsByTagName( "shapePoints" );
if ( shapePoints.size() == 1 ) {
QDomNodeList geometry = shapePoints.at( 0 ).toElement().elementsByTagName( "latLng" );
for ( int i=0; i<geometry.size(); ++i ) {
double const lat = geometry.item( i ).namedItem( "lat" ).toElement().text().toDouble();
double const lon = geometry.item( i ).namedItem( "lng" ).toElement().text().toDouble();
GeoDataCoordinates const position( lon, lat, 0.0, GeoDataCoordinates::Degree );
routeWaypoints->append( position );
}
}
routePlacemark->setGeometry( routeWaypoints );
QTime time;
time = time.addSecs( root.elementsByTagName( "time" ).at( 0 ).toElement().text().toInt() );
qreal length = routeWaypoints->length( EARTH_RADIUS );
const QString name = nameString( "MQ", length, time );
const GeoDataExtendedData data = routeData( length, time );
routePlacemark->setExtendedData( data );
result->setName( name );
result->append( routePlacemark );
QMap<int,int> mapping;
QDomNodeList maneuvers = root.elementsByTagName( "maneuverIndexes" );
if ( maneuvers.size() == 1 ) {
maneuvers = maneuvers.at( 0 ).childNodes();
for ( int i=0; i<maneuvers.size(); ++i ) {
mapping[i] = maneuvers.at( i ).toElement().text().toInt();
if ( mapping[i] == routeWaypoints->size() ) {
--mapping[i];
}
}
}
QDomNodeList instructions = root.elementsByTagName( "maneuver" );
unsigned int const lastInstruction = qMax<int>( 0, instructions.length()-1 ); // ignore the last 'Welcome to xy' instruction
for ( unsigned int i = 0; i < lastInstruction; ++i ) {
QDomElement node = instructions.item( i ).toElement();
QDomNodeList maneuver = node.elementsByTagName( "turnType" );
QDomNodeList textNodes = node.elementsByTagName( "narrative" );
QDomNodeList points = node.elementsByTagName( "startPoint" );
QDomNodeList streets = node.elementsByTagName( "streets" );
Q_ASSERT( mapping.contains( i ) );
if ( textNodes.size() == 1 && maneuver.size() == 1 && points.size() == 1 && mapping.contains( i ) ) {
GeoDataPlacemark* instruction = new GeoDataPlacemark;
instruction->setName( textNodes.at( 0 ).toElement().text() );
GeoDataExtendedData extendedData;
GeoDataData turnType;
turnType.setName( "turnType" );
turnType.setValue( maneuverType( maneuver.at( 0 ).toElement().text().toInt() ) );
extendedData.addValue( turnType );
if ( streets.size() == 1 ) {
GeoDataData roadName;
roadName.setName( "roadName" );
roadName.setValue( streets.at( 0 ).toElement().text() );
extendedData.addValue( roadName );
}
instruction->setExtendedData( extendedData );
int const start = mapping[i];
int const end = mapping.contains(i+1) ? mapping[i+1] : routeWaypoints->size()-1;
if ( start >= 0 && start < routeWaypoints->size() && end < routeWaypoints->size() ) {
instruction->setName( textNodes.item( 0 ).toElement().text() );
GeoDataLineString *lineString = new GeoDataLineString;
for ( int j=start; j<=end; ++j ) {
*lineString << GeoDataCoordinates( routeWaypoints->at( j ).longitude(), routeWaypoints->at( j ).latitude() );
}
if ( !lineString->isEmpty() ) {
instruction->setGeometry( lineString );
result->append( instruction );
}
}
}
}
if ( routeWaypoints->size() < 1 ) {
delete result;
result = 0;
}
return result;
}
GeoDataDocument* OpenRouteServiceRunner::parse( const QByteArray &content ) const
{
QDomDocument xml;
if ( !xml.setContent( content ) ) {
mDebug() << "Cannot parse xml file with routing instructions.";
return nullptr;
}
QDomElement root = xml.documentElement();
GeoDataDocument* result = new GeoDataDocument();
result->setName(QStringLiteral("OpenRouteService"));
QDomNodeList errors = root.elementsByTagName(QStringLiteral("xls:Error"));
if ( errors.size() > 0 ) {
return nullptr;
// Returning early because fallback routing providers are used now
// The code below can be used to parse OpenGis errors reported by ORS
// and may be useful in the future
for (int i=0 ; i < errors.length(); ++i ) {
QDomNode node = errors.item( i );
QString errorMessage = node.attributes().namedItem(QStringLiteral("message")).nodeValue();
QRegExp regexp = QRegExp( "^(.*) Please Check your Position: (-?[0-9]+.[0-9]+) (-?[0-9]+.[0-9]+) !" );
if ( regexp.indexIn( errorMessage ) == 0 ) {
if ( regexp.capturedTexts().size() == 4 ) {
GeoDataPlacemark* placemark = new GeoDataPlacemark;
placemark->setName( regexp.capturedTexts().at( 1 ) );
GeoDataCoordinates position;
position.setLongitude( regexp.capturedTexts().at( 2 ).toDouble(), GeoDataCoordinates::Degree );
position.setLatitude( regexp.capturedTexts().at( 3 ).toDouble(), GeoDataCoordinates::Degree );
placemark->setCoordinate( position );
result->append( placemark );
}
} else {
mDebug() << "Error message " << errorMessage << " not parsable.";
/** @todo: How to handle this now with plugins? */
// QString message = tr( "Sorry, a problem occurred when calculating the route. Try adjusting start and destination points." );
// QPointer<QMessageBox> messageBox = new QMessageBox( QMessageBox::Warning, "Route Error", message );
// messageBox->setDetailedText( errorMessage );
// messageBox->exec();
// delete messageBox;
}
}
}
GeoDataPlacemark* routePlacemark = new GeoDataPlacemark;
routePlacemark->setName(QStringLiteral("Route"));
QTime time;
QDomNodeList summary = root.elementsByTagName(QStringLiteral("xls:RouteSummary"));
if ( summary.size() > 0 ) {
QDomNodeList timeNodeList = summary.item(0).toElement().elementsByTagName(QStringLiteral("xls:TotalTime"));
if ( timeNodeList.size() == 1 ) {
QRegExp regexp = QRegExp( "^P(?:(\\d+)D)?T(?:(\\d+)H)?(?:(\\d+)M)?(\\d+)S" );
if ( regexp.indexIn( timeNodeList.item( 0 ).toElement().text() ) == 0 ) {
QStringList matches = regexp.capturedTexts();
unsigned int hours( 0 ), minutes( 0 ), seconds( 0 );
switch ( matches.size() ) {
case 5:
// days = regexp.cap( matches.size() - 4 ).toInt();
// Intentionally no break
case 4:
hours = regexp.cap( matches.size() - 3 ).toInt();
// Intentionally no break
case 3:
minutes = regexp.cap( matches.size() - 2 ).toInt();
// Intentionally no break
case 2:
seconds = regexp.cap( matches.size() - 1 ).toInt();
break;
default:
mDebug() << "Unable to parse time string " << timeNodeList.item( 0 ).toElement().text();
}
time = QTime( hours, minutes, seconds, 0 );
}
}
}
GeoDataLineString* routeWaypoints = new GeoDataLineString;
QDomNodeList geometry = root.elementsByTagName(QStringLiteral("xls:RouteGeometry"));
if ( geometry.size() > 0 ) {
QDomNodeList waypoints = geometry.item( 0 ).toElement().elementsByTagName( "gml:pos" );
for (int i=0 ; i < waypoints.length(); ++i ) {
QDomNode node = waypoints.item( i );
const QStringList content = node.toElement().text().split(QLatin1Char(' '));
if ( content.length() == 2 ) {
GeoDataCoordinates position;
position.setLongitude( content.at( 0 ).toDouble(), GeoDataCoordinates::Degree );
position.setLatitude( content.at( 1 ).toDouble(), GeoDataCoordinates::Degree );
routeWaypoints->append( position );
}
}
}
routePlacemark->setGeometry( routeWaypoints );
qreal length = routeWaypoints->length( EARTH_RADIUS );
const QString name = nameString( "ORS", length, time );
const GeoDataExtendedData data = routeData( length, time );
routePlacemark->setExtendedData( data );
result->setName( name );
result->append( routePlacemark );
QDomNodeList instructionList = root.elementsByTagName(QStringLiteral("xls:RouteInstructionsList"));
if ( instructionList.size() > 0 ) {
QDomNodeList instructions = instructionList.item(0).toElement().elementsByTagName(QStringLiteral("xls:RouteInstruction"));
for (int i=0 ; i < instructions.length(); ++i ) {
QDomElement node = instructions.item( i ).toElement();
QDomNodeList textNodes = node.elementsByTagName(QStringLiteral("xls:Instruction"));
QDomNodeList positions = node.elementsByTagName(QStringLiteral("gml:pos"));
if ( textNodes.size() > 0 && positions.size() > 0 ) {
const QStringList content = positions.at(0).toElement().text().split(QLatin1Char(' '));
if ( content.length() == 2 ) {
GeoDataLineString *lineString = new GeoDataLineString;
for( int i = 0; i < positions.count(); ++i ) {
const QStringList pointList = positions.at(i).toElement().text().split(QLatin1Char(' '));
GeoDataCoordinates position;
position.setLongitude( pointList.at( 0 ).toDouble(), GeoDataCoordinates::Degree );
position.setLatitude( pointList.at( 1 ).toDouble(), GeoDataCoordinates::Degree );
lineString->append( position );
}
GeoDataPlacemark* instruction = new GeoDataPlacemark;
QString const text = textNodes.item( 0 ).toElement().text().remove(QRegExp("<[^>]*>"));
GeoDataExtendedData extendedData;
GeoDataData turnTypeData;
turnTypeData.setName(QStringLiteral("turnType"));
QString road;
RoutingInstruction::TurnType turnType = parseTurnType( text, &road );
turnTypeData.setValue( turnType );
extendedData.addValue( turnTypeData );
if ( !road.isEmpty() ) {
GeoDataData roadName;
roadName.setName(QStringLiteral("roadName"));
roadName.setValue( road );
extendedData.addValue( roadName );
}
QString const instructionText = turnType == RoutingInstruction::Unknown ? text : RoutingInstruction::generateRoadInstruction( turnType, road );
instruction->setName( instructionText );
instruction->setExtendedData( extendedData );
instruction->setGeometry( lineString );
result->append( instruction );
}
}
}
}
return result;
}
int MonavRunnerPrivate::retrieveRoute( const Marble::RouteRequest* route, QVector< Marble::GeoDataPlacemark* >* instructions, Marble::GeoDataLineString* geometry ) const
{
RoutingResult reply;
if ( retrieveData( route, &reply ) ) {
/** @todo: make use of reply.seconds, the estimated travel time */
for ( int i = 0; i < reply.pathNodes.size(); ++i ) {
qreal lon = reply.pathNodes[i].longitude;
qreal lat = reply.pathNodes[i].latitude;
GeoDataCoordinates coordinates( lon, lat, 0, GeoDataCoordinates::Degree );
geometry->append( coordinates );
}
RoutingWaypoints waypoints;
int k = 0;
for ( int i = 0; i < reply.pathEdges.size(); ++i ) {
QString road = reply.nameStrings[reply.pathEdges[i].name];
QString type = reply.typeStrings[reply.pathEdges[i].type];
RoutingWaypoint::JunctionType junction = RoutingWaypoint::Other;
if (type == QLatin1String("roundabout") && reply.pathEdges[i].branchingPossible) {
junction = RoutingWaypoint::Roundabout;
}
for ( unsigned int l = 0; l < reply.pathEdges[i].length; ++k, ++l ) {
qreal lon = reply.pathNodes[k].longitude;
qreal lat = reply.pathNodes[k].latitude;
RoutingPoint point( lon, lat );
bool const last = l == reply.pathEdges[i].length - 1;
RoutingWaypoint::JunctionType finalJunction = last ? junction : ( reply.pathEdges[i].branchingPossible ? RoutingWaypoint::Other : RoutingWaypoint::None );
RoutingWaypoint waypoint( point, finalJunction, "", type, -1, road );
waypoints.push_back( waypoint );
}
}
RoutingInstructions directions = InstructionTransformation::process( waypoints );
for ( int i = 0; i < directions.size(); ++i ) {
GeoDataPlacemark* placemark = new GeoDataPlacemark( directions[i].instructionText() );
GeoDataExtendedData extendedData;
GeoDataData turnType;
turnType.setName(QStringLiteral("turnType"));
turnType.setValue( qVariantFromValue<int>( int( directions[i].turnType() ) ) );
extendedData.addValue( turnType );
GeoDataData roadName;
roadName.setName(QStringLiteral("roadName"));
roadName.setValue( directions[i].roadName() );
extendedData.addValue( roadName );
placemark->setExtendedData( extendedData );
Q_ASSERT( !directions[i].points().isEmpty() );
GeoDataLineString* geometry = new GeoDataLineString;
QVector<RoutingWaypoint> items = directions[i].points();
for ( int j = 0; j < items.size(); ++j ) {
RoutingPoint point = items[j].point();
GeoDataCoordinates coordinates( point.lon(), point.lat(), 0.0, GeoDataCoordinates::Degree );
geometry->append( coordinates );
}
placemark->setGeometry( geometry );
instructions->push_back( placemark );
}
int duration = (int) reply.seconds;
return duration;
}
return 0;
}
void OsmNominatimRunner::handleResult( QNetworkReply* reply )
{
QDomDocument xml;
if (!xml.setContent(reply->readAll())) {
qWarning() << "Cannot parse osm nominatim result";
qWarning() << reply->error();
returnNoResults();
return;
}
QVector<GeoDataPlacemark*> placemarks;
QDomElement root = xml.documentElement();
QDomNodeList places = root.elementsByTagName(QStringLiteral("place"));
for (int i=0; i<places.size(); ++i) {
QDomNode place = places.at(i);
QDomNamedNodeMap attributes = place.attributes();
QString lon = attributes.namedItem(QStringLiteral("lon")).nodeValue();
QString lat = attributes.namedItem(QStringLiteral("lat")).nodeValue();
QString desc = attributes.namedItem(QStringLiteral("display_name")).nodeValue();
QString key = attributes.namedItem(QStringLiteral("class")).nodeValue();
QString value = attributes.namedItem(QStringLiteral("type")).nodeValue();
OsmPlacemarkData data;
GeoDataExtendedData placemarkData = extractChildren(place);
placemarkData.addValue(GeoDataData(QStringLiteral("class"), key));
placemarkData.addValue(GeoDataData(QStringLiteral("type"), value));
QString name = place.firstChildElement(value).text();
QString road = place.firstChildElement(QStringLiteral("road")).text();
placemarkData.addValue(GeoDataData(QStringLiteral("name"), name));
QString city = place.firstChildElement(QStringLiteral("city")).text();
if( city.isEmpty() ) {
city = place.firstChildElement(QStringLiteral("town")).text();
if( city.isEmpty() ) {
city = place.firstChildElement(QStringLiteral("village")).text();
} if( city.isEmpty() ) {
city = place.firstChildElement(QStringLiteral("hamlet")).text();
}
}
QString administrative = place.firstChildElement(QStringLiteral("county")).text();
if( administrative.isEmpty() ) {
administrative = place.firstChildElement(QStringLiteral("region")).text();
if( administrative.isEmpty() ) {
administrative = place.firstChildElement(QStringLiteral("state")).text();
data.addTag(QStringLiteral("addr:state"), administrative);
} else {
data.addTag(QStringLiteral("district"), administrative);
}
}
QString country = place.firstChildElement(QStringLiteral("country")).text();
QString description;
for (int i=0; i<place.childNodes().size(); ++i) {
QDomElement item = place.childNodes().at(i).toElement();
description += item.nodeName() + QLatin1Char(':') + item.text() + QLatin1Char('\n');
}
description += QLatin1String("Category: ") + key + QLatin1Char('/') + value;
if (!lon.isEmpty() && !lat.isEmpty() && !desc.isEmpty()) {
QString placemarkName;
GeoDataPlacemark* placemark = new GeoDataPlacemark;
// try to provide 2 fields
if (!name.isEmpty()) {
placemarkName = name;
}
if (!road.isEmpty() && road != placemarkName ) {
if( !placemarkName.isEmpty() ) {
placemarkName += QLatin1String(", ");
}
placemarkName += road;
data.addTag(QStringLiteral("addr:street"), road);
}
if (!city.isEmpty() && !placemarkName.contains(QLatin1Char(',')) && city != placemarkName) {
if( !placemarkName.isEmpty() ) {
placemarkName += QLatin1String(", ");
}
placemarkName += city;
data.addTag(QStringLiteral("addr:city"), city);
}
if (!administrative.isEmpty() && !placemarkName.contains(QLatin1Char(',')) && administrative != placemarkName) {
if( !placemarkName.isEmpty() ) {
placemarkName += QLatin1String(", ");
}
placemarkName += administrative;
}
if (!country.isEmpty() && !placemarkName.contains(QLatin1Char(',')) && country != placemarkName) {
if( !placemarkName.isEmpty() ) {
placemarkName += QLatin1String(", ");
}
placemarkName += country;
data.addTag(QStringLiteral("addr:country"), country);
}
if (placemarkName.isEmpty()) {
placemarkName = desc;
}
placemark->setName( placemarkName );
placemark->setDescription(description);
placemark->setAddress(desc);
placemark->setCoordinate( lon.toDouble(), lat.toDouble(), 0, GeoDataCoordinates::Degree );
const auto category = StyleBuilder::determineVisualCategory(data);
placemark->setVisualCategory( category );
placemark->setExtendedData(placemarkData);
placemark->setOsmData(data);
placemarks << placemark;
}
}
emit searchFinished( placemarks );
}
GeoDataDocument *CycleStreetsRunner::parse( const QByteArray &content ) const
{
QDomDocument xml;
if ( !xml.setContent( content ) ) {
mDebug() << "Cannot parse xml file with routing instructions.";
return 0;
}
GeoDataDocument *result = new GeoDataDocument();
result->setName( "CycleStreets" );
GeoDataPlacemark *routePlacemark = new GeoDataPlacemark;
routePlacemark->setName( "Route" );
GeoDataLineString *routeWaypoints = new GeoDataLineString;
QDomNodeList features = xml.elementsByTagName( "gml:featureMember" );
if ( features.isEmpty() ) {
return 0;
}
QDomElement route = features.at( 0 ).toElement().firstChild().toElement();
QDomElement lineString = route.elementsByTagName( "gml:LineString" ).at( 0 ).toElement();
QDomElement coordinates = lineString.toElement().elementsByTagName( "gml:coordinates" ).at( 0 ).toElement();
QStringList coordinatesList = coordinates.text().split( ' ' );
QStringList::iterator iter = coordinatesList.begin();
QStringList::iterator end = coordinatesList.end();
for( ; iter != end; ++iter) {
QStringList coordinate = iter->split(',');
if ( coordinate.size() == 2 ) {
double const lon = coordinate.at( 0 ).toDouble();
double const lat = coordinate.at( 1 ).toDouble();
GeoDataCoordinates const position( lon, lat, 0.0, GeoDataCoordinates::Degree );
routeWaypoints->append( position );
}
}
routePlacemark->setGeometry( routeWaypoints );
QDomElement durationElement = route.elementsByTagName( "cs:time" ).at(0).toElement();
QTime duration;
duration = duration.addSecs( durationElement.text().toInt() );
qreal length = routeWaypoints->length( EARTH_RADIUS );
const QString name = nameString( "CS", length, duration );
const GeoDataExtendedData data = routeData( length, duration );
routePlacemark->setExtendedData( data );
result->setName( name );
result->append( routePlacemark );
int i;
for ( i = 1; i < features.count() && features.at( i ).firstChildElement().tagName() != "cs:segment"; ++i );
for ( ; i < features.count(); ++i) {
QDomElement segment = features.at( i ).toElement();
QString name = segment.elementsByTagName( "cs:name" ).at( 0 ).toElement().text();
QString maneuver = segment.elementsByTagName( "cs:turn" ).at( 0 ).toElement().text();
QStringList points = segment.elementsByTagName( "cs:points" ).at( 0 ).toElement().text().split( ' ' );
QStringList const elevation = segment.elementsByTagName( "cs:elevations" ).at( 0 ).toElement().text().split( ',' );
GeoDataPlacemark *instructions = new GeoDataPlacemark;
QString instructionName;
if ( !maneuver.isEmpty() ) {
instructionName = maneuver.left( 1 ).toUpper() + maneuver.mid( 1 );
} else {
instructionName = "Straight";
}
if ( name != "Short un-named link" && name != "Un-named link" ){
instructionName.append( " into " + name );
}
instructions->setName( instructionName );
GeoDataExtendedData extendedData;
GeoDataData turnType;
turnType.setName( "turnType" );
turnType.setValue( maneuverType( maneuver ) );
extendedData.addValue( turnType );
instructions->setExtendedData( extendedData );
GeoDataLineString *lineString = new GeoDataLineString;
QStringList::iterator iter = points.begin();
QStringList::iterator end = points.end();
for ( int j=0; iter != end; ++iter, ++j ) {
QStringList coordinate = iter->split( ',' );
if ( coordinate.size() == 2 ) {
double const lon = coordinate.at( 0 ).toDouble();
double const lat = coordinate.at( 1 ).toDouble();
double const alt = j < elevation.size() ? elevation[j].toDouble() : 0.0;
lineString->append( GeoDataCoordinates( lon, lat, alt, GeoDataCoordinates::Degree ) );
}
}
instructions->setGeometry( lineString );
result->append( instructions );
}
return result;
}
