• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdeedu API Reference
  • KDE Home
  • Contact Us
 

marble

  • sources
  • kde-4.14
  • kdeedu
  • marble
  • src
  • lib
  • marble
  • routing
  • instructions
RoutingInstruction.cpp
Go to the documentation of this file.
1 //
2 // This file is part of the Marble Virtual Globe.
3 //
4 // This program is free software licensed under the GNU LGPL. You can
5 // find a copy of this license in LICENSE.txt in the top directory of
6 // the source code.
7 //
8 // Copyright 2010 Dennis Nienhüser <earthwings@gentoo.org>
9 //
10 
11 #include "RoutingInstruction.h"
12 #include "MarbleLocale.h"
13 
14 #include <QCoreApplication>
15 #include <QStringList>
16 
17 #include <cmath>
18 
19 namespace Marble
20 {
21 
22 RoutingInstruction::RoutingInstruction( const RoutingWaypoint &item ) :
23  m_roadName( item.roadName() ), m_roadType( item.roadType() ),
24  m_secondsLeft( item.secondsRemaining() ),
25  m_angleToPredecessor( 0.0 ), m_roundaboutExit( 0 ),
26  m_predecessor( 0 ), m_successor( 0 )
27 {
28  m_points.append( item );
29 }
30 
31 bool RoutingInstruction::append( const RoutingWaypoint &item, int angle )
32 {
33  if ( m_points.size() && m_points.last().roadType() != "roundabout" && item.roadType() == "roundabout" ) {
34  // Entering a roundabout. Merge with previous segment to avoid 'Enter the roundabout' instructions
35  m_points.push_back( item );
36  return true;
37  }
38 
39  if ( m_points.size() && m_points.last().roadType() == "roundabout" && item.roadType() != "roundabout" ) {
40  // Exiting a roundabout
41  m_points.push_back( item );
42  return false;
43  }
44 
45  m_points.push_back( item );
46 
47  if ( item.junctionType() == RoutingWaypoint::Roundabout ) {
48  // Passing a roundabout exit
49  ++m_roundaboutExit;
50  return true;
51  }
52 
53  if ( item.roadName().isEmpty() ) {
54  if ( item.junctionType() == RoutingWaypoint::None ) {
55  return true;
56  }
57 
58  return angle >= 150 && angle <= 210;
59  } else {
60  return item.roadType() == "roundabout" || item.roadName() == roadName();
61  }
62 }
63 
64 QString RoutingInstruction::roadName() const
65 {
66  return m_roadName;
67 }
68 
69 QString RoutingInstruction::roadType() const
70 {
71  return m_roadType;
72 }
73 
74 int RoutingInstruction::secondsLeft() const
75 {
76  return m_secondsLeft;
77 }
78 
79 void RoutingInstruction::calculateAngle()
80 {
81  if ( !m_predecessor ) {
82  return;
83  }
84 
85  int hisSize = m_predecessor->points().size();
86  int mySize = m_points.size();
87  Q_ASSERT( mySize > 0 && hisSize > 0 );
88  RoutingPoint one = points().first().point();
89  RoutingPoint two = m_predecessor->points().at( hisSize - 1 ).point();
90  qreal distance = 0;
91  for ( int i = 2; i <= qMin<int>( hisSize, 20 ) && distance < 50.0; ++i ) {
92  two = m_predecessor->points().at( hisSize - i ).point();
93  m_intersectionPoints.push_front( two );
94  distance = one.distance( two );
95  }
96  qreal before = two.bearing( one );
97  m_intersectionPoints.push_back( one );
98 
99  one = points().first().point();
100  if ( mySize == 1 && !m_successor ) {
101  return;
102  } else if ( mySize == 1 ) {
103  Q_ASSERT( !m_successor->points().isEmpty() );
104  two = m_successor->points().first().point();
105  } else {
106  two = points().at( 1 ).point();
107  }
108 
109  distance = 0;
110  m_intersectionPoints.push_back( one );
111  for ( int i = 2; i < qMin<int>( mySize, 20 ) && distance < 50.0; ++i ) {
112  two = points().at( i ).point();
113  m_intersectionPoints.push_back( two );
114  distance = one.distance( two );
115  }
116 
117  qreal after = one.bearing( two );
118  m_angleToPredecessor = after - before;
119 }
120 
121 void RoutingInstruction::calculateTurnType()
122 {
123  if ( predecessor() && predecessor()->roundaboutExitNumber() ) {
124  int exit = predecessor()->roundaboutExitNumber();
125  switch( exit ) {
126  case 1:
127  m_turnType = RoundaboutFirstExit;
128  break;
129  case 2:
130  m_turnType = RoundaboutSecondExit;
131  break;
132  case 3:
133  m_turnType = RoundaboutThirdExit;
134  break;
135  default:
136  m_turnType = RoundaboutExit;
137  break;
138  }
139 
140  return;
141  }
142 
143  int angle = qRound( angleToPredecssor() * 180.0 / M_PI + 540 ) % 360;
144  Q_ASSERT( angle >= 0 && angle <= 360 );
145 
146  const int sharp = 30;
147  if ( angle >= 360 - sharp || angle < sharp ) {
148  m_turnType = TurnAround;
149  } else if ( angle >= sharp && angle < 90 - sharp ) {
150  m_turnType = SharpLeft;
151  } else if ( angle >= 90 - sharp && angle < 90 + sharp ) {
152  m_turnType = Left;
153  } else if ( angle >= 90 + sharp && angle < 180 - sharp ) {
154  m_turnType = SlightLeft;
155  } else if ( angle >= 180 - sharp && angle < 180 + sharp ) {
156  m_turnType = Straight;
157  } else if ( angle >= 180 + sharp && angle < 270 - sharp ) {
158  m_turnType = SlightRight;
159  } else if ( angle >= 270 - sharp && angle < 270 + sharp ) {
160  m_turnType = Right;
161  } else if ( angle >= 270 + sharp && angle < 360 - sharp ) {
162  m_turnType = SharpRight;
163  } else {
164  Q_ASSERT( false && "Internal error: not all angles are properly handled" );
165  }
166 }
167 
168 QVector<RoutingWaypoint> RoutingInstruction::points() const
169 {
170  return m_points;
171 }
172 
173 QVector<RoutingPoint> RoutingInstruction::intersectionPoints() const
174 {
175  return m_intersectionPoints;
176 }
177 
178 qreal RoutingInstruction::angleToPredecssor() const
179 {
180  return m_angleToPredecessor;
181 }
182 
183 RoutingInstruction* RoutingInstruction::predecessor()
184 {
185  return m_predecessor;
186 }
187 
188 const RoutingInstruction* RoutingInstruction::predecessor() const
189 {
190  return m_predecessor;
191 }
192 
193 void RoutingInstruction::setPredecessor( RoutingInstruction* predecessor )
194 {
195  m_predecessor = predecessor;
196  calculateAngle();
197  calculateTurnType();
198 }
199 
200 RoutingInstruction* RoutingInstruction::successor()
201 {
202  return m_successor;
203 }
204 
205 const RoutingInstruction* RoutingInstruction::successor() const
206 {
207  return m_successor;
208 }
209 
210 void RoutingInstruction::setSuccessor( RoutingInstruction* successor )
211 {
212  m_successor = successor;
213 }
214 
215 qreal RoutingInstruction::distance() const
216 {
217  qreal result = 0.0;
218  for ( int i = 1; i < m_points.size(); ++i ) {
219  result += m_points[i-1].point().distance( m_points[i].point() );
220  }
221 
222  return result;
223 }
224 
225 qreal RoutingInstruction::distanceFromStart() const
226 {
227  qreal result = 0.0;
228  const RoutingInstruction* i = predecessor();
229  while ( i ) {
230  result += i->distance();
231  i = i->predecessor();
232  }
233  return result;
234 }
235 
236 qreal RoutingInstruction::distanceToEnd() const
237 {
238  qreal result = distance();
239  const RoutingInstruction* i = successor();
240  while ( i ) {
241  result += i->distance();
242  i = i->successor();
243  }
244  return result;
245 }
246 
247 QString RoutingInstruction::nextRoadInstruction() const
248 {
249  if ( roadType() == "roundabout" ) {
250  return QObject::tr( "Enter the roundabout." );
251  }
252 
253  if ( roadType() == "motorway_link" ) {
254  QStringList motorways = QStringList() << "motorway" << "motorway_link";
255  bool const leaving = predecessor() && motorways.contains( predecessor()->roadType() );
256  if ( leaving ) {
257  if ( roadName().isEmpty() ) {
258  return QObject::tr( "Take the exit." );
259  } else {
260  return QObject::tr( "Take the exit towards %1." ).arg( roadName() );
261  }
262  }
263  if ( roadName().isEmpty() ) {
264  return QObject::tr( "Take the ramp." );
265  } else {
266  return QObject::tr( "Take the ramp towards %1." ).arg( roadName() );
267  }
268  }
269 
270  TurnType turnType = m_turnType;
271  if ( predecessor() && predecessor()->roundaboutExitNumber() ) {
272  switch ( predecessor()->roundaboutExitNumber() ) {
273  case 1:
274  turnType = RoundaboutFirstExit;
275  break;
276  case 2:
277  turnType = RoundaboutSecondExit;
278  break;
279  case 3:
280  turnType = RoundaboutThirdExit;
281  break;
282  }
283  }
284 
285  return generateRoadInstruction( turnType, roadName() );
286 }
287 
288 QString RoutingInstruction::nextDistanceInstruction() const
289 {
290  QLocale::MeasurementSystem const measurement = QLocale::system().measurementSystem();
291  int precision = 0;
292  qreal length = distance();
293  QString distanceUnit = QLatin1String( "m" );
294 
295  if ( measurement != QLocale::MetricSystem ) {
296  precision = 1;
297  distanceUnit = "mi";
298  length /= 1000.0;
299  length /= 1.609344;
300  if ( length < 0.1 ) {
301  length = 10 * qRound( length * 528 );
302  precision = 0;
303  distanceUnit = "ft";
304  }
305  } else {
306  if ( length >= 1000 ) {
307  length /= 1000;
308  distanceUnit = "km";
309  precision = 1;
310  } else if ( length >= 200 ) {
311  length = 50 * qRound( length / 50 );
312  } else if ( length >= 100 ) {
313  length = 25 * qRound( length / 25 );
314  } else {
315  length = 10 * qRound( length / 10 );
316  }
317  }
318 
319  if ( length == 0 ) {
320  return QString();
321  } else {
322  QString text = QObject::tr( "Follow the road for %1 %2." );
323  return text.arg( length, 0, 'f', precision ).arg( distanceUnit );
324  }
325 }
326 
327 QString RoutingInstruction::totalDurationRemaining() const
328 {
329  qreal duration = secondsLeft();
330  QString durationUnit = "sec";
331  int precision = 0;
332  if ( duration >= 60.0 ) {
333  duration /= 60.0;
334  durationUnit = "min";
335  precision = 0;
336  }
337  if ( duration >= 60.0 ) {
338  duration /= 60.0;
339  durationUnit = 'h';
340  precision = 1;
341  }
342 
343  QString text = "Arrival in %1 %2.";
344  return text.arg( duration, 0, 'f', precision ).arg( durationUnit );
345 }
346 
347 QString RoutingInstruction::instructionText() const
348 {
349  QString text = nextRoadInstruction();
350  text += ' ' + nextDistanceInstruction();
351  if ( QCoreApplication::instance()->arguments().contains( "--remaining-duration" ) ) {
352  text += ' ' + totalDurationRemaining();
353  }
354  return text;
355 }
356 
357 QString RoutingInstruction::generateRoadInstruction( RoutingInstruction::TurnType turnType, const QString &roadName )
358 {
359  int roundaboutExit = 0;
360  switch ( turnType ) {
361  case RoundaboutFirstExit:
362  roundaboutExit = 1;
363  break;
364  case RoundaboutSecondExit:
365  roundaboutExit = 2;
366  break;
367  case RoundaboutThirdExit:
368  roundaboutExit = 3;
369  break;
370  default:
371  break;
372  }
373 
374  if ( roundaboutExit > 0 ) {
375  if ( roadName.isEmpty() ) {
376  return QObject::tr( "Take the %1. exit in the roundabout." ).arg( roundaboutExit ); // One sentence
377  } else {
378  QString text = QObject::tr( "Take the %1. exit in the roundabout into %2." ); // One sentence
379  return text.arg( roundaboutExit ).arg( roadName );
380  }
381  }
382 
383  if ( roadName.isEmpty() ) {
384  switch( turnType ) {
385  case Continue:
386  return QObject::tr( "Continue." );
387  case Merge:
388  return QObject::tr( "Merge." );
389  case TurnAround:
390  return QObject::tr( "Turn around." );
391  case SharpLeft:
392  return QObject::tr( "Turn sharp left." );
393  case Left:
394  return QObject::tr( "Turn left." );
395  case SlightLeft:
396  return QObject::tr( "Keep slightly left." );
397  case Straight:
398  return QObject::tr( "Go straight ahead." );
399  case SlightRight:
400  return QObject::tr( "Keep slightly right." );
401  case Right:
402  return QObject::tr( "Turn right." );
403  case SharpRight:
404  return QObject::tr( "Turn sharp right." );
405  case RoundaboutExit:
406  return QObject::tr( "Exit the roundabout." );
407  case Unknown:
408  case RoundaboutFirstExit:
409  case RoundaboutSecondExit:
410  case RoundaboutThirdExit:
411  Q_ASSERT( false && "Internal error: Unknown/Roundabout should have been handled earlier." );
412  return QString();
413  break;
414  case ExitLeft:
415  return QObject::tr( "Take the exit to the left." );
416  case ExitRight:
417  return QObject::tr( "Take the exit to the right." );
418  }
419  } else {
420  switch( turnType ) {
421  case Continue:
422  return QObject::tr( "Continue onto %1." ).arg( roadName );
423  case Merge:
424  return QObject::tr( "Merge onto %1." ).arg( roadName );
425  case TurnAround:
426  return QObject::tr( "Turn around onto %1." ).arg( roadName );
427  case SharpLeft:
428  return QObject::tr( "Turn sharp left on %1." ).arg( roadName );
429  case Left:
430  return QObject::tr( "Turn left into %1." ).arg( roadName );
431  case SlightLeft:
432  return QObject::tr( "Keep slightly left on %1." ).arg( roadName );
433  case Straight:
434  return QObject::tr( "Continue on %1." ).arg( roadName );
435  case SlightRight:
436  return QObject::tr( "Keep slightly right on %1." ).arg( roadName );
437  case Right:
438  return QObject::tr( "Turn right into %1." ).arg( roadName );
439  case SharpRight:
440  return QObject::tr( "Turn sharp right into %1." ).arg( roadName );
441  case RoundaboutExit:
442  return QObject::tr( "Exit the roundabout into %2." ).arg( roadName );
443  case Unknown:
444  case RoundaboutFirstExit:
445  case RoundaboutSecondExit:
446  case RoundaboutThirdExit:
447  Q_ASSERT( false && "Internal error: Unknown/Roundabout should have been handled earlier." );
448  return QString();
449  break;
450  case ExitLeft:
451  return QObject::tr( "Take the exit to the left onto %1." ).arg( roadName );
452  case ExitRight:
453  return QObject::tr( "Take the exit to the right onto %1." ).arg( roadName );
454  }
455  }
456 
457  Q_ASSERT( false && "Internal error: Switch did not handle all cases.");
458  return QString();
459 }
460 
461 QTextStream& operator<<( QTextStream& stream, const RoutingInstruction &i )
462 {
463  stream.setRealNumberPrecision( 8 );
464  if ( i.points().isEmpty() ) {
465  return stream;
466  }
467 
468  if ( QCoreApplication::instance()->arguments().contains( "--dense" ) ) {
469  QVector<RoutingWaypoint> points = i.points();
470  int maxElement = points.size() - ( i.successor() ? 1 : 0 );
471  for ( int j = 0; j < maxElement; ++j ) {
472  stream << points[j].point().lat() << ',';
473  stream << points[j].point().lon() << ',';
474  stream << points[j].junctionTypeRaw() << ',';
475  stream << points[j].roadType() << ',';
476  stream << points[j].secondsRemaining() << ',';
477  if ( !j ) {
478  stream << i.instructionText();
479  }
480  if ( j < maxElement - 1 ) {
481  stream << '\n';
482  }
483  }
484 
485  return stream;
486  }
487 
488  if ( QCoreApplication::instance()->arguments().contains( "--csv" ) ) {
489  stream << i.points().first().point().lat() << ',';
490  stream << i.points().first().point().lon() << ',';
491  } else {
492  QString distanceUnit = "m ";
493  int precision = 0;
494  qreal length = i.distanceFromStart();
495  if ( length >= 1000 ) {
496  length /= 1000;
497  distanceUnit = "km";
498  precision = 1;
499  }
500 
501  QString totalDistance = "[%1 %2] ";
502  stream << totalDistance.arg( length, 3, 'f', precision ).arg( distanceUnit );
503  }
504 
505  stream << i.instructionText();
506 
507  if ( QCoreApplication::instance()->arguments().contains( "--csv" ) && QCoreApplication::instance()->arguments().contains( "--intersection-points" ) ) {
508  foreach( const RoutingPoint &point, i.intersectionPoints() ) {
509  stream << ',' << point.lat() << ',' << point.lon();
510  }
511  }
512 
513  return stream;
514 }
515 
516 int RoutingInstruction::roundaboutExitNumber() const
517 {
518  return m_roundaboutExit;
519 }
520 
521 RoutingInstruction::TurnType RoutingInstruction::turnType() const
522 {
523  return m_turnType;
524 }
525 
526 } // namespace Marble
Marble::RoutingInstruction
Stores data related to one instruction: Road name, angle to predecessor, associated waypoints etc...
Definition: RoutingInstruction.h:29
Marble::RoutingPoint::lat
qreal lat() const
Latitude of the point.
Definition: RoutingPoint.cpp:30
Marble::RoutingWaypoint::roadName
QString roadName() const
OSM name of the road.
Definition: RoutingWaypoint.cpp:58
Marble::RoutingInstruction::distanceFromStart
qreal distanceFromStart() const
The distance from the route start.
Definition: RoutingInstruction.cpp:225
Marble::RoutingInstruction::RoutingInstruction
RoutingInstruction(const RoutingWaypoint &item=RoutingWaypoint())
Constructor.
Definition: RoutingInstruction.cpp:22
angle
double angle(double vec1[3], double vec2[3])
Definition: sgp4ext.cpp:164
Marble::RoutingInstruction::append
bool append(const RoutingWaypoint &item, int angle)
Append data of the given item, returns true if item's street name matches instructions street name...
Definition: RoutingInstruction.cpp:31
Marble::RoutingInstruction::TurnAround
Definition: RoutingInstruction.h:40
Marble::RoutingPoint::lon
qreal lon() const
Longitude of the point.
Definition: RoutingPoint.cpp:25
Marble::RoutingInstruction::Right
Definition: RoutingInstruction.h:38
RoutingInstruction.h
Marble::RoutingInstruction::RoundaboutSecondExit
Definition: RoutingInstruction.h:45
Marble::RoutingInstruction::Left
Definition: RoutingInstruction.h:42
QTextStream::setRealNumberPrecision
void setRealNumberPrecision(int precision)
QStringList::contains
bool contains(const QString &str, Qt::CaseSensitivity cs) const
Marble::RoutingInstruction::TurnType
TurnType
Definition: RoutingInstruction.h:32
QLocale::measurementSystem
MeasurementSystem measurementSystem() const
Marble::RoutingWaypoint::None
Definition: RoutingWaypoint.h:33
QObject::tr
QString tr(const char *sourceText, const char *disambiguation, int n)
Marble::RoutingInstruction::setPredecessor
void setPredecessor(RoutingInstruction *predecessor)
Change the predecessor.
Definition: RoutingInstruction.cpp:193
Marble::RoutingInstruction::turnType
TurnType turnType() const
Definition: RoutingInstruction.cpp:521
QTextStream
Marble::RoutingInstruction::angleToPredecssor
qreal angleToPredecssor() const
The angle between the two turn roads, in radians.
Definition: RoutingInstruction.cpp:178
QLocale::system
QLocale system()
Marble::RoutingInstruction::SharpLeft
Definition: RoutingInstruction.h:41
Marble::RoutingInstruction::generateRoadInstruction
static QString generateRoadInstruction(TurnType turnType, const QString &roadName)
Definition: RoutingInstruction.cpp:357
Marble::RoutingInstruction::roadType
QString roadType() const
OSM type of the road to turn into.
Definition: RoutingInstruction.cpp:69
Marble::RoutingWaypoint::junctionType
JunctionType junctionType() const
Parsed junction type.
Definition: RoutingWaypoint.cpp:38
Marble::RoutingInstruction::RoundaboutFirstExit
Definition: RoutingInstruction.h:44
Marble::RoutingInstruction::RoundaboutThirdExit
Definition: RoutingInstruction.h:46
Marble::RoutingInstruction::Continue
Definition: RoutingInstruction.h:34
Marble::RoutingInstruction::distanceToEnd
qreal distanceToEnd() const
The distance to the route end.
Definition: RoutingInstruction.cpp:236
QString::isEmpty
bool isEmpty() const
Marble::RoutingInstruction::setSuccessor
void setSuccessor(RoutingInstruction *successor)
Change the successor.
Definition: RoutingInstruction.cpp:210
Marble::RoutingInstruction::totalDurationRemaining
QString totalDurationRemaining() const
Formats the instruction (duration to destination) for a human reader.
Definition: RoutingInstruction.cpp:327
Marble::RoutingInstruction::RoundaboutExit
Definition: RoutingInstruction.h:47
QCoreApplication::instance
QCoreApplication * instance()
Marble::RoutingInstruction::roundaboutExitNumber
int roundaboutExitNumber() const
Definition: RoutingInstruction.cpp:516
QString
Marble::RoutingInstruction::intersectionPoints
QVector< RoutingPoint > intersectionPoints() const
Contains the intersection point and points near it on the previous and current road.
Definition: RoutingInstruction.cpp:173
MarbleLocale.h
Marble::RoutingInstruction::roadName
QString roadName() const
Name of the road to turn into.
Definition: RoutingInstruction.cpp:64
QStringList
Marble::RoutingInstruction::SlightRight
Definition: RoutingInstruction.h:37
Marble::RoutingInstruction::points
QVector< RoutingWaypoint > points() const
Waypoints from the last instruction to this instruction.
Definition: RoutingInstruction.cpp:168
Marble::RoutingInstruction::SharpRight
Definition: RoutingInstruction.h:39
Marble::RoutingInstruction::nextDistanceInstruction
QString nextDistanceInstruction() const
Formats the instruction (distance to next instruction) for a human reader.
Definition: RoutingInstruction.cpp:288
Marble::RoutingInstruction::predecessor
RoutingInstruction * predecessor()
Previous turn road.
Definition: RoutingInstruction.cpp:183
Marble::RoutingInstruction::nextRoadInstruction
QString nextRoadInstruction() const
Formats the instruction (road name) for a human reader.
Definition: RoutingInstruction.cpp:247
Marble::RoutingInstruction::secondsLeft
int secondsLeft() const
Estimated number of seconds to the route destination.
Definition: RoutingInstruction.cpp:74
Marble::RoutingInstruction::Straight
Definition: RoutingInstruction.h:36
QVector
Marble::RoutingInstruction::successor
RoutingInstruction * successor()
Next turn road.
Definition: RoutingInstruction.cpp:200
QLatin1String
Marble::RoutingWaypoint::Roundabout
Definition: RoutingWaypoint.h:31
Marble::RoutingInstruction::SlightLeft
Definition: RoutingInstruction.h:43
Marble::RoutingWaypoint::roadType
QString roadType() const
OSM type of the road.
Definition: RoutingWaypoint.cpp:48
Marble::RoutingInstruction::ExitRight
Definition: RoutingInstruction.h:49
Marble::RoutingPoint
There are many Point classes, but this is mine.
Definition: RoutingPoint.h:24
Marble::RoutingInstruction::Merge
Definition: RoutingInstruction.h:35
M_PI
#define M_PI
Definition: GeoDataCoordinates.h:26
Marble::RoutingInstruction::instructionText
QString instructionText() const
Formats the instruction for a human reader.
Definition: RoutingInstruction.cpp:347
Marble::RoutingInstruction::distance
qreal distance() const
The accumulated distance of all waypoints belonging to this instruction.
Definition: RoutingInstruction.cpp:215
Marble::operator<<
QTextStream & operator<<(QTextStream &stream, const RoutingInstruction &i)
Definition: RoutingInstruction.cpp:461
QCoreApplication::arguments
QStringList arguments()
Marble::RoutingInstruction::Unknown
Definition: RoutingInstruction.h:33
QVector::size
int size() const
QString::arg
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
Marble::RoutingWaypoint
Stores one line of gosmore/routino output.
Definition: RoutingWaypoint.h:25
Marble::RoutingInstruction::ExitLeft
Definition: RoutingInstruction.h:48
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:13:41 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

marble

Skip menu "marble"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdeedu API Reference

Skip menu "kdeedu API Reference"
  • Analitza
  •     lib
  • kalgebra
  • kalzium
  •   libscience
  • kanagram
  • kig
  •   lib
  • klettres
  • marble
  • parley
  • rocs
  •   App
  •   RocsCore
  •   VisualEditor
  •   stepcore

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal