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" ) ); }