void RoutingManagerPrivate::saveRoute(const QString &filename)
{
GeoWriter writer;
writer.setDocumentType( kml::kmlTag_nameSpaceOgc22 );
QMutexLocker locker( &m_fileMutex );
QFile file( filename );
if ( !file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
{
mDebug() << "Cannot write to " << file.fileName();
return;
}
GeoDataDocument container;
container.setName(QStringLiteral("Route"));
GeoDataFolder* request = routeRequest();
if ( request ) {
container.append( request );
}
GeoDataDocument *route = m_alternativeRoutesModel.currentRoute();
if ( route ) {
container.append( new GeoDataDocument( *route ) );
}
if ( !writer.write( &file, &container ) ) {
mDebug() << "Can not write route state to " << file.fileName();
}
file.close();
}
GeoDataDocument* GosmoreRunnerPrivate::createDocument( GeoDataLineString* routeWaypoints, const QVector<GeoDataPlacemark*> instructions )
{
if ( !routeWaypoints || routeWaypoints->isEmpty() ) {
return nullptr;
}
GeoDataDocument* result = new GeoDataDocument();
GeoDataPlacemark* routePlacemark = new GeoDataPlacemark;
routePlacemark->setName(QStringLiteral("Route"));
routePlacemark->setGeometry( routeWaypoints );
result->append( routePlacemark );
QString name = QStringLiteral("%1 %2 (Gosmore)");
QString unit = QLatin1String( "m" );
qreal length = routeWaypoints->length( EARTH_RADIUS );
if (length >= 1000) {
length /= 1000.0;
unit = "km";
}
result->setName( name.arg( length, 0, 'f', 1 ).arg( unit ) );
for( GeoDataPlacemark* placemark: instructions )
{
result->append( placemark );
}
return result;
}
GeoDataDocument* MonavRunnerPrivate::createDocument( Marble::GeoDataLineString* geometry, const QVector< Marble::GeoDataPlacemark* >& instructions, const QString& name, const Marble::GeoDataExtendedData& data )
{
if ( !geometry || geometry->isEmpty() ) {
return 0;
}
GeoDataDocument* result = new GeoDataDocument;
GeoDataPlacemark* routePlacemark = new GeoDataPlacemark;
routePlacemark->setName(QStringLiteral("Route"));
routePlacemark->setGeometry( geometry );
routePlacemark->setExtendedData( data );
result->append( routePlacemark );
foreach( GeoDataPlacemark* placemark, instructions ) {
result->append( placemark );
}
GeoDataDocument *VectorClipper::clipTo(const GeoDataLatLonBox &tileBoundary, int zoomLevel)
{
bool const useBaseClipper = false;
if (useBaseClipper) {
return clipToBaseClipper(tileBoundary);
}
bool const filterSmallAreas = zoomLevel > 10 && zoomLevel < 17;
GeoDataDocument* tile = new GeoDataDocument();
auto const clip = clipPath(tileBoundary, zoomLevel);
GeoDataLinearRing ring;
ring << GeoDataCoordinates(tileBoundary.west(), tileBoundary.north());
ring << GeoDataCoordinates(tileBoundary.east(), tileBoundary.north());
ring << GeoDataCoordinates(tileBoundary.east(), tileBoundary.south());
ring << GeoDataCoordinates(tileBoundary.west(), tileBoundary.south());
qreal const minArea = filterSmallAreas ? 0.01 * area(ring) : 0.0;
foreach (GeoDataPlacemark const * placemark, potentialIntersections(tileBoundary)) {
GeoDataGeometry const * const geometry = placemark ? placemark->geometry() : nullptr;
if (geometry && tileBoundary.intersects(geometry->latLonAltBox())) {
if(geometry->nodeType() == GeoDataTypes::GeoDataPolygonType) {
clipPolygon(placemark, clip, minArea, tile);
} else if (geometry->nodeType() == GeoDataTypes::GeoDataLineStringType) {
clipString<GeoDataLineString>(placemark, clip, minArea, tile);
} else if (geometry->nodeType() == GeoDataTypes::GeoDataLinearRingType) {
clipString<GeoDataLinearRing>(placemark, clip, minArea, tile);
} else {
tile->append(new GeoDataPlacemark(*placemark));
}
}
}
bool PositionTracking::saveTrack( const QString& fileName )
{
if ( fileName.isEmpty() ) {
return false;
}
GeoWriter writer;
//FIXME: a better way to do this?
writer.setDocumentType( kml::kmlTag_nameSpaceOgc22 );
GeoDataDocument *document = new GeoDataDocument;
QFileInfo fileInfo( fileName );
QString name = fileInfo.baseName();
document->setName( name );
foreach( const GeoDataStyle &style, d->m_document.styles() ) {
document->addStyle( style );
}
foreach( const GeoDataStyleMap &map, d->m_document.styleMaps() ) {
document->addStyleMap( map );
}
GeoDataPlacemark *track = new GeoDataPlacemark( *d->m_currentTrackPlacemark );
track->setName( "Track " + name );
document->append( track );
QFile file( fileName );
file.open( QIODevice::WriteOnly );
bool const result = writer.write( &file, document );
file.close();
delete document;
return result;
}
GeoDataDocument* MonavRunnerPrivate::createDocument( GeoDataLineString *geometry, const QVector<GeoDataPlacemark*> &instructions ) const
{
if ( !geometry || geometry->isEmpty() ) {
return 0;
}
GeoDataDocument* result = new GeoDataDocument;
GeoDataPlacemark* routePlacemark = new GeoDataPlacemark;
routePlacemark->setName( "Route" );
routePlacemark->setGeometry( geometry );
result->append( routePlacemark );
QString name = "%1 %2 (Monav)";
QString unit = "m";
qreal length = geometry->length( EARTH_RADIUS );
if ( length >= 1000 ) {
length /= 1000.0;
unit = "km";
}
foreach( GeoDataPlacemark* placemark, instructions ) {
result->append( placemark );
}
void TourWidgetPrivate::createTour()
{
if ( overrideModifications() ) {
GeoDataDocument *document = new GeoDataDocument();
document->setDocumentRole( UserDocument );
document->setName( "New Tour" );
document->setId( "new_tour" );
GeoDataTour *tour = new GeoDataTour();
tour->setName( "New Tour" );
GeoDataPlaylist *playlist = new GeoDataPlaylist;
tour->setPlaylist( playlist );
document->append( static_cast<GeoDataFeature*>( tour ) );
m_playback.setBaseUrl( QUrl::fromLocalFile( MarbleDirs::marbleDataPath() ) );
openDocument( document );
m_isChanged = true;
m_tourUi.m_actionSaveTour->setEnabled( true );
}
}
void TourWidgetPrivate::addPlacemark()
{
// Get the normalized coordinates of the focus point. There will be automatically added a new
// placemark.
qreal lat = m_widget->focusPoint().latitude();
qreal lon = m_widget->focusPoint().longitude();
GeoDataCoordinates::normalizeLonLat( lon, lat );
GeoDataDocument *document = new GeoDataDocument;
if( m_document->id().isEmpty() ) {
if( m_document->name().isEmpty() ) {
m_document->setId( "untitled_tour" );
} else {
m_document->setId( m_document->name().trimmed().replace( " ", "_" ).toLower() );
}
}
document->setTargetId( m_document->id() );
GeoDataPlacemark *placemark = new GeoDataPlacemark;
placemark->setCoordinate( lon, lat );
placemark->setVisible( true );
placemark->setBalloonVisible( true );
GeoDataStyle *newStyle = new GeoDataStyle( *placemark->style() );
newStyle->iconStyle().setIcon( QImage() );
newStyle->iconStyle().setIconPath( MarbleDirs::path("bitmaps/redflag_22.png") );
placemark->setStyle( newStyle );
document->append( placemark );
GeoDataCreate *create = new GeoDataCreate;
create->append( document );
GeoDataUpdate *update = new GeoDataUpdate;
update->setCreate( create );
GeoDataAnimatedUpdate *animatedUpdate = new GeoDataAnimatedUpdate;
animatedUpdate->setUpdate( update );
if( m_delegate->editAnimatedUpdate( animatedUpdate ) ) {
addTourPrimitive( animatedUpdate );
m_delegate->setDefaultFeatureId( placemark->id() );
} else {
delete animatedUpdate;
}
}
int main(int argc, char** argv) {
QApplication app(argc,argv);
QFileInfo inputFile( app.arguments().last() );
if ( app.arguments().size() < 2 || !inputFile.exists() ) {
qWarning() << "Usage: " << app.arguments().first() << "file.png";
return 1;
}
// Create a Marble QWidget without a parent
MarbleWidget *mapWidget = new MarbleWidget();
// Load the Satellite map
mapWidget->setMapThemeId( "earth/bluemarble/bluemarble.dgml" );
// Create a bounding box from the given corner points
GeoDataLatLonBox box( 55, 48, 14.5, 6, GeoDataCoordinates::Degree );
box.setRotation( 0, GeoDataCoordinates::Degree );
// Create an overlay and assign the image to render and its bounding box to it
GeoDataGroundOverlay *overlay = new GeoDataGroundOverlay;
overlay->setLatLonBox( box );
overlay->setIcon( QImage( inputFile.absoluteFilePath() ) );
// Create a document as a container for the overlay
GeoDataDocument *document = new GeoDataDocument();
document->append( overlay );
// Add the document to MarbleWidget's tree model
mapWidget->model()->treeModel()->addDocument( document );
mapWidget->show();
return app.exec();
}
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 *ShpRunner::parseFile(const QString &fileName, DocumentRole role, QString &error)
{
QFileInfo fileinfo( fileName );
if (fileinfo.suffix().compare(QLatin1String("shp"), Qt::CaseInsensitive) != 0) {
error = QStringLiteral("File %1 does not have a shp suffix").arg(fileName);
mDebug() << error;
return nullptr;
}
SHPHandle handle = SHPOpen( fileName.toStdString().c_str(), "rb" );
if ( !handle ) {
error = QStringLiteral("Failed to read %1").arg(fileName);
mDebug() << error;
return nullptr;
}
int entities;
int shapeType;
SHPGetInfo( handle, &entities, &shapeType, NULL, NULL );
mDebug() << " SHP info " << entities << " Entities "
<< shapeType << " Shape Type ";
DBFHandle dbfhandle;
dbfhandle = DBFOpen( fileName.toStdString().c_str(), "rb");
int nameField = DBFGetFieldIndex( dbfhandle, "Name" );
int noteField = DBFGetFieldIndex( dbfhandle, "Note" );
int mapColorField = DBFGetFieldIndex( dbfhandle, "mapcolor13" );
GeoDataDocument *document = new GeoDataDocument;
document->setDocumentRole( role );
if ( mapColorField != -1 ) {
GeoDataSchema schema;
schema.setId(QStringLiteral("default"));
GeoDataSimpleField simpleField;
simpleField.setName(QStringLiteral("mapcolor13"));
simpleField.setType( GeoDataSimpleField::Double );
schema.addSimpleField( simpleField );
document->addSchema( schema );
}
for ( int i=0; i< entities; ++i ) {
GeoDataPlacemark *placemark = 0;
placemark = new GeoDataPlacemark;
document->append( placemark );
SHPObject *shape = SHPReadObject( handle, i );
if (nameField != -1) {
const char* info = DBFReadStringAttribute( dbfhandle, i, nameField );
// TODO: defaults to utf-8 encoding, but could be also something else, optionally noted in a .cpg file
placemark->setName( info );
mDebug() << "name " << placemark->name();
}
if (noteField != -1) {
const char* note = DBFReadStringAttribute( dbfhandle, i, noteField );
// TODO: defaults to utf-8 encoding, see comment for name
placemark->setDescription( note );
mDebug() << "desc " << placemark->description();
}
double mapColor = DBFReadDoubleAttribute( dbfhandle, i, mapColorField );
if ( mapColor ) {
GeoDataStyle::Ptr style(new GeoDataStyle);
if ( mapColor >= 0 && mapColor <=255 ) {
quint8 colorIndex = quint8( mapColor );
style->polyStyle().setColorIndex( colorIndex );
}
else {
quint8 colorIndex = 0; // mapColor is undefined in this case
style->polyStyle().setColorIndex( colorIndex );
}
placemark->setStyle( style );
}
switch ( shapeType ) {
case SHPT_POINT: {
GeoDataPoint *point = new GeoDataPoint( *shape->padfX, *shape->padfY, 0, GeoDataCoordinates::Degree );
placemark->setGeometry( point );
mDebug() << "point " << placemark->name();
break;
}
case SHPT_MULTIPOINT: {
GeoDataMultiGeometry *geom = new GeoDataMultiGeometry;
for( int j=0; j<shape->nVertices; ++j ) {
geom->append( new GeoDataPoint( GeoDataCoordinates(
shape->padfX[j], shape->padfY[j],
0, GeoDataCoordinates::Degree ) ) );
}
placemark->setGeometry( geom );
mDebug() << "multipoint " << placemark->name();
break;
}
case SHPT_ARC: {
if ( shape->nParts != 1 ) {
GeoDataMultiGeometry *geom = new GeoDataMultiGeometry;
for( int j=0; j<shape->nParts; ++j ) {
GeoDataLineString *line = new GeoDataLineString;
int itEnd = (j + 1 < shape->nParts) ? shape->panPartStart[j+1] : shape->nVertices;
for( int k=shape->panPartStart[j]; k<itEnd; ++k ) {
line->append( GeoDataCoordinates(
shape->padfX[k], shape->padfY[k],
0, GeoDataCoordinates::Degree ) );
}
geom->append( line );
}
placemark->setGeometry( geom );
mDebug() << "arc " << placemark->name() << " " << shape->nParts;
} else {
GeoDataLineString *line = new GeoDataLineString;
for( int j=0; j<shape->nVertices; ++j ) {
line->append( GeoDataCoordinates(
shape->padfX[j], shape->padfY[j],
0, GeoDataCoordinates::Degree ) );
}
placemark->setGeometry( line );
mDebug() << "arc " << placemark->name() << " " << shape->nParts;
}
break;
}
case SHPT_POLYGON: {
if ( shape->nParts != 1 ) {
bool isRingClockwise = false;
GeoDataMultiGeometry *multigeom = new GeoDataMultiGeometry;
GeoDataPolygon *poly = 0;
int polygonCount = 0;
for( int j=0; j<shape->nParts; ++j ) {
GeoDataLinearRing ring;
int itStart = shape->panPartStart[j];
int itEnd = (j + 1 < shape->nParts) ? shape->panPartStart[j+1] : shape->nVertices;
for( int k = itStart; k<itEnd; ++k ) {
ring.append( GeoDataCoordinates(
shape->padfX[k], shape->padfY[k],
0, GeoDataCoordinates::Degree ) );
}
isRingClockwise = ring.isClockwise();
if ( j == 0 || isRingClockwise ) {
poly = new GeoDataPolygon;
++polygonCount;
poly->setOuterBoundary( ring );
if ( polygonCount > 1 ) {
multigeom->append( poly );
}
}
else {
poly->appendInnerBoundary( ring );
}
}
if ( polygonCount > 1 ) {
placemark->setGeometry( multigeom );
}
else {
placemark->setGeometry( poly );
delete multigeom;
multigeom = 0;
}
mDebug() << "donut " << placemark->name() << " " << shape->nParts;
} else {
GeoDataPolygon *poly = new GeoDataPolygon;
GeoDataLinearRing ring;
for( int j=0; j<shape->nVertices; ++j ) {
ring.append( GeoDataCoordinates(
shape->padfX[j], shape->padfY[j],
0, GeoDataCoordinates::Degree ) );
}
poly->setOuterBoundary( ring );
placemark->setGeometry( poly );
mDebug() << "poly " << placemark->name() << " " << shape->nParts;
}
break;
}
}
}
SHPClose( handle );
DBFClose( dbfhandle );
if ( document->size() ) {
document->setFileName( fileName );
return document;
} else {
delete document;
return nullptr;
}
}
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;
}
GeoDataDocument *LogRunner::parseFile(const QString &fileName, DocumentRole role, QString &errorString)
{
QFile file( fileName );
if ( !file.exists() ) {
errorString = QStringLiteral("File %1 does not exist").arg(fileName);
mDebug() << errorString;
return nullptr;
}
file.open( QIODevice::ReadOnly );
QTextStream stream( &file );
GeoDataLineString *const track = new GeoDataLineString;
GeoDataPlacemark *const placemark = new GeoDataPlacemark;
placemark->setGeometry( track );
GeoDataDocument *document = new GeoDataDocument();
document->setDocumentRole( role );
document->append( placemark );
int count = 0;
bool error = false;
while( !stream.atEnd() || error ){
const QString line = stream.readLine();
const QStringList list = line.split(QLatin1Char(','));
if ( list.size() != 7 ) {
mDebug() << Q_FUNC_INFO << "Aborting due to error in line" << count << ". Line was:" << line;
error = true;
break;
}
const QString strLat = list[0];
const QString strLon = list[1];
const QString strElevation = list[2];
const QString strSpeed = list[3];
const QString strCourse = list[4];
const QString strHdop = list[5];
const QString strTime = list[6];
if ( strLat.isEmpty() || strLon.isEmpty() || strElevation.isEmpty() ) {
continue;
}
bool okLat, okLon, okAlt = false;
const qreal lat = strLat.toDouble( &okLat );
const qreal lon = strLon.toDouble( &okLon );
const qreal alt = strElevation.toDouble( &okAlt );
if ( !okLat || !okLon || !okAlt ) {
continue;
}
GeoDataCoordinates coord( lon, lat, alt, GeoDataCoordinates::Degree );
track->append( coord );
}
file.close();
if ( track->size() == 0 || error ) {
delete document;
document = 0;
return nullptr;
}
document->setFileName( fileName );
return document;
}
GeoDataDocument* Pn2Runner::parseForVersion1(const QString& fileName, DocumentRole role)
{
GeoDataDocument *document = new GeoDataDocument();
document->setDocumentRole( role );
bool error = false;
quint32 ID, nrAbsoluteNodes;
quint8 flag, prevFlag = -1;
GeoDataStyle::Ptr style;
GeoDataPolygon *polygon = new GeoDataPolygon;
for ( quint32 currentPoly = 1; ( currentPoly <= m_fileHeaderPolygons ) && ( !error ) && ( !m_stream.atEnd() ); currentPoly++ ) {
m_stream >> ID >> nrAbsoluteNodes >> flag;
if ( flag != INNERBOUNDARY && ( prevFlag == INNERBOUNDARY || prevFlag == OUTERBOUNDARY ) ) {
GeoDataPlacemark *placemark = new GeoDataPlacemark;
placemark->setGeometry( polygon );
if ( m_isMapColorField ) {
if ( style ) {
placemark->setStyle( style );
}
}
document->append( placemark );
}
if ( flag == LINESTRING ) {
GeoDataLineString *linestring = new GeoDataLineString;
error = error | importPolygon( m_stream, linestring, nrAbsoluteNodes );
GeoDataPlacemark *placemark = new GeoDataPlacemark;
placemark->setGeometry( linestring );
document->append( placemark );
}
if ( ( flag == LINEARRING ) || ( flag == OUTERBOUNDARY ) || ( flag == INNERBOUNDARY ) ) {
if ( flag == OUTERBOUNDARY && m_isMapColorField ) {
quint8 colorIndex;
m_stream >> colorIndex;
style = GeoDataStyle::Ptr(new GeoDataStyle);
GeoDataPolyStyle polyStyle;
polyStyle.setColorIndex( colorIndex );
style->setPolyStyle( polyStyle );
}
GeoDataLinearRing* linearring = new GeoDataLinearRing;
error = error | importPolygon( m_stream, linearring, nrAbsoluteNodes );
if ( flag == LINEARRING ) {
GeoDataPlacemark *placemark = new GeoDataPlacemark;
placemark->setGeometry( linearring );
document->append( placemark );
}
if ( flag == OUTERBOUNDARY ) {
polygon = new GeoDataPolygon;
polygon->setOuterBoundary( *linearring );
}
if ( flag == INNERBOUNDARY ) {
polygon->appendInnerBoundary( *linearring );
}
}
if ( flag == MULTIGEOMETRY ) {
// not implemented yet, for now elements inside a multigeometry are separated as individual geometries
}
prevFlag = flag;
}
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;
}
void TestGeoData::parentingTest()
{
GeoDataDocument *document = new GeoDataDocument;
GeoDataFolder *folder = new GeoDataFolder;
/// simple parenting test
GeoDataPlacemark *placemark = new GeoDataPlacemark;
placemark->setParent(document);
QCOMPARE(placemark->parent(), document);
/// simple append and child count test
document->append(placemark);
/// appending folder to document before feeding folder
document->append(folder);
QCOMPARE(document->size(), 2);
GeoDataPlacemark *placemark2 = new GeoDataPlacemark;
folder->append(placemark2);
QCOMPARE(folder->size(), 1);
/// retrieve child and check it matches placemark
GeoDataPlacemark *placemarkPtr;
QCOMPARE(document->child(0)->nodeType(), placemark->nodeType());
placemarkPtr = static_cast<GeoDataPlacemark*>(document->child(0));
QCOMPARE(placemarkPtr, placemark);
/// check retrieved placemark matches intented child
int position = document->childPosition(placemarkPtr);
QCOMPARE(position, 0);
/// retrieve child two and check it matches folder
GeoDataFolder *folderPtr;
QCOMPARE(document->child(1)->nodeType(), folder->nodeType());
folderPtr = static_cast<GeoDataFolder*>(document->child(1));
QCOMPARE(folderPtr, folder);
/// check retrieved folder matches intended child
position = document->childPosition(folderPtr);
QCOMPARE(position, 1);
/// retrieve child three and check it matches placemark
QCOMPARE(folderPtr->size(), 1);
placemarkPtr = static_cast<GeoDataPlacemark*>(folderPtr->child(0));
QCOMPARE(placemarkPtr->nodeType(), placemark2->nodeType());
QCOMPARE(placemarkPtr, placemark2);
/// check retrieved placemark matches intended child
QCOMPARE(folderPtr->childPosition(placemarkPtr), 0);
/// Set a style
GeoDataIconStyle iconStyle;
iconStyle.setIconPath( "myicon.png" );
GeoDataStyle* style = new GeoDataStyle;
style->setStyleId( "mystyle" );
style->setIconStyle( iconStyle );
GeoDataObject* noParent = 0;
QCOMPARE( style->parent(), noParent );
QCOMPARE( iconStyle.parent(), noParent );
document->setStyle( style );
QCOMPARE( style->parent(), document ); // Parent should be assigned now
QCOMPARE( style->iconStyle().parent(), style );
QCOMPARE( iconStyle.parent(), noParent ); // setIconStyle copies
QCOMPARE( placemark->style()->parent(), noParent );
placemark->setStyle( style );
QCOMPARE( placemark->style()->parent(), placemark ); // Parent should be assigned now
/// Set a style map
GeoDataStyleMap* styleMap = new GeoDataStyleMap;
styleMap->setStyleId( "mystylemap" );
styleMap->insert( "normal", "#mystyle" );
styleMap->insert( "highlight", "#mystyle" );
document->addStyle( *style );
document->setStyleMap( styleMap );
QCOMPARE( placemark2->style()->parent(), noParent );
placemark2->setStyleUrl( "#mystyle" );
QCOMPARE( placemark2->style()->parent(), document ); // Parent is document, not placemark2
QCOMPARE( iconStyle.iconPath(), QString( "myicon.png" ) );
QCOMPARE( placemark2->style()->iconStyle().iconPath(), QString( "myicon.png" ) );
}
