libosmscout  0.1
osmscout Namespace Reference

Original source: https://github.com/philipperemy/easy-encryption/blob/master/b64.h licensed under terms of MIT license. More...

Namespaces

 FileDownloaderConfig
 
 oss
 
 ost
 

Classes

class  AbstractRoutingProfile
 
class  AbstractRoutingService
 
class  AccessFeature
 
class  AccessFeatureValue
 
class  AccessRestrictedFeature
 AccessRestriction signals, if there is some access restriction for a given way and a given vehicle. More...
 
class  AccessRestrictedFeatureValue
 
struct  AccumulatorEvent
 
class  Address
 
class  AddressFeature
 
class  AddressFeatureValue
 The address feature stores the house number of an (normally) node or area. More...
 
class  AddressListVisitor
 
class  AddressVisitor
 
class  AdminLevelFeature
 
class  AdminLevelFeatureValue
 
class  AdminRegion
 
class  AdminRegionVisitor
 
class  Area
 Representation of an (complex/multipolygon) area. More...
 
class  AreaAreaIndex
 
class  AreaDataFile
 
class  AreaIndex
 
class  AreaNodeIndex
 
class  AreaRegionSearchResult
 
class  AreaRegionSearchResultEntry
 
class  AreaRouteIndex
 
class  AreaSearchParameter
 
class  AreaWayIndex
 
class  ArrivalEstimateAgent
 
struct  ArrivalEstimateMessage
 
class  AsyncWorker
 Async worker provides simple tool for providing asynchronous method calls. More...
 
class  AvailableMapsModel
 Tree model with maps available by configured providers (see Settings::GetMapProviders). More...
 
class  AvailableMapsModelDir
 Model item representing directory in AvailableMapsModel. More...
 
class  AvailableMapsModelItem
 Abstract model item used in AvailableMapsModel. More...
 
class  AvailableMapsModelMap
 Model item representing map in AvailableMapsModel. More...
 
class  AvailableVoice
 
class  AvailableVoicesModel
 List model with voices available by configured providers (see Settings::GetVoiceProviders). More...
 
class  BasemapDatabase
 
class  BasemapDatabaseParameter
 BasemapDatabase instance initialization parameter to influence the behavior of the db instance. More...
 
class  BatchMapPainter
 
class  BatchMapPainterQt
 
class  Bearing
 
class  BearingAgent
 
struct  BearingChangedMessage
 
class  BorderStyle
 
class  BoundingBoxDataFile
 
class  Breaker
 
class  BridgeFeature
 
class  BuildingFeature
 
class  Cache
 
class  CancelableFuture
 Future provides mechanism to access result of asynchronous computation. More...
 
class  CapStyleEnumAttributeDescriptor
 
struct  CellDimension
 
class  CharacterTexture
 
class  CirclePrimitive
 
class  ClockwiseDirectionFeature
 
class  ClosestRoutableObjectResult
 
class  CmdLineAlternativeFlagArgParser
 
class  CmdLineArgParser
 
class  CmdLineBoolArgParser
 
class  CmdLineFlagArgParser
 
class  CmdLineGeoCoordArgParser
 
class  CmdLineNumberArgParser
 
class  CmdLineParser
 
class  CmdLineParseResult
 
class  CmdLineScanner
 
class  CmdLineStringArgParser
 
class  CmdLineStringListArgParser
 
class  Color
 Representation of a color with red, green and blue value (RGB) and a alpha channel. More...
 
class  ColorFeature
 
class  ColorFeatureValue
 
struct  ConditionalStyle
 
class  ConsoleLogger
 
class  ConsoleProgress
 
class  ConstructionYearFeature
 
class  ConstructionYearFeatureValue
 
class  Consumer
 A specialisation of worker that consumes events from a queue. More...
 
class  ContourLabel
 
class  ContourLabelPositioner
 
struct  ContoursData
 
class  CoordBuffer
 Buffer structure for Vertex2D data. More...
 
class  CoordBufferRange
 Hold a reference to a range of data within a CoordBuffer. More...
 
class  CoordDataFile
 
class  CoverageIndex
 
struct  CurrentSpeedMessage
 
class  DataAgent
 
class  Database
 
class  DatabaseParameter
 Database instance initialization parameter to influence the behavior of the db instance. More...
 
struct  DataBlockSpan
 
class  DataFile
 
class  DataTileCache
 
struct  DBFileOffset
 
struct  DBId
 
class  DBLoadJob
 
class  DBRenderJob
 
class  DebugDatabase
 
class  DebugDatabaseParameter
 
struct  DecodeNumberTemplated
 
struct  DecodeNumberTemplated< false, N >
 
struct  DecodeNumberTemplated< true, N >
 
class  DestinationFeature
 
class  DestinationFeatureValue
 
class  Distance
 
struct  DistanceUnit
 
class  DownloadJob
 Class that provide abstraction for download job of multiple files in sequence. More...
 
class  DragHandler
 
class  DrawPrimitive
 
class  DynamicFeatureLabelReader
 
class  DynamicFeatureReader
 Variant of FeatureReader that is not type set and thus can easier get used in cases where runtime dynamics are required and features are referenced by name and not by type. More...
 
class  Earth
 Some general information regarding the earth. More...
 
class  EleFeature
 
class  EleFeatureValue
 
class  ElevationChartWidget
 
class  ElevationModule
 
struct  ElevationPoint
 
class  ElevationService
 
class  EmbankmentFeature
 
struct  EncodeNumberTemplated
 
struct  EncodeNumberTemplated< false, N >
 
struct  EncodeNumberTemplated< true, N >
 
class  FastestPathRoutingProfile
 
class  Feature
 A feature combines one or multiple tags to build information attribute for a type. More...
 
struct  FeatureFilterData
 
class  FeatureInstance
 An instantiation of a feature for a certain type. More...
 
class  FeatureLabelReader
 
class  FeatureReader
 Helper template class for easy access to flag-like Features. More...
 
class  FeatureValue
 
class  FeatureValueBuffer
 A FeatureValueBuffer is instantiated by an object and holds information about the type of the object, the features and feature values available for the given object. More...
 
class  FeatureValueReader
 Helper template class for easy access to the value of a certain feature for objects of any type. More...
 
struct  Feet
 
class  FileDownloader
 Downloads a file specified by URL. More...
 
class  FileScanner
 
class  FileWriter
 
class  FillStyle
 
class  FillStyleProcessor
 
class  FreeTextSearchRunnable
 
class  FromToFeature
 
class  FromToFeatureValue
 
class  GeoBox
 
class  GeoBoxPartitioner
 Helper class to divide a given GeoBox in multiple equally sized parts. More...
 
class  GeoCoord
 
class  Glyph
 
struct  GPSUpdateMessage
 Message to pass to the NavigationEngine each time gps state has changed. More...
 
class  GradeFeature
 
class  GradeFeatureValue
 
struct  GroundTile
 A single ground tile cell. More...
 
class  HTMLWriter
 
class  IconAnimation
 
class  IconLookup
 
class  IconStyle
 
class  INameLabelProviderFactory
 
class  IndexedDataFile
 
struct  InitializeMessage
 Message send once at the beginning to make sure everything initializes correctly and to make it possible that agents can send messages on initialization. More...
 
class  InputHandler
 
class  InstalledMapsModel
 Model providing access to currently installed maps on device. More...
 
class  InstalledVoicesModel
 Model providing access to currently installed voices on device. More...
 
class  Intersection
 A Intersection is a node, where multiple routeable ways or areas meet. More...
 
class  IOException
 
class  IsInFeature
 
class  IsInFeatureValue
 
class  JumpHandler
 
struct  Kilometer
 
class  Label
 Position independent representation of layouted label. More...
 
class  LabelData
 
class  LabelInstance
 
class  LabelLayouter
 
class  LabelPath
 Helper for rendering labels following some path. More...
 
class  LabelProvider
 
class  LabelProviderFactory
 
class  LabelStyle
 
class  LaneAgent
 
class  LanesFeature
 
class  LanesFeatureValue
 
class  Latch
 This implements a pure C++ Latch providing lock-S (shared) and lock-X (exclusive). More...
 
class  LayerFeature
 
class  LayerFeatureValue
 
class  LineStyle
 
class  Locale
 
class  Location
 
class  LocationAtPlaceDescription
 
class  LocationCoordDescription
 
class  LocationCrossingDescription
 
class  LocationDescription
 
class  LocationDescriptionCandicate
 
class  LocationDescriptionService
 
class  LocationEntry
 
class  LocationFeature
 The location feature stores the location of an (normally) node or area. More...
 
class  LocationFeatureValue
 
class  LocationFormSearchParameter
 
class  LocationIndex
 
class  LocationInfoModel
 
class  LocationListModel
 Model for searching objects in osmscout databases by pattern written by human. More...
 
class  LocationSearchResult
 
class  LocationService
 
class  LocationStringSearchParameter
 
class  LocationVisitor
 
class  LocationWayDescription
 
class  LockHandler
 
class  Log
 
class  Logger
 
class  LookupModule
 
class  Magnification
 
class  MagnificationConverter
 
class  MagnificationLevel
 
class  MapData
 
class  MapDownloader
 Manager of map databases. More...
 
class  MapDownloadJob
 Utility class for downloading map db described by AvailableMapsModelMap over http. More...
 
class  MapDownloadsModel
 QML list model with currently downloaded maps. More...
 
struct  MapIcon
 
class  MapObjectInfoModel
 
class  MapOverlay
 
class  MapPainter
 Abstract base class of all renders (though you can always write your own renderer without inheriting from this class) It implements the general rendering algorithm. More...
 
class  MapPainterAgg
 
class  MapPainterCairo
 
class  MapPainterNoOp
 
class  MapPainterOpenGL
 
class  MapPainterQt
 Implementation of MapPainter for Qt. More...
 
class  MapPainterStatistics
 
class  MapPainterSVG
 
class  MapParameter
 
class  MapRenderer
 
class  MapService
 
class  MapStyleModel
 
class  MapTile
 
class  MapTileCache
 
class  MapView
 
class  MapWidget
 
class  Mask
 
struct  MaxAllowedSpeedMessage
 
class  MaxSpeedFeature
 
class  MaxSpeedFeatureValue
 
class  MemoryMonitor
 Starts a background thread that checks every 200ms the current memory usage of the current process and accumulates it to return the maximum memory usage since start or reset. More...
 
class  MercatorProjection
 Mercator projection that tries to render the resulting map in the same physical size on all devices. More...
 
class  Meter
 
struct  Mile
 
class  MoveAccumulator
 
class  MoveHandler
 
class  MultiDBRoutingService
 
class  MultiDBRoutingState
 
class  MultitouchHandler
 
class  NameAltFeature
 
class  NameAltFeatureValue
 
class  NameFeature
 
class  NameFeatureValue
 
class  NameShortFeature
 
class  NameShortFeatureValue
 
class  Navigation
 
class  NavigationAgent
 
class  NavigationEngine
 
struct  NavigationMessage
 Base class for all navigation messages. More...
 
class  NavigationModel
 Model providing navigation functionality to QML. More...
 
class  NavigationModule
 
class  NearPOIModel
 
class  NetworkFeature
 
class  NetworkFeatureValue
 
struct  NextRouteInstructionsMessage
 
class  Node
 
class  NodeDataFile
 
class  NodeRegionSearchResult
 
class  NodeRegionSearchResultEntry
 
class  NodeUseMap
 
class  NoOpLogger
 
class  NumberSet
 
class  NumericIndex
 
class  ObjectFileRef
 Reference to an libosmscout internal object by its type (area, way, node) and by its file offset within its data file. More...
 
class  ObjectFileRefByFileOffsetComparator
 Comparator to sort ObjectFileRefs strictly by increasing file offset. More...
 
class  ObjectFileRefStreamReader
 Read back a stream of sorted ObjectFileRefs as written by the ObjectFileRefStreamWriter. More...
 
class  ObjectFileRefStreamWriter
 Efficiently (in disk space handling) write a number of (sorted by file offset) ObjectFileRefs. More...
 
struct  ObjectKey
 
class  ObjectOSMRef
 Reference to an OSM object by its type (Node, Way, Relation) and its OSM object id. More...
 
class  ObjectPool
 
struct  ObjectVariantData
 
class  ObjectVariantDataFile
 
class  OffsetRelAttributeDescriptor
 
class  OnlineTileProviderModel
 
class  OpenGLMapData
 
class  OpenGLProjection
 
class  OpenGLTexture
 
class  OpeningHours
 Utility for parsing simple OpenStreetMap opening hours. More...
 
class  OpeningHoursFeature
 
class  OpeningHoursFeatureValue
 
class  OpeningHoursModel
 
class  OperatorFeature
 
class  OperatorFeatureValue
 
class  OptimizeAreasLowZoom
 
class  OptimizeWaysLowZoom
 
class  OSMScoutException
 
class  OSMScoutQt
 
class  OSMScoutQtBuilder
 
class  OSMTile
 
class  OsmTileDownloader
 
class  OSMTileId
 
class  OSMTileIdBox
 
class  OSMTileIdBoxConstIterator
 
class  OutputDescription
 
class  OverlayArea
 
class  OverlayNode
 
class  OverlayObject
 
class  OverlayWay
 
struct  PartialStyle
 
struct  PartialStyleBase
 
class  Path
 
struct  PathIntersection
 
class  PathLabelData
 
class  PathShieldStyle
 
class  PathSymbolStyle
 
class  PathTextStyle
 
class  PersistentCookieJar
 
class  PhoneFeature
 
class  PhoneFeatureValue
 
class  Pipe
 A specialisation of worker. More...
 
struct  Pixel
 
class  Place
 
class  PlaneMapRenderer
 
class  POI
 
class  POIFormSearchParameter
 
class  Point
 
class  POIService
 
class  POIVisitor
 
class  PolygonMerger
 
class  PolygonPrimitive
 
class  PositionAgent
 This agent pin position of vehicle to most probable routable object. More...
 
class  PostalArea
 
class  PostalCodeFeature
 
class  PostalCodeFeatureValue
 
class  ProcessingQueue
 A ProcessingQueue is a special multi-threaded safe implementation of a queue. More...
 
class  Producer
 A specialisation of Worker. More...
 
class  Progress
 
class  Projection
 
class  PTRoute
 
class  PTRouteDataFile
 
class  QmlRoutingProfile
 Routing profile. More...
 
class  QmlSettings
 
class  QtRouteData
 Representation of computed route. More...
 
class  QtSettingsStorage
 
class  ReadLock
 
struct  Rectangle
 
class  RectanglePrimitive
 
class  RefFeature
 
class  RefFeatureValue
 
class  RenderModeEnumAttributeDescriptor
 
struct  RequestState
 
struct  RerouteRequestMessage
 Message created when we should compute new route. More...
 
class  RoundaboutFeature
 
struct  RoutableDBObjects
 
struct  RoutableObjects
 
struct  RoutableObjectsMessage
 Message to pass to the NavigationEngine with routable objects around current possition. More...
 
struct  RoutableObjectsRequestMessage
 
class  Route
 Representation of route. More...
 
class  RouteData
 
class  RouteDataFile
 
class  RouteDescription
 
class  RouteDescriptionBuilder
 
class  RouteDescriptionPostprocessor
 The RouteDescriptionPostprocessor does all the heavy lifting of creating the various available Postprocessors, evaluate their feedback and map it onto a set of real-life situation callback methods. More...
 
class  RouteDescriptionResult
 
class  RouteInstructionAgent
 
struct  RouteInstructionsMessage
 
class  RouteNode
 
class  RouteNodeDataFile
 
struct  RoutePoints
 
class  RoutePointsResult
 
class  RoutePosition
 
class  RoutePositionResult
 
class  RoutePostprocessor
 
class  Router
 
class  RouterParameter
 
class  RouteStateAgent
 
class  RouteStep
 Human representation of route step commands. More...
 
struct  RouteUpdateMessage
 Message to pass to the NavigationEngine each time the calculated route changes. More...
 
class  RouteWayResult
 
class  RoutingDatabase
 
class  RoutingListModel
 
class  RoutingParameter
 
class  RoutingProfile
 
class  RoutingProgress
 
class  RoutingResult
 Result of a routing calculation. More...
 
class  RoutingService
 
struct  ScanCell
 
class  ScopeGuard
 ScopeGuard utility calls its constructor parameter (callable type) in it's destructor (on the end of the scope) More...
 
class  ScreenBox
 
class  SearchLocationsRunnable
 
class  SearchModule
 
class  SearchRunnable
 
struct  Segment
 
struct  SegmentGeoBox
 
class  ShieldStyle
 
class  ShortestPathRoutingProfile
 
class  SidewayFeature
 
class  SidewayFeatureValue
 
class  Signal
 Signal and Slot is tool for connecting source of events and its consumers. More...
 
class  SilentProgress
 
class  SilentTagErrorReporter
 
class  SimpleRoutingService
 
class  SizeCondition
 
class  Slot
 
class  SpeedAgent
 
struct  SpeedVariant
 
class  SRTM
 Read elevation data in hgt format. More...
 
class  SRTMData
 
class  StopClock
 
class  StopClockNano
 Copy of the StopClock implementation but using a high_resolution timer and by default return nano seconds. More...
 
class  StreamLogger
 
class  StringMatcher
 
class  StringMatcherCI
 
class  StringMatcherCIFactory
 
class  StringMatcherFactory
 
class  StringMatcherTransliterate
 
class  StringMatcherTransliterateFactory
 
struct  StringToNumberTemplated
 
struct  StringToNumberTemplated< false, N >
 
struct  StringToNumberTemplated< true, N >
 
class  Style
 
class  StyleAttributeDescriptor
 
class  StyleBoolAttributeDescriptor
 
class  StyleColorAttributeDescriptor
 
class  StyleConfig
 Index selectors by type and level. More...
 
class  StyleConstant
 
class  StyleConstantColor
 
class  StyleConstantMag
 
class  StyleConstantUInt
 
class  StyleConstantWidth
 
class  StyleCriteria
 
class  StyleDescriptor
 
class  StyleDisplayAttributeDescriptor
 
class  StyleDoubleAttributeDescriptor
 
class  StyleEnumAttributeDescriptor
 
class  StyleError
 
class  StyleFilter
 
class  StyleFlagsModel
 
class  StyleIntAttributeDescriptor
 
class  StyleLabelAttributeDescriptor
 
class  StyleMagnificationAttributeDescriptor
 
class  StyleMapAttributeDescriptor
 
class  StyleModule
 
class  StyleResolveContext
 
struct  StyleSelector
 
class  StyleStringAttributeDescriptor
 
class  StyleSymbolAttributeDescriptor
 
class  StyleUDisplayAttributeDescriptor
 
class  StyleUDoubleArrayAttributeDescriptor
 
class  StyleUDoubleAttributeDescriptor
 
class  StyleUIntAttributeDescriptor
 
class  StyleUMapAttributeDescriptor
 
class  StyleVoidAttributeDescriptor
 
class  SunriseSunset
 
class  Symbol
 
class  SymbolRenderer
 
class  SymbolRendererCairo
 
class  SymbolRendererQt
 
class  TagBinaryCondition
 
class  TagBoolCondition
 
class  TagCondition
 
class  TagErrorReporter
 
class  TagExistsCondition
 
class  TagInfo
 
class  TagIsInCondition
 
class  TagNotCondition
 
class  TagRegistry
 
class  TapRecognizer
 
struct  TargetReachedMessage
 
class  TextLoader
 
class  TextSearchIndex
 
class  TextStyle
 
class  TextStyleEnumAttributeDescriptor
 
class  ThreadedBreaker
 
class  ThreadedWorker
 A single threaded agent. More...
 
class  Tile
 
class  TileCache
 
struct  TileCacheKey
 
struct  TileCacheVal
 
class  TileData
 
class  TiledMapOverlay
 
class  TiledMapRenderer
 
class  TiledRenderingHelper
 
class  TileId
 
class  TileIdBox
 
class  TileIdBoxConstIterator
 
struct  TileIdHasher
 Hasher that can be used in std::unordered_map with TileId as a key. More...
 
class  TileKey
 
class  TileLoaderThread
 
class  TileProjection
 Mercator projection as used by the OpenStreetMap tile rendering code. More...
 
struct  TimeTickMessage
 Message to pass periodically to the Engine to make sure that state changes based on timeouts are triggered. More...
 
class  TransBuffer
 Temporary stateful buffer for holding results of transformation of polygon from geo coords to display coords. More...
 
struct  TransPoint
 Entry in the TransBuffer structure. More...
 
class  TransPolygon
 Class to allows transformation of geometric primitives form geo coordinate to display coordinates using the passed Projection instance. More...
 
class  Triangulate
 
class  TunnelFeature
 
class  TurnRestriction
 
class  TypeConfig
 
class  TypeDistributionDataFile
 
class  TypeInfo
 
class  TypeInfoSet
 Custom data structure to efficiently handle a set of TypeInfoRef. More...
 
class  TypeInfoSetConstIterator
 
class  UninitializedException
 
class  VehicleFollowHandler
 
class  VehiclePosition
 
class  Vertex2D
 
class  Vertex3D
 
class  Voice
 Holder for voice metadata. More...
 
class  VoiceDownloadJob
 Utility class for downloading voice described by AvailableVoice over http. More...
 
class  VoiceInstructionAgent
 This agent prepares voice messages for concatenation voice synthesis. More...
 
struct  VoiceInstructionMessage
 
class  VoiceManager
 Manager of voices for navigation commands. More...
 
class  WaterIndex
 
class  Way
 
class  WayDataFile
 
class  WayRegionSearchResult
 
class  WayRegionSearchResultEntry
 
class  WebsiteFeature
 
class  WebsiteFeatureValue
 
class  WidthFeature
 
class  WidthFeatureValue
 
class  WorkQueue
 
class  WriteLock
 
struct  Yard
 
class  ZoomGestureHandler
 

Typedefs

using AccessFeatureValueReader = FeatureValueReader< AccessFeature, AccessFeatureValue >
 
using AccessRestrictedFeatureReader = FeatureReader< AccessRestrictedFeature >
 
using AccessRestrictedFeatureValueReader = FeatureValueReader< AccessRestrictedFeature, AccessRestrictedFeatureValue >
 
using AddressFeatureValueReader = FeatureValueReader< AddressFeature, AddressFeatureValue >
 
using AddressRef = std::shared_ptr< Address >
 
using AdminLevelFeatureValueReader = FeatureValueReader< AdminLevelFeature, AdminLevelFeatureValue >
 
using AdminRegionRef = std::shared_ptr< AdminRegion >
 
using AreaAreaIndexRef = std::shared_ptr< AreaAreaIndex >
 
using AreaDataFileRef = std::shared_ptr< AreaDataFile >
 
using AreaNodeIndexRef = std::shared_ptr< AreaNodeIndex >
 
using AreaRef = std::shared_ptr< Area >
 
using AreaRouteIndexRef = std::shared_ptr< AreaRouteIndex >
 
using AreaWayIndexRef = std::shared_ptr< AreaWayIndex >
 
using BasemapDatabaseRef = std::shared_ptr< BasemapDatabase >
 Reference counted reference to an Database instance. More...
 
using BorderConditionalStyle = ConditionalStyle< BorderStyle, BorderStyle::Attribute >
 
using BorderPartialStyle = PartialStyle< BorderStyle, BorderStyle::Attribute >
 Index selectors by type and level. More...
 
using BorderStyleLookupTable = std::vector< std::vector< BorderStyleSelectorList > >
 List of selectors. More...
 
using BorderStyleRef = std::shared_ptr< BorderStyle >
 
using BorderStyleSelector = StyleSelector< BorderStyle, BorderStyle::Attribute >
 
using BorderStyleSelectorList = std::list< BorderStyleSelector >
 
using BoundingBoxDataFileRef = std::shared_ptr< BoundingBoxDataFile >
 
using BreakerRef = std::shared_ptr< Breaker >
 
using BridgeFeatureReader = FeatureReader< BridgeFeature >
 
typedef std::shared_ptr< CharacterTextureCharacterTextureRef
 
using CirclePrimitiveRef = std::shared_ptr< CirclePrimitive >
 
using ClockwiseDirectionFeatureReader = FeatureReader< ClockwiseDirectionFeature >
 
using CmdLineArgParserRef = std::shared_ptr< CmdLineArgParser >
 
using ColorFeatureValueReader = FeatureValueReader< ColorFeature, ColorFeatureValue >
 
using ColorPostprocessor = osmscout::Color(*)(const osmscout::Color &)
 
using ConstructionYearFeatureValueReader = FeatureValueReader< ConstructionYearFeature, ConstructionYearFeatureValue >
 
using CoverageIndexRef = std::shared_ptr< CoverageIndex >
 
using DatabaseId = uint32_t
 
using DatabaseRef = std::shared_ptr< Database >
 Reference counted reference to an Database instance. More...
 
using DestinationFeatureValueReader = FeatureValueReader< DestinationFeature, DestinationFeatureValue >
 
using DistanceUnitPtr = std::shared_ptr< DistanceUnit >
 
using DoubleRectangle = Rectangle< double >
 
using DrawPrimitiveRef = std::shared_ptr< DrawPrimitive >
 
using Duration = Timestamp::duration
 
using EleFeatureValueReader = FeatureValueReader< EleFeature, EleFeatureValue >
 
using EmbankmentFeatureReader = FeatureReader< EmbankmentFeature >
 
using FastestPathRoutingProfileRef = std::shared_ptr< FastestPathRoutingProfile >
 
using FeatureRef = std::shared_ptr< Feature >
 
using FeatureValueBufferRef = std::shared_ptr< FeatureValueBuffer >
 
using FileOffset = uint64_t
 
using FillConditionalStyle = ConditionalStyle< FillStyle, FillStyle::Attribute >
 
using FillPartialStyle = PartialStyle< FillStyle, FillStyle::Attribute >
 Index selectors by type and level. More...
 
using FillStyleLookupTable = std::vector< std::vector< FillStyleSelectorList > >
 List of selectors. More...
 
using FillStyleProcessorRef = std::shared_ptr< FillStyleProcessor >
 
using FillStyleRef = std::shared_ptr< FillStyle >
 
using FillStyleSelector = StyleSelector< FillStyle, FillStyle::Attribute >
 
using FillStyleSelectorList = std::list< FillStyleSelector >
 
using FromToFeatureValueReader = FeatureValueReader< FromToFeature, FromToFeatureValue >
 
using GradeFeatureValueReader = FeatureValueReader< GradeFeature, GradeFeatureValue >
 
using HourDuration = std::chrono::duration< double, std::ratio< 3600 > >
 
using IconConditionalStyle = ConditionalStyle< IconStyle, IconStyle::Attribute >
 
using IconLookupRef = std::shared_ptr< IconLookup >
 
using IconPartialStyle = PartialStyle< IconStyle, IconStyle::Attribute >
 Index selectors by type and level. More...
 
using IconStyleLookupTable = std::vector< std::vector< IconStyleSelectorList > >
 List of selectors. More...
 
using IconStyleRef = std::shared_ptr< IconStyle >
 
using IconStyleSelector = StyleSelector< IconStyle, IconStyle::Attribute >
 
using IconStyleSelectorList = std::list< IconStyleSelector >
 
using Id = uint64_t
 
using IntRectangle = Rectangle< int >
 
using IsInFeatureValueReader = FeatureValueReader< IsInFeature, IsInFeatureValue >
 
using JunctionRef = std::shared_ptr< Intersection >
 
using LabelProviderFactoryRef = std::shared_ptr< LabelProviderFactory >
 
using LabelProviderRef = std::shared_ptr< LabelProvider >
 
using LabelStyleRef = std::shared_ptr< LabelStyle >
 
using LanesFeatureValueReader = FeatureValueReader< LanesFeature, LanesFeatureValue >
 
using LayerFeatureValueReader = FeatureValueReader< LayerFeature, LayerFeatureValue >
 
using LineConditionalStyle = ConditionalStyle< LineStyle, LineStyle::Attribute >
 
using LinePartialStyle = PartialStyle< LineStyle, LineStyle::Attribute >
 
using LineStyleLookupTable = std::vector< std::vector< LineStyleSelectorList > >
 List of selectors. More...
 
using LineStyleRef = std::shared_ptr< LineStyle >
 
using LineStyleSelector = StyleSelector< LineStyle, LineStyle::Attribute >
 
using LineStyleSelectorList = std::list< LineStyleSelector >
 
using LocationAtPlaceDescriptionRef = std::shared_ptr< LocationAtPlaceDescription >
 
using LocationCoordDescriptionRef = std::shared_ptr< LocationCoordDescription >
 
using LocationCrossingDescriptionRef = std::shared_ptr< LocationCrossingDescription >
 
using LocationDescriptionServiceRef = std::shared_ptr< LocationDescriptionService >
 
using LocationEntryRef = std::shared_ptr< LocationEntry >
 
using LocationFeatureValueReader = FeatureValueReader< LocationFeature, LocationFeatureValue >
 
using LocationIndexRef = std::shared_ptr< LocationIndex >
 
using LocationRef = std::shared_ptr< Location >
 
using LocationServiceRef = std::shared_ptr< LocationService >
 
using LocationWayDescriptionRef = std::shared_ptr< LocationWayDescription >
 
typedef std::shared_ptr< LookupModuleLookupModuleRef
 
using MapDataRef = std::shared_ptr< MapData >
 
using MapDownloaderRef = std::shared_ptr< MapDownloader >
 
using MapRendererRef = std::shared_ptr< MapRenderer >
 
using MapServiceRef = std::shared_ptr< MapService >
 
typedef std::shared_ptr< MapTileMapTileRef
 
using MaxSpeedFeatureValueReader = FeatureValueReader< MaxSpeedFeature, MaxSpeedFeatureValue >
 
using MilliDouble = std::chrono::duration< double, std::milli >
 
using MultiDBRoutingServiceRef = std::shared_ptr< MultiDBRoutingService >
 
using NameAltFeatureValueReader = FeatureValueReader< NameAltFeature, NameAltFeatureValue >
 
using NameFeatureLabelReader = FeatureLabelReader< NameFeature, NameFeatureValue >
 
using NameFeatureValueReader = FeatureValueReader< NameFeature, NameFeatureValue >
 
using NameShortFeatureValueReader = FeatureValueReader< NameShortFeature, NameShortFeatureValue >
 
using NanoDouble = std::chrono::duration< double, std::nano >
 
using NavigationAgentRef = std::shared_ptr< NavigationAgent >
 
using NavigationMessageRef = std::shared_ptr< NavigationMessage >
 
using NetworkFeatureValueReader = FeatureValueReader< NetworkFeature, NetworkFeatureValue >
 
using NodeDataFileRef = std::shared_ptr< NodeDataFile >
 
using NodeRef = std::shared_ptr< Node >
 
typedef std::shared_ptr< OpenGLTextureOpenGLTextureRef
 
using OperatorFeatureValueReader = FeatureValueReader< OperatorFeature, OperatorFeatureValue >
 
using OptimizeAreasLowZoomRef = std::shared_ptr< OptimizeAreasLowZoom >
 
using OptimizeWaysLowZoomRef = std::shared_ptr< OptimizeWaysLowZoom >
 
using OSMId = int64_t
 
using OSMScoutQtBuilderRef = std::shared_ptr< OSMScoutQtBuilder >
 
using OverlayObjectRef = std::shared_ptr< OverlayObject >
 
using PageId = uint64_t
 
using PathShieldConditionalStyle = ConditionalStyle< PathShieldStyle, PathShieldStyle::Attribute >
 
using PathShieldPartialStyle = PartialStyle< PathShieldStyle, PathShieldStyle::Attribute >
 Index selectors by type and level. More...
 
using PathShieldStyleLookupTable = std::vector< std::vector< PathShieldStyleSelectorList > >
 List of selectors. More...
 
using PathShieldStyleRef = std::shared_ptr< PathShieldStyle >
 
using PathShieldStyleSelector = StyleSelector< PathShieldStyle, PathShieldStyle::Attribute >
 
using PathShieldStyleSelectorList = std::list< PathShieldStyleSelector >
 
using PathSymbolConditionalStyle = ConditionalStyle< PathSymbolStyle, PathSymbolStyle::Attribute >
 
using PathSymbolPartialStyle = PartialStyle< PathSymbolStyle, PathSymbolStyle::Attribute >
 Index selectors by type and level. More...
 
using PathSymbolStyleLookupTable = std::vector< std::vector< PathSymbolStyleSelectorList > >
 List of selectors. More...
 
using PathSymbolStyleRef = std::shared_ptr< PathSymbolStyle >
 
using PathSymbolStyleSelector = StyleSelector< PathSymbolStyle, PathSymbolStyle::Attribute >
 
using PathSymbolStyleSelectorList = std::list< PathSymbolStyleSelector >
 
using PathTextConditionalStyle = ConditionalStyle< PathTextStyle, PathTextStyle::Attribute >
 
using PathTextPartialStyle = PartialStyle< PathTextStyle, PathTextStyle::Attribute >
 Index selectors by type and level. More...
 
using PathTextStyleLookupTable = std::vector< std::vector< PathTextStyleSelectorList > >
 List of selectors. More...
 
using PathTextStyleRef = std::shared_ptr< PathTextStyle >
 
using PathTextStyleSelector = StyleSelector< PathTextStyle, PathTextStyle::Attribute >
 
using PathTextStyleSelectorList = std::list< PathTextStyleSelector >
 
using POIRef = std::shared_ptr< POI >
 
using POIServiceRef = std::shared_ptr< POIService >
 
using Polygon = std::vector< const Ring * >
 
using PolygonPrimitiveRef = std::shared_ptr< PolygonPrimitive >
 
using PostalAreaRef = std::shared_ptr< PostalArea >
 
using PostalCodeFeatureValueReader = FeatureValueReader< PostalCodeFeature, PostalCodeFeatureValue >
 
using PTRouteDataFileRef = std::shared_ptr< PTRouteDataFile >
 
using PTRouteRef = std::shared_ptr< PTRoute >
 
using QmlRoutingProfileRef = std::shared_ptr< QmlRoutingProfile >
 
using QtGlyph = Glyph< QGlyphRun >
 
using QtLabel = Label< QGlyphRun, QTextLayout >
 
using QtLabelInstance = LabelInstance< QGlyphRun, QTextLayout >
 
using QtMediaPlayerState = QMediaPlayer::PlaybackState
 
using RectanglePrimitiveRef = std::shared_ptr< RectanglePrimitive >
 
using RefFeatureLabelReader = FeatureLabelReader< RefFeature, RefFeatureValue >
 
using RefFeatureValueReader = FeatureValueReader< RefFeature, RefFeatureValue >
 
using Ring = std::vector< Point >
 
using RoundaboutFeatureReader = FeatureReader< RoundaboutFeature >
 
using RoutableObjectsMessageRef = std::shared_ptr< RoutableObjectsMessage >
 
using RoutableObjectsRef = std::shared_ptr< RoutableObjects >
 
using RouteDataFileRef = std::shared_ptr< RouteDataFile >
 
using RouteDescriptionRef = std::shared_ptr< RouteDescription >
 
using RouteNodeRef = std::shared_ptr< RouteNode >
 
using RoutePointsRef = std::shared_ptr< RoutePoints >
 
using RouteRef = std::shared_ptr< Route >
 
using RoutingDatabaseRef = std::shared_ptr< RoutingDatabase >
 
using RoutingProfileRef = std::shared_ptr< RoutingProfile >
 
using RoutingProgressRef = std::shared_ptr< RoutingProgress >
 
using ShieldConditionalStyle = ConditionalStyle< ShieldStyle, ShieldStyle::Attribute >
 
using ShieldPartialStyle = PartialStyle< ShieldStyle, ShieldStyle::Attribute >
 Index selectors by type and level. More...
 
using ShieldStyleLookupTable = std::vector< std::vector< ShieldStyleSelectorList > >
 List of selectors. More...
 
using ShieldStyleRef = std::shared_ptr< ShieldStyle >
 
using ShieldStyleSelector = StyleSelector< ShieldStyle, ShieldStyle::Attribute >
 
using ShieldStyleSelectorList = std::list< ShieldStyleSelector >
 
using ShortestPathRoutingProfileRef = std::shared_ptr< ShortestPathRoutingProfile >
 
using SimpleRoutingServiceRef = std::shared_ptr< SimpleRoutingService >
 
using SizeConditionRef = std::shared_ptr< SizeCondition >
 
using SRTMDataRef = std::shared_ptr< SRTMData >
 
using SRTMRef = std::shared_ptr< SRTM >
 
using StringMatcherFactoryRef = std::shared_ptr< StringMatcherFactory >
 
using StringMatcherRef = std::shared_ptr< StringMatcher >
 
using StyleAttributeDescriptorRef = std::shared_ptr< StyleAttributeDescriptor >
 
using StyleConfigRef = std::shared_ptr< StyleConfig >
 
using StyleConstantRef = std::shared_ptr< StyleConstant >
 
using StyleDescriptorRef = std::shared_ptr< StyleDescriptor >
 
using StyleModuleRef = std::shared_ptr< StyleModule >
 
using SunriseSunsetRes = std::optional< std::tuple< Timestamp, Timestamp > >
 
using SymbolRef = std::shared_ptr< Symbol >
 
using TagBoolConditionRef = std::shared_ptr< TagBoolCondition >
 
using TagConditionRef = std::shared_ptr< TagCondition >
 
using TagId = uint16_t
 
using TagIsInConditionRef = std::shared_ptr< TagIsInCondition >
 
using TagMap = std::unordered_map< TagId, std::string >
 
using TextConditionalStyle = ConditionalStyle< TextStyle, TextStyle::Attribute >
 
using TextPartialStyle = PartialStyle< TextStyle, TextStyle::Attribute >
 Index selectors by type and level. More...
 
using TextStyleLookupTable = std::vector< std::vector< TextStyleSelectorList > >
 List of selectors. More...
 
using TextStyleRef = std::shared_ptr< TextStyle >
 
using TextStyleSelector = StyleSelector< TextStyle, TextStyle::Attribute >
 
using TextStyleSelectorList = std::list< TextStyleSelector >
 
using TileAreaData = TileData< AreaRef >
 
using TiledDataCacheRef = std::shared_ptr< DataTileCache >
 
using TileNodeData = TileData< NodeRef >
 
using TileRef = std::shared_ptr< Tile >
 
using TileRouteData = TileData< RouteRef >
 
using TileWayData = TileData< WayRef >
 
using Timestamp = std::chrono::system_clock::time_point
 
typedef std::shared_ptr< TokenString > TokenStringRef
 
using TunnelFeatureReader = FeatureReader< TunnelFeature >
 
using TurnRestrictionRef = std::shared_ptr< TurnRestriction >
 
using TypeConfigRef = std::shared_ptr< TypeConfig >
 
using TypeDistributionDataFileRef = std::shared_ptr< TypeDistributionDataFile >
 
using TypeId = uint16_t
 
using TypeInfoRef = std::shared_ptr< TypeInfo >
 
using VehicleMask = uint8_t
 
using VoiceManagerRef = std::shared_ptr< VoiceManager >
 
using WaterIndexRef = std::shared_ptr< WaterIndex >
 
using WayDataFileRef = std::shared_ptr< WayDataFile >
 
using WayRef = std::shared_ptr< Way >
 
using WidthFeatureValueReader = FeatureValueReader< WidthFeature, WidthFeatureValue >
 

Enumerations

enum  BinaryOperator {
  operatorLess, operatorLessEqual, operatorEqual, operatorGreaterEqual,
  operatorGreater, operatorNotEqual
}
 Enumeration of possible binary operators as used by the various parsers. More...
 
enum  DistanceUnitSystem { DistanceUnitSystem::Metrics, DistanceUnitSystem::Imperial }
 
enum  Grade : uint8_t {
  SolidGrade = 1, GravelGrade = 2, UnpavedGrade = 3, MostlySoftGrade = 4,
  SoftGrade = 5
}
 
enum  LaneTurn : std::uint8_t {
  LaneTurn::Null = 0, LaneTurn::None = 1, LaneTurn::Left = 2, LaneTurn::MergeToLeft = 3,
  LaneTurn::SlightLeft = 4, LaneTurn::SharpLeft = 5, LaneTurn::Through_Left = 6, LaneTurn::Through_SlightLeft = 7,
  LaneTurn::Through_SharpLeft = 8, LaneTurn::Through = 9, LaneTurn::Through_Right = 10, LaneTurn::Through_SlightRight = 11,
  LaneTurn::Through_SharpRight = 12, LaneTurn::Right = 13, LaneTurn::MergeToRight = 14, LaneTurn::SlightRight = 15,
  LaneTurn::SharpRight = 16, LaneTurn::Unknown = 17
}
 
enum  OffsetRel : int {
  OffsetRel::base, OffsetRel::leftOutline, OffsetRel::rightOutline, OffsetRel::laneDivider,
  OffsetRel::laneForwardLeft, OffsetRel::laneForwardThroughLeft, OffsetRel::laneForwardThrough, OffsetRel::laneForwardThroughRight,
  OffsetRel::laneForwardRight, OffsetRel::laneBackwardLeft, OffsetRel::laneBackwardThroughLeft, OffsetRel::laneBackwardThrough,
  OffsetRel::laneBackwardThroughRight, OffsetRel::laneBackwardRight, OffsetRel::sidecar
}
 Offset for rendered line, relative to way. More...
 
enum  OSMRefType { osmRefNone = 0, osmRefNode = 1, osmRefWay = 2, osmRefRelation = 3 }
 
enum  RefType { refNone = 0, refNode = 1, refArea = 2, refWay = 3 }
 
enum  RenderingType { PlaneRendering = 0, TiledRendering = 1 }
 
enum  RenderSteps : size_t {
  FirstStep = 0, Initialize = 0, DumpStatistics = 1, CalculatePaths = 2,
  CalculateWayShields = 3, ProcessAreas = 4, ProcessRoutes = 5, AfterPreprocessing = 6,
  Prerender = 7, DrawBaseMapTiles = 8, DrawGroundTiles = 9, DrawOSMTileGrids = 10,
  DrawAreas = 11, DrawWays = 12, DrawWayDecorations = 13, DrawWayContourLabels = 14,
  PrepareAreaLabels = 15, DrawAreaBorderLabels = 16, DrawAreaBorderSymbols = 17, PrepareNodeLabels = 18,
  PrepareRouteLabels = 19, DrawContourLines = 20, DrawHillShading = 21, DrawLabels = 22,
  Postrender = 23, LastStep = 23
}
 
enum  StyleAttributeType {
  StyleAttributeType::TYPE_VOID, StyleAttributeType::TYPE_BOOL, StyleAttributeType::TYPE_STRING, StyleAttributeType::TYPE_COLOR,
  StyleAttributeType::TYPE_MAGNIFICATION, StyleAttributeType::TYPE_ENUM, StyleAttributeType::TYPE_DISPLAY_SIZE, StyleAttributeType::TYPE_UDISPLAY_SIZE,
  StyleAttributeType::TYPE_MAP_SIZE, StyleAttributeType::TYPE_UMAP_SIZE, StyleAttributeType::TYPE_DOUBLE, StyleAttributeType::TYPE_UDOUBLE,
  StyleAttributeType::TYPE_UDOUBLE_ARRAY, StyleAttributeType::TYPE_INT, StyleAttributeType::TYPE_UINT, StyleAttributeType::TYPE_LABEL,
  StyleAttributeType::TYPE_SYMBOL
}
 
enum  Vehicle : uint8_t { vehicleFoot = 1u << 1u, vehicleBicycle = 1u << 2u, vehicleCar = 1u << 3u }
 

Functions

static void AddAddressResult (const SearchParameter &parameter, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult::MatchQuality postalAreaMatchQuality, LocationSearchResult::MatchQuality locationMatchQuality, const AddressSearchVisitor::Result &addressMatch, LocationSearchResult::MatchQuality addressMatchQuality, LocationSearchResult &result)
 
static void AddLocationResult (const SearchParameter &parameter, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult::MatchQuality postalAreaMatchQuality, const LocationSearchVisitor::Result &locationMatch, LocationSearchResult::MatchQuality locationMatchQuality, LocationSearchResult &result)
 
static void AddPOIResult (const SearchParameter &parameter, LocationSearchResult::MatchQuality regionMatchQuality, const POISearchVisitor::Result &poiMatch, LocationSearchResult::MatchQuality poiMatchQuality, LocationSearchResult &result)
 
static void AddPostalAreaResult (const SearchParameter &parameter, LocationSearchResult::MatchQuality regionMatchQuality, const PostalAreaSearchVisitor::Result &postalAreaMatch, LocationSearchResult::MatchQuality postalAreaMatchQuality, LocationSearchResult &result)
 
static void AddRegionResult (const SearchParameter &parameter, LocationSearchResult::MatchQuality regionMatchQuality, const AdminRegionSearchVisitor::Result &regionMatch, LocationSearchResult &result)
 
double AngleDiff (double a, double b)
 
std::string AppendFileToDir (const std::string &dir, const std::string &file)
 
template<typename N >
bool AreaIsCCW (const std::vector< N > &edges)
 
template<typename N >
bool AreaIsClockwise (const std::vector< N > &edges)
 
template<typename N >
bool AreaIsSimple (const std::vector< std::pair< N, N > > &edges, const std::vector< bool > &edgeStartsNewPoly)
 
template<typename N >
bool AreaIsSimple (std::vector< N > points)
 
template<typename N >
bool AreaIsValid (std::vector< N > &outerPoints, std::vector< std::vector< N > > &innerPoints)
 
static bool AreaSorter (const MapPainter::AreaData &a, const MapPainter::AreaData &b)
 Return if a > b, a should be drawn before b. More...
 
template<typename T >
int64_t AsMillis (const std::chrono::duration< T > &duration)
 
double atanh_pd (double x)
 
double atanh_pd (double x, double y, double &res_x, double &res_y)
 
v2df atanh_pd (v2df x)
 
double atanh_sin_pd (double x)
 
double atanh_sin_pd (double x, double y, double &res_x, double &res_y)
 
v2df atanh_sin_pd (v2df x)
 
bool availableMapsModelItemLessThan (const AvailableMapsModelItem *i1, const AvailableMapsModelItem *i2)
 
static std::vector< char > Base64Decode (const std::string &in)
 
static std::string Base64Encode (const std::vector< char > &in)
 
template<typename N >
uint8_t BitsNeededToEncodeNumber (N number)
 
template<typename N >
BitsToBytes (N bits)
 
const char * BoolToString (bool value)
 Returns a string representation of the given boolean value (either 'true' or 'false') More...
 
static std::list< std::string > BuildStringListFromSubToken (const TokenStringRef &tokenString, const std::list< std::string > &tokens)
 Return a list of token by removing tokenString from the given token list (tokens). More...
 
std::string ByteSizeToString (double size, const Locale &locale=Locale::ByEnvironmentSafe())
 
std::string ByteSizeToString (FileOffset size, const Locale &locale=Locale::ByEnvironmentSafe())
 
uint8_t BytesNeededToAddressFileData (const std::string &filename)
 
template<typename N >
uint8_t BytesNeededToEncodeNumber (N number)
 
double CalculateDistancePointToLineSegment (const GeoCoord &p, const GeoCoord &a, const GeoCoord &b, GeoCoord &intersection)
 Calculates the distance between a point p and a line defined by the points a and b. More...
 
template<typename N >
double CalculateDistancePointToLineSegment (const N &p, const N &a, const N &b)
 Calculates the distance between a point p and a line defined by the points a and b. More...
 
static double CalculateDistancePointToLineSegment (const TransPoint &p, const TransPoint &a, const TransPoint &b)
 Calculates the distance between a point p and a line defined by the points a and b. More...
 
static double CalculateDistancePointToPoint (const TransPoint &a, const TransPoint &b)
 
static double * CalculatePathSegmentLengths (cairo_path_t *path)
 Calculate an array of double for the path, that contains the length of each path segment. More...
 
static double CalculatePointDistance (cairo_path_data_t *a, cairo_path_data_t *b)
 
template<class S , class A >
void CalculateUsedTypes (const TypeConfig &typeConfig, const std::list< ConditionalStyle< S, A > > &conditionals, size_t maxLevel, std::vector< TypeInfoSet > &typeSets)
 
static void CleanupSearchPatterns (std::list< TokenStringRef > &patterns)
 
template<class ... Args>
CmdLineArgParserRef CmdLineAlternativeFlag (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineBoolOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineDoubleOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineFlag (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineGeoCoordOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineIntOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineLongOption (Args &&...args)
 
template<class T , class ... Args>
CmdLineArgParserRef CmdLineNumberOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineSizeTOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineStringListOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineStringOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineUIntOption (Args &&...args)
 
template<class ... Args>
CmdLineArgParserRef CmdLineULongOption (Args &&...args)
 
template<typename N >
void ComputeSegmentBoxes (const std::vector< N > &path, std::vector< SegmentGeoBox > &segmentBoxes, size_t bound, size_t segmentSize=1000)
 Helper for FindPathIntersections. More...
 
template<class NativeGlyph >
static bool ContourLabelSorter (const ContourLabel< NativeGlyph > &a, const ContourLabel< NativeGlyph > &b)
 
CoordBufferRange CopyPolygonToCoordBuffer (const TransBuffer &transBuffer, CoordBuffer &coordBuffer)
 
double cos_pd (double x)
 
double cos_pd (double x, double y, double &res_x, double &res_y)
 
v2df cos_pd (v2df x)
 
size_t CountWords (const std::string &text)
 
static bool CrossesElevationLine (int32_t ele, int32_t height1, int32_t height2)
 
static QString CrossingWaysDescriptionToString (const RouteDescription::CrossingWaysDescription &crossingWaysDescription)
 
double dangerous_sin_pd (double x)
 
void dangerous_sin_pd (double x, double y, double &res_x, double &res_y)
 
v2df dangerous_sin_pd (v2df x)
 
template<typename N >
unsigned int DecodeNumber (const char *buffer, N &number)
 
template<typename N >
unsigned int DecodeNumberSigned (const char *buffer, N &number)
 
template<typename N >
unsigned int DecodeNumberUnsigned (const char *buffer, N &number)
 
double DegToRad (double deg)
 
double Det (double x1, double y1, double x2, double y2)
 
template<typename N >
double DistanceSquare (const N &a, const N &b)
 
double DistanceToSegment (const GeoBox &boundingBox, const GeoCoord &segmentStart, const GeoCoord &segmentEnd, GeoCoord &location, GeoCoord &intersection)
 
double DistanceToSegment (const GeoCoord &point, const GeoCoord &segmentStart, const GeoCoord &segmentEnd, double &r, GeoCoord &intersection)
 
double DistanceToSegment (const std::vector< Point > &points, const GeoCoord &segmentStart, const GeoCoord &segmentEnd, GeoCoord &location, GeoCoord &intersection)
 
double DistanceToSegment (double px, double py, double p1x, double p1y, double p2x, double p2y, double &r, double &qx, double &qy)
 return the minimum distance from the point p to the line segment [p1,p2] this could be the distance from p to p1 or to p2 if q the orthogonal projection of p on the line supporting the segment is outside [p1,p2] r is the abscissa of q on the line, 0 <= r <= 1 if q is between p1 and p2. More...
 
static void DropEqualPoints (TransBuffer &buffer)
 
static void DropRedundantPointsDouglasPeuckerArea (TransBuffer &buffer, double optimizeErrorTolerance)
 
static void DropRedundantPointsDouglasPeuckerWay (TransBuffer &buffer, double optimizeErrorTolerance)
 
static void DropRedundantPointsFast (TransBuffer &buffer, double optimizeErrorTolerance)
 
static void DropSimilarPoints (TransBuffer &buffer, double optimizeErrorTolerance)
 
static void DumpGroundTile (const GroundTile &tile)
 
double DurationAsHours (Duration duration)
 
double DurationAsSeconds (Duration duration)
 
Duration DurationOfHours (double hours)
 
std::string DurationString (const Duration &duration)
 
static size_t EatWhitespace (const std::string &text, size_t currentPos)
 
template<typename N >
unsigned int EncodeNumber (N number, char *buffer)
 
template<typename N , size_t S>
unsigned int EncodeNumber (N number, std::array< char, S > &buffer)
 
template<typename N >
unsigned int EncodeNumberSigned (N number, char *buffer)
 
template<typename N >
unsigned int EncodeNumberUnsigned (N number, char *buffer)
 
static void EnsureSimple (TransBuffer &buffer, bool isArea)
 
bool ExistsInFilesystem (const std::string &filename)
 
template<typename N >
bool FindIntersection (const std::vector< N > &way, size_t &i, size_t &j)
 
template<typename N >
void FindPathIntersections (const std::vector< N > &aPath, const std::vector< N > &bPath, bool aClosed, bool bClosed, std::vector< PathIntersection > &intersections, size_t aStartIndex=0, size_t bStartIndex=0)
 
std::string FloatToString (double value, const Locale &locale, uint32_t precision=3)
 Returns locale-aware string representation of number. More...
 
static QString FormatMotorwayJunctionName (const RouteDescription::NameDescription &nameDescription)
 
static QString FormatName (const RouteDescription::NameDescription &nameDescription)
 
static QString FullTurnCommand (const RouteDescription::DirectionDescriptionRef &directionDescription)
 
static std::list< TokenStringRefGenerateSearchPatterns (const std::list< std::string > &tokens, const std::unordered_set< std::string > &patternExclusions, size_t maxWords)
 
SunriseSunsetRes GetAstronomicalTwilight (const GeoCoord &location, const Timestamp &day=Timestamp::clock::now())
 Calculate the astronomical twilight time for the given date and given location. More...
 
template<class InputIt >
void GetBoundingBox (const InputIt first, const InputIt last, GeoBox &boundingBox)
 
template<typename N >
GeoBox GetBoundingBox (const std::vector< N > &nodes)
 
template<typename N >
void GetBoundingBox (const std::vector< N > &nodes, GeoBox &boundingBox)
 
GeoBox GetBoundingBox (const std::vector< Point > &nodes)
 
void GetBoundingBox (const std::vector< Point > &nodes, GeoBox &boundingBox)
 
Cell getCentroidCell (const Polygon &polygon)
 
SunriseSunsetRes GetCivilTwilight (const GeoCoord &location, const Timestamp &day=Timestamp::clock::now())
 Calculate the civil twilight time for the given date and given location. More...
 
bool GetDigitValue (char digit, size_t &result)
 
std::string GetDirectory (const std::string &file)
 
double GetDistanceInLonDegrees (const Distance &d, double latitude=0)
 
Distance GetEllipsoidalDistance (const GeoCoord &a, const GeoCoord &b)
 
GeoCoord GetEllipsoidalDistance (const GeoCoord &position, const Bearing &bearing, const Distance &distance)
 
Distance GetEllipsoidalDistance (double aLon, double aLat, double bLon, double bLat)
 Calculating Vincenty's inverse for getting the ellipsoidal distance of two points on earth. More...
 
void GetEllipsoidalDistance (double lat1, double lon1, const Bearing &bearing, const Distance &distance, double &lat2, double &lon2)
 
template<class S , class A >
std::shared_ptr< S > GetFeatureStyle (const StyleResolveContext &context, const std::vector< std::list< StyleSelector< S, A > > > &styleSelectors, const FeatureValueBuffer &buffer, const Projection &projection)
 Get the style data based on the given features of an object, a given style (S) and its style attributes (A). More...
 
FileOffset GetFileSize (const std::string &filename)
 
std::string GetFirstInStringList (const std::string &stringList, const std::string &divider)
 
static std::set< GeoCoordGetGridPoints (const std::vector< Point > &nodes, double gridSizeHoriz, double gridSizeVert)
 
static char GetHexChar (size_t value)
 
static size_t GetHexValue (char digit)
 
template<typename N , typename I >
bool GetLineIntersection (const N &a1, const N &a2, const N &b1, const N &b2, I &intersection)
 
template<typename N >
bool GetLineIntersectionPixel (const N &a1, const N &a2, const N &b1, const N &b2, N &intersection)
 
template<class S , class A >
void GetMaxLevelInConditionals (const std::list< ConditionalStyle< S, A > > &conditionals, size_t &maxLevel)
 
SunriseSunsetRes GetNauticalTwilight (const GeoCoord &location, const Timestamp &day=Timestamp::clock::now())
 Calculate the nautical twilight time for the given date and given location. More...
 
template<typename N , typename M >
int GetRelationOfPointToArea (const N &point, const std::vector< M > &nodes)
 
double getSegDistSq (const GeoCoord &p, const Point &a, const Point &b)
 
template<typename N >
void GetSegmentBoundingBox (const std::vector< N > &path, size_t from, size_t to, GeoBox &boundingBox)
 Helper for FindPathIntersections. More...
 
Bearing GetSphericalBearingFinal (const GeoCoord &a, const GeoCoord &b)
 Taken the path from A to B over a sphere return the bearing at the destination point B. More...
 
Bearing GetSphericalBearingInitial (const GeoCoord &a, const GeoCoord &b)
 
Distance GetSphericalDistance (const GeoCoord &a, const GeoCoord &b)
 Calculating basic cost for the A* algorithm based on the spherical distance of two points on earth. More...
 
SunriseSunsetRes GetSunriseSunset (const GeoCoord &location, const Timestamp &day, double sunAltitude)
 Calculate the sunrise and sunset times for the given date, given location, and sun altitude. More...
 
SunriseSunsetRes GetSunriseSunset (const GeoCoord &location, const Timestamp &day=Timestamp::clock::now())
 Calculate the sunrise and sunset times for the given date and given location. More...
 
std::string GetTokensFromEnd (const std::list< std::string > &tokens, size_t count)
 
std::string GetTokensFromStart (const std::list< std::string > &tokens, size_t count)
 
int GetUtcOffset ()
 returns the utc timezone offset (e.g. More...
 
void GroupStringListToStrings (std::list< std::string >::const_iterator token, size_t listSize, size_t parts, std::list< std::list< std::string > > &lists)
 
template<class S , class A >
bool HasStyle (const std::vector< std::vector< std::list< StyleSelector< S, A >>>> &styleSelectors, const size_t level)
 
uint64_t InterleaveNumbers (uint32_t a, uint32_t b)
 
template<typename N , typename M >
bool IsAreaAtLeastPartlyInArea (const std::vector< N > &a, const std::vector< M > &b)
 
template<typename N , typename M >
bool IsAreaAtLeastPartlyInArea (const std::vector< N > &a, const std::vector< M > &b, const GeoBox &aBox, const GeoBox &bBox)
 
template<typename N , typename M >
bool IsAreaCompletelyInArea (const std::vector< N > &a, const std::vector< M > &b)
 
template<typename N , typename M >
bool IsAreaSubOfArea (const std::vector< N > &a, const std::vector< M > &b)
 
template<typename N , typename M >
bool IsAreaSubOfAreaOrSame (const std::vector< N > &a, const std::vector< M > &b)
 
template<typename N , typename M >
bool IsAreaSubOfAreaQuorum (const std::vector< N > &a, const std::vector< M > &b)
 
template<typename N , typename M >
bool IsCoordInArea (const N &point, const std::vector< M > &nodes)
 
bool IsDirectory (const std::string &filename)
 
bool IsLaneOffset (OffsetRel rel)
 
static bool IsLowerByteSet (const unsigned char *bytes)
 
static bool IsLowerByteSet (unsigned char *bytes)
 
bool IsValidToWrite (const std::vector< Point > &nodes)
 
Distance Kilometers (double km)
 
template<class NativeGlyph , class NativeLabel >
static bool LabelInstanceSorter (const LabelInstance< NativeGlyph, NativeLabel > &a, const LabelInstance< NativeGlyph, NativeLabel > &b)
 
static bool LabelLayoutDataSorter (const LabelData &a, const LabelData &b)
 Sort labels for the same object by position. More...
 
std::string LaneTurnString (LaneTurn turn)
 
void LayoutTextLayout (const QFontMetrics &fontMetrics, qreal proposedWidth, QTextLayout &layout, QRectF &boundingBox)
 
template<typename N >
bool LinesIntersect (const N &a1, const N &a2, const N &b1, const N &b2)
 
cairo_surface_t * LoadPNG (const std::string &filename)
 
osmscout::OpenGLTextureRef LoadPNGOpenGL (const std::string &filename)
 
bool LoadShader (GLuint &shader, GLenum type, const std::string &name, const std::string &shaderSource)
 
bool LoadShaderSource (const std::string &dirPath, const std::string &name, std::string &result)
 
std::string LocaleStringToUTF8String (const std::string &text)
 
std::wstring LocaleStringToWString (const std::string &text)
 
double log_pd (double x)
 
double log_pd (double x, double y, double &res_x, double &res_y)
 
v2df log_pd (v2df x)
 
static void MapPathOnPath (cairo_t *draw, cairo_path_t *srcPath, cairo_path_t *dstPath, double xOffset, double yOffset)
 
Distance Meters (double m)
 
time_t MkTimeUTC (struct tm *timeptr)
 https://stackoverflow.com/a/9088549/1632737 More...
 
void Normalize (double x, double y, double &nx, double &ny)
 
double NormalizeRelativeAngle (double angle)
 
template<typename N >
size_t NumberDigits (const N &number, size_t base=10)
 
std::string NumberToString (long value, const Locale &locale)
 Returns locale-aware string representation of number. More...
 
bool operator!= (const MapView &a, const MapView &b)
 
Vertex2D operator* (const Vertex2D &a, double scale)
 
std::string operator+ (const char *text, const MagnificationLevel &level)
 
std::string operator+ (const std::string &text, const MagnificationLevel &level)
 
Vertex2D operator+ (const Vertex2D &a, const Vertex2D &b)
 
Vertex2D operator- (const Vertex2D &a, const Vertex2D &b)
 
bool operator< (const TileCacheKey &a, const TileCacheKey &b)
 
QDebug & operator<< (QDebug &out, const TileCacheKey &key)
 
std::ostream & operator<< (std::ostream &os, const Distance &distance)
 
std::ostream & operator<< (std::ostream &os, const MagnificationLevel &level)
 
std::ostream & operator<< (std::ostream &stream, const DBFileOffset &o)
 
std::ostream & operator<< (std::ostream &stream, const DBId &o)
 
std::ostream & operator<< (std::ostream &stream, const StopClock &stopClock)
 
std::ostream & operator<< (std::ostream &stream, const StopClockNano &stopClock)
 
bool operator== (const MapView &a, const MapView &b)
 
bool operator== (const ObjectKey &k1, const ObjectKey &k2)
 
bool operator== (const TileCacheKey &a, const TileCacheKey &b)
 
void OptimizeArea (TransBuffer &buffer, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance, TransPolygon::OutputConstraint constraint)
 Optimize a already transformed area. More...
 
void OptimizeWay (TransBuffer &buffer, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance, TransPolygon::OutputConstraint constraint)
 Optimize a already transformed way. More...
 
OffsetRel ParseBackwardTurnStringToOffset (LaneTurn turn)
 
bool ParseBoolArgument (int argc, char *argv[], int &currentIndex, bool &value)
 
OffsetRel ParseForwardTurnStringToOffset (LaneTurn turn)
 
bool ParseISO8601TimeString (const std::string &timeStr, Timestamp &timestamp)
 Parse time string in ISO 8601 format "2017-11-26T13:46:12.124Z" (UTC timezone) to Timestamp (std::chrono::time_point with millisecond accuracy). More...
 
bool ParseSizeTArgument (int argc, char *argv[], int &currentIndex, size_t &value)
 
bool ParseStringArgument (int argc, char *argv[], int &currentIndex, std::string &value)
 
bool ParseUInt32Argument (int argc, char *argv[], int &currentIndex, uint32_t &value)
 
static void PathPointTransformer (double &x, double &y, cairo_path_t *path, const double *pathSegmentLengths)
 Project a point X,Y onto a parameterized path. More...
 
OSMSCOUT_CLIENT_QT_API QList< QDir > PathVectorToQDirList (const std::vector< std::filesystem::path > &paths)
 
auto pointToPolygonDist (const GeoCoord &point, const Polygon &polygon)
 
GeoCoord PolygonCenter (const Area &area, double precision=1)
 
GeoCoord PolygonCenter (const Polygon &polygon, const GeoBox &envelope, double precision)
 
GeoCoord PolygonCenter (const std::vector< Point > &polygon, double precision=1)
 
size_t Pow (size_t a, size_t b)
 
uint qHash (const TileCacheKey &key)
 
OSMSCOUT_CLIENT_QT_API std::vector< std::string > QStringListToStringVector (const QStringList &list)
 
double RadToDeg (double rad)
 
bool ReadFile (const std::string &filename, std::vector< char > &content)
 
bool RemoveFile (const std::string &filename)
 
bool RenameFile (const std::string &oldFilename, const std::string &newFilename)
 Rename a file. More...
 
std::string ReplaceString (const std::string &in, const std::string &search, const std::string &replacement)
 
static double RoundDown (double value)
 
static double RoundUp (double value)
 
void ScanConvertLine (int x1, int y1, int x2, int y2, std::vector< ScanCell > &cells)
 This functions does a scan conversion of a line with the given start and end points. More...
 
static bool ScanCoordinate (const std::string &text, size_t &currentPos, double &value, size_t maxDigits)
 
static bool ScanNumber (const std::string &text, size_t &currentPos, double &value, size_t maxDigits)
 
static bool SearchForAddressForLocation (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::list< std::string > &addressTokens, const LocationSearchVisitor::Result &locationMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult::MatchQuality postalAreaMatchQuality, LocationSearchResult::MatchQuality locationMatchQuality, LocationSearchResult &result)
 
static bool SearchForLocationForPostalArea (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::string &locationPattern, const std::string &addressPattern, const PostalAreaSearchVisitor::Result &postalAreaMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult::MatchQuality postalAreaMatchQuality, LocationSearchResult &result, BreakerRef &breaker)
 
static bool SearchForLocationForRegion (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::list< std::string > &locationTokens, const AdminRegionSearchVisitor::Result &regionMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult &result, BreakerRef &breaker)
 
static bool SearchForPOIForRegion (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::list< std::string > &poiTokens, const AdminRegionSearchVisitor::Result &regionMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult &result, BreakerRef &breaker)
 
static bool SearchForPOIForRegion (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::string &poiPattern, const AdminRegionSearchVisitor::Result &regionMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult &result, BreakerRef &breaker)
 
static bool SearchForPostalAreaForRegion (LocationIndexRef &locationIndex, const SearchParameter &parameter, const std::string &postalAreaPattern, const std::string &locationPattern, const std::string &addressPattern, const AdminRegionSearchVisitor::Result &regionMatch, LocationSearchResult::MatchQuality regionMatchQuality, LocationSearchResult &result, BreakerRef &breaker)
 
bool SetThreadName ([[maybe_unused]] const std::string &name)
 
bool SetThreadName (const std::string &name)
 Try to set current thread name. More...
 
bool SetThreadName (std::thread &thread, const std::string &name)
 Try to set thread name. More...
 
static QString ShortTurnCommand (const RouteDescription::DirectionDescriptionRef &directionDescription)
 
static void SimplifyPolyLineDouglasPeucker (TransPoint *points, size_t beginIndex, size_t endIndex, size_t endValueIndex, double optimizeErrorToleranceSquared)
 
void SimplifyTokenList (std::list< std::string > &tokens)
 
void sin_cos_pd (double x, double &res_sin, double &res_cos)
 
double sin_pd (double x)
 
void sin_pd (double x, double y, double &res_x, double &res_y)
 
v2df sin_pd (v2df x)
 
void sincos (double x, double &resSin, double &resCos)
 
template<class S , class A >
void SortInConditionals (const TypeConfig &typeConfig, const std::list< ConditionalStyle< S, A > > &conditionals, size_t maxLevel, std::vector< std::vector< std::list< StyleSelector< S, A > > > > &selectors)
 
template<class S , class A >
void SortInConditionalsBySlot (const TypeConfig &typeConfig, const std::list< ConditionalStyle< S, A > > &conditionals, size_t maxLevel, std::vector< std::vector< std::vector< std::list< StyleSelector< S, A > > > > > &selectors)
 
static QStringList SplitDestinations (const std::string &destinations)
 
std::list< std::string > SplitString (const std::string &stringList, const std::string &separator, int maxSize=-1)
 
std::list< std::string > SplitStringAtSpace (const std::string &input)
 
std::optional< std::pair< std::string, std::string > > SplitStringToPair (const std::string &str, const std::string &separator)
 Split string by separator to two parts. More...
 
bool StringToBool (const char *string, bool &value)
 
bool StringToNumber (const char *string, double &value)
 
bool StringToNumber (const std::string &string, double &value)
 
template<typename N >
bool StringToNumber (const std::string &string, N &number, size_t base=10)
 
template<typename N >
bool StringToNumberSigned (const std::string &string, N &number, size_t base=10)
 
template<typename N >
bool StringToNumberUnsigned (const std::string &string, N &number, size_t base=10)
 
OSMSCOUT_CLIENT_QT_API QStringList StringVectorToQStringList (const std::vector< std::string > &v)
 
Signal< std::thread::id > & ThreadExitSignal ()
 Signal that is emitted on thread exit. More...
 
std::string TimestampToISO8601TimeString (const Timestamp &timestamp)
 Format Timestamp to string in ISO8601 format "2017-11-26T13:46:12.124Z" for UTC timezone. More...
 
OSMSCOUT_CLIENT_QT_API QDateTime TimestampToQDateTime (const osmscout::Timestamp &ts)
 
void TokenizeString (const std::string &input, std::list< std::string > &tokens)
 
template<typename C >
void TransformArea (const C &nodes, TransBuffer &buffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance, TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint)
 Transform form geo to screen coordinates and (optionally) optimize the passed area with the given coordinates. More...
 
template<typename C >
CoordBufferRange TransformArea (const C &nodes, TransBuffer &transBuffer, CoordBuffer &coordBuffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance)
 Transform the geo coordinates to display coordinates of the given area and copy the resulting coordinates the the given CoordBuffer. More...
 
void TransformBoundingBox (const GeoBox &boundingBox, TransBuffer &buffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance, TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint)
 Transform form geo to screen coordinates and (optionally) optimize the passed way with the given coordinates. More...
 
CoordBufferRange TransformBoundingBox (const GeoBox &boundingBox, TransBuffer &buffer, CoordBuffer &coordBuffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance)
 Transform the geo coordinates to display coordinates of the given bounding box and copy the resulting coordinates the the given CoordBuffer. More...
 
static void TransformPathOntoPath (cairo_path_t *srcPath, cairo_path_t *dstPath, double *pathSegmentLengths, double xOffset, double yOffset)
 Project a path using a function. More...
 
template<typename C >
void TransformWay (const C &nodes, TransBuffer &buffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance, TransPolygon::OutputConstraint constraint=TransPolygon::noConstraint)
 Transform form geo to screen coordinates and (optionally) optimize the passed way with the given coordinates. More...
 
template<typename C >
CoordBufferRange TransformWay (const C &nodes, TransBuffer &transBuffer, CoordBuffer &coordBuffer, const Projection &projection, TransPolygon::OptimizeMethod optimize, double optimizeErrorTolerance)
 Transform the geo coordinates to display coordinates of the given way and copy the resulting coordinates the the given CoordBuffer. More...
 
std::string Trim (const std::string &str, char trimmedChar=' ')
 Trim trimmedChar from begin and end of str. More...
 
static QString TurnCommandType (const RouteDescription::DirectionDescriptionRef &directionDescription)
 
static QString TurnCommandWithList (const RouteDescription::DirectionDescriptionRef &directionDescription)
 
std::string UTF8NormForLookup (const std::string &text)
 Normalise the given std::string containing a UTF8 character sequence for tolerant comparison. More...
 
std::string UTF8StringToLocaleString (const std::string &text)
 
std::string UTF8StringToLower (const std::string &text)
 Convert the given std::string containing a UTF8 character sequence to lower case using the translation table implementation. More...
 
std::u32string UTF8StringToU32String (const std::string &text)
 
std::string UTF8StringToUpper (const std::string &text)
 Convert the given std::string containing a UTF8 character sequence to upper case using translation table implementation. More...
 
std::wstring UTF8StringToWString (const std::string &text)
 
std::string UTF8Transliterate (const std::string &text)
 Transliterate non-ascii characters to one or more characters that are similar to the original character. More...
 
template<typename T >
QList< T > vectorToQList (const std::vector< T > &vec)
 
std::string vehicleStr (osmscout::Vehicle vehicle)
 
std::string WStringToLocaleString (const std::wstring &text)
 
std::string WStringToUTF8String (const std::wstring &text)
 

Variables

const ALIGN16_BEG double SINECOEFF_SSE[] ALIGN16_END
 
constexpr const char * Base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 
static const StyleDescriptorRef borderStyleDescriptor =std::make_shared<BorderStyleDescriptor>()
 
const size_t CELL_DIMENSION_COUNT = CELL_DIMENSION_MAX+1
 
const size_t CELL_DIMENSION_MAX = 25
 
const std::array< CellDimension, CELL_DIMENSION_COUNTcellDimension
 
const size_t coordByteSize =7
 
constexpr bool debugGroundTiles = false
 
constexpr bool debugLabelLayouter = false
 
constexpr bool debugRouting = false
 
static double DELTA_ANGLE =2*M_PI/16.0
 We rotate in 16 steps. More...
 
static const uint32_t FILE_FORMAT_VERSION =25
 
static const StyleDescriptorRef fillStyleDescriptor =std::make_shared<FillStyleDescriptor>()
 
static double FONT_HEIGHT_FACTOR =10
 Height of the font in pixel in relation to the given fontSize. More...
 
static const double GRAD_TO_RAD = 2 * M_PI / 360
 
static const double gradtorad =2*M_PI/360.0
 
static const StyleDescriptorRef iconStyleDescriptor =std::make_shared<IconStyleDescriptor>()
 
cairo_user_data_key_t imageDataKey
 
static int INITIAL_DATA_RENDERING_TIMEOUT = 10
 
const double latConversionFactor =(double)maxRawCoordValue/180.0
 
static const StyleDescriptorRef lineStyleDescriptor =std::make_shared<LineStyleDescriptor>()
 
Log log
 
const double lonConversionFactor =(double)maxRawCoordValue/360.0
 
constexpr uint32_t maxRawCoordValue = 0x7FFFFFF
 
static OSMScoutQtosmScoutInstance =nullptr
 
static const StyleDescriptorRef pathShieldStyleDescriptor =std::make_shared<PathShieldStyleDescriptor>()
 
static const StyleDescriptorRef pathSymbolStyleDescriptor =std::make_shared<PathSymbolStyleDescriptor>()
 
static const StyleDescriptorRef pathTextStyleDescriptor =std::make_shared<PathTextStyleDescriptor>()
 
static const TagId tagIgnore = 0
 
static const StyleDescriptorRef textStyleDescriptor =std::make_shared<TextStyleDescriptor>()
 
static const double tileDPI =96.0
 
static const TypeId typeIgnore = 0
 
static int UPDATED_DATA_RENDERING_TIMEOUT = 200
 
static const char * valueChar ="0123456789abcdef"
 
constexpr int X_STEP_0 = 0
 The X flag is set as follows based on the locking steps Step 0 : X is released Step 1 : X is held, but waits for release of S Step 2 : X was released and left available for one of request in wait Step 3 : X is held Step N : X recursive N-3. More...
 
constexpr int X_STEP_1 = 1
 
constexpr int X_STEP_2 = 2
 
constexpr int X_STEP_3 = 3
 

Detailed Description

Typedef Documentation

◆ AccessFeatureValueReader

◆ AccessRestrictedFeatureReader

◆ AccessRestrictedFeatureValueReader

◆ AddressFeatureValueReader

◆ AddressRef

using osmscout::AddressRef = typedef std::shared_ptr<Address>

◆ AdminLevelFeatureValueReader

◆ AdminRegionRef

using osmscout::AdminRegionRef = typedef std::shared_ptr<AdminRegion>

◆ AreaAreaIndexRef

using osmscout::AreaAreaIndexRef = typedef std::shared_ptr<AreaAreaIndex>

◆ AreaDataFileRef

using osmscout::AreaDataFileRef = typedef std::shared_ptr<AreaDataFile>

◆ AreaNodeIndexRef

using osmscout::AreaNodeIndexRef = typedef std::shared_ptr<AreaNodeIndex>

◆ AreaRef

using osmscout::AreaRef = typedef std::shared_ptr<Area>

◆ AreaRouteIndexRef

using osmscout::AreaRouteIndexRef = typedef std::shared_ptr<AreaRouteIndex>

◆ AreaWayIndexRef

using osmscout::AreaWayIndexRef = typedef std::shared_ptr<AreaWayIndex>

◆ BasemapDatabaseRef

using osmscout::BasemapDatabaseRef = typedef std::shared_ptr<BasemapDatabase>

Reference counted reference to an Database instance.

◆ BorderConditionalStyle

◆ BorderPartialStyle

Index selectors by type and level.

◆ BorderStyleLookupTable

using osmscout::BorderStyleLookupTable = typedef std::vector<std::vector<BorderStyleSelectorList> >

List of selectors.

◆ BorderStyleRef

using osmscout::BorderStyleRef = typedef std::shared_ptr<BorderStyle>

◆ BorderStyleSelector

◆ BorderStyleSelectorList

◆ BoundingBoxDataFileRef

using osmscout::BoundingBoxDataFileRef = typedef std::shared_ptr<BoundingBoxDataFile>

◆ BreakerRef

using osmscout::BreakerRef = typedef std::shared_ptr<Breaker>

◆ BridgeFeatureReader

◆ CharacterTextureRef

◆ CirclePrimitiveRef

using osmscout::CirclePrimitiveRef = typedef std::shared_ptr<CirclePrimitive>

◆ ClockwiseDirectionFeatureReader

◆ CmdLineArgParserRef

using osmscout::CmdLineArgParserRef = typedef std::shared_ptr<CmdLineArgParser>

◆ ColorFeatureValueReader

◆ ColorPostprocessor

◆ ConstructionYearFeatureValueReader

◆ CoverageIndexRef

using osmscout::CoverageIndexRef = typedef std::shared_ptr<CoverageIndex>

◆ DatabaseId

using osmscout::DatabaseId = typedef uint32_t

◆ DatabaseRef

using osmscout::DatabaseRef = typedef std::shared_ptr<Database>

Reference counted reference to an Database instance.

◆ DestinationFeatureValueReader

◆ DistanceUnitPtr

using osmscout::DistanceUnitPtr = typedef std::shared_ptr<DistanceUnit>

◆ DoubleRectangle

using osmscout::DoubleRectangle = typedef Rectangle<double>

◆ DrawPrimitiveRef

using osmscout::DrawPrimitiveRef = typedef std::shared_ptr<DrawPrimitive>

◆ Duration

using osmscout::Duration = typedef Timestamp::duration

◆ EleFeatureValueReader

◆ EmbankmentFeatureReader

◆ FastestPathRoutingProfileRef

◆ FeatureRef

using osmscout::FeatureRef = typedef std::shared_ptr<Feature>

◆ FeatureValueBufferRef

using osmscout::FeatureValueBufferRef = typedef std::shared_ptr<FeatureValueBuffer>

◆ FillConditionalStyle

◆ FillPartialStyle

Index selectors by type and level.

◆ FillStyleLookupTable

using osmscout::FillStyleLookupTable = typedef std::vector<std::vector<FillStyleSelectorList> >

List of selectors.

◆ FillStyleProcessorRef

using osmscout::FillStyleProcessorRef = typedef std::shared_ptr<FillStyleProcessor>

◆ FillStyleRef

using osmscout::FillStyleRef = typedef std::shared_ptr<FillStyle>

◆ FillStyleSelector

◆ FillStyleSelectorList

◆ FromToFeatureValueReader

◆ GradeFeatureValueReader

◆ HourDuration

using osmscout::HourDuration = typedef std::chrono::duration<double, std::ratio<3600> >

◆ IconConditionalStyle

◆ IconPartialStyle

Index selectors by type and level.

◆ IconStyleLookupTable

using osmscout::IconStyleLookupTable = typedef std::vector<std::vector<IconStyleSelectorList> >

List of selectors.

◆ IconStyleRef

using osmscout::IconStyleRef = typedef std::shared_ptr<IconStyle>

◆ IconStyleSelector

◆ IconStyleSelectorList

◆ IntRectangle

using osmscout::IntRectangle = typedef Rectangle<int>

◆ IsInFeatureValueReader

◆ JunctionRef

using osmscout::JunctionRef = typedef std::shared_ptr<Intersection>

◆ LabelProviderFactoryRef

using osmscout::LabelProviderFactoryRef = typedef std::shared_ptr<LabelProviderFactory>

◆ LabelProviderRef

typedef std::shared_ptr< LabelProvider > osmscout::LabelProviderRef

◆ LabelStyleRef

using osmscout::LabelStyleRef = typedef std::shared_ptr<LabelStyle>

◆ LanesFeatureValueReader

◆ LayerFeatureValueReader

◆ LineConditionalStyle

◆ LinePartialStyle

◆ LineStyleLookupTable

using osmscout::LineStyleLookupTable = typedef std::vector<std::vector<LineStyleSelectorList> >

List of selectors.

◆ LineStyleRef

using osmscout::LineStyleRef = typedef std::shared_ptr<LineStyle>

◆ LineStyleSelector

◆ LineStyleSelectorList

◆ LocationEntryRef

using osmscout::LocationEntryRef = typedef std::shared_ptr<LocationEntry>

◆ LocationFeatureValueReader

◆ LocationIndexRef

using osmscout::LocationIndexRef = typedef std::shared_ptr<LocationIndex>

◆ LocationRef

using osmscout::LocationRef = typedef std::shared_ptr<Location>

◆ MapDataRef

using osmscout::MapDataRef = typedef std::shared_ptr<MapData>

◆ MapRendererRef

using osmscout::MapRendererRef = typedef std::shared_ptr<MapRenderer>

◆ MapTileRef

typedef std::shared_ptr<MapTile> osmscout::MapTileRef

◆ MaxSpeedFeatureValueReader

◆ MilliDouble

using osmscout::MilliDouble = typedef std::chrono::duration<double, std::milli>

◆ NameAltFeatureValueReader

◆ NameFeatureLabelReader

◆ NameFeatureValueReader

◆ NameShortFeatureValueReader

◆ NanoDouble

using osmscout::NanoDouble = typedef std::chrono::duration<double, std::nano>

◆ NavigationAgentRef

using osmscout::NavigationAgentRef = typedef std::shared_ptr<NavigationAgent>

◆ NavigationMessageRef

using osmscout::NavigationMessageRef = typedef std::shared_ptr<NavigationMessage>

◆ NetworkFeatureValueReader

◆ NodeDataFileRef

using osmscout::NodeDataFileRef = typedef std::shared_ptr<NodeDataFile>

◆ NodeRef

using osmscout::NodeRef = typedef std::shared_ptr<Node>

◆ OpenGLTextureRef

typedef std::shared_ptr<OpenGLTexture> osmscout::OpenGLTextureRef

◆ OperatorFeatureValueReader

◆ OptimizeAreasLowZoomRef

using osmscout::OptimizeAreasLowZoomRef = typedef std::shared_ptr<OptimizeAreasLowZoom>

◆ OptimizeWaysLowZoomRef

using osmscout::OptimizeWaysLowZoomRef = typedef std::shared_ptr<OptimizeWaysLowZoom>

◆ OverlayObjectRef

using osmscout::OverlayObjectRef = typedef std::shared_ptr<OverlayObject>

◆ PageId

using osmscout::PageId = typedef uint64_t

◆ PathShieldConditionalStyle

◆ PathShieldPartialStyle

Index selectors by type and level.

◆ PathShieldStyleLookupTable

using osmscout::PathShieldStyleLookupTable = typedef std::vector<std::vector<PathShieldStyleSelectorList> >

List of selectors.

◆ PathShieldStyleRef

using osmscout::PathShieldStyleRef = typedef std::shared_ptr<PathShieldStyle>

◆ PathShieldStyleSelector

◆ PathShieldStyleSelectorList

◆ PathSymbolConditionalStyle

◆ PathSymbolPartialStyle

Index selectors by type and level.

◆ PathSymbolStyleLookupTable

using osmscout::PathSymbolStyleLookupTable = typedef std::vector<std::vector<PathSymbolStyleSelectorList> >

List of selectors.

◆ PathSymbolStyleRef

using osmscout::PathSymbolStyleRef = typedef std::shared_ptr<PathSymbolStyle>

◆ PathSymbolStyleSelector

◆ PathSymbolStyleSelectorList

◆ PathTextConditionalStyle

◆ PathTextPartialStyle

Index selectors by type and level.

◆ PathTextStyleLookupTable

using osmscout::PathTextStyleLookupTable = typedef std::vector<std::vector<PathTextStyleSelectorList> >

List of selectors.

◆ PathTextStyleRef

using osmscout::PathTextStyleRef = typedef std::shared_ptr<PathTextStyle>

◆ PathTextStyleSelector

◆ PathTextStyleSelectorList

◆ POIRef

using osmscout::POIRef = typedef std::shared_ptr<POI>

◆ Polygon

using osmscout::Polygon = typedef std::vector<const Ring*>

◆ PolygonPrimitiveRef

using osmscout::PolygonPrimitiveRef = typedef std::shared_ptr<PolygonPrimitive>

◆ PostalAreaRef

using osmscout::PostalAreaRef = typedef std::shared_ptr<PostalArea>

◆ PostalCodeFeatureValueReader

◆ PTRouteDataFileRef

using osmscout::PTRouteDataFileRef = typedef std::shared_ptr<PTRouteDataFile>

◆ PTRouteRef

using osmscout::PTRouteRef = typedef std::shared_ptr<PTRoute>

◆ QmlRoutingProfileRef

using osmscout::QmlRoutingProfileRef = typedef std::shared_ptr<QmlRoutingProfile>

◆ QtGlyph

using osmscout::QtGlyph = typedef Glyph<QGlyphRun>

◆ QtLabel

using osmscout::QtLabel = typedef Label<QGlyphRun, QTextLayout>

◆ QtLabelInstance

using osmscout::QtLabelInstance = typedef LabelInstance<QGlyphRun, QTextLayout>

◆ QtMediaPlayerState

using osmscout::QtMediaPlayerState = typedef QMediaPlayer::PlaybackState

◆ RectanglePrimitiveRef

using osmscout::RectanglePrimitiveRef = typedef std::shared_ptr<RectanglePrimitive>

◆ RefFeatureLabelReader

◆ RefFeatureValueReader

◆ Ring

using osmscout::Ring = typedef std::vector<Point>

◆ RoundaboutFeatureReader

◆ RoutableObjectsMessageRef

◆ RoutableObjectsRef

using osmscout::RoutableObjectsRef = typedef std::shared_ptr<RoutableObjects>

◆ RouteDataFileRef

using osmscout::RouteDataFileRef = typedef std::shared_ptr<RouteDataFile>

◆ RouteDescriptionRef

using osmscout::RouteDescriptionRef = typedef std::shared_ptr<RouteDescription>

◆ RouteNodeRef

using osmscout::RouteNodeRef = typedef std::shared_ptr<RouteNode>

◆ RoutePointsRef

using osmscout::RoutePointsRef = typedef std::shared_ptr<RoutePoints>

◆ RouteRef

using osmscout::RouteRef = typedef std::shared_ptr<Route>

◆ RoutingProfileRef

using osmscout::RoutingProfileRef = typedef std::shared_ptr<RoutingProfile>

◆ ShieldConditionalStyle

◆ ShieldPartialStyle

Index selectors by type and level.

◆ ShieldStyleLookupTable

using osmscout::ShieldStyleLookupTable = typedef std::vector<std::vector<ShieldStyleSelectorList> >

List of selectors.

◆ ShieldStyleRef

using osmscout::ShieldStyleRef = typedef std::shared_ptr<ShieldStyle>

◆ ShieldStyleSelector

◆ ShieldStyleSelectorList

◆ ShortestPathRoutingProfileRef

◆ SizeConditionRef

using osmscout::SizeConditionRef = typedef std::shared_ptr<SizeCondition>

◆ SRTMDataRef

using osmscout::SRTMDataRef = typedef std::shared_ptr<SRTMData>

◆ SRTMRef

using osmscout::SRTMRef = typedef std::shared_ptr<SRTM>

◆ StringMatcherFactoryRef

using osmscout::StringMatcherFactoryRef = typedef std::shared_ptr<StringMatcherFactory>

◆ StringMatcherRef

using osmscout::StringMatcherRef = typedef std::shared_ptr<StringMatcher>

◆ StyleAttributeDescriptorRef

◆ StyleConfigRef

using osmscout::StyleConfigRef = typedef std::shared_ptr<StyleConfig>

◆ StyleConstantRef

using osmscout::StyleConstantRef = typedef std::shared_ptr<StyleConstant>

◆ StyleDescriptorRef

using osmscout::StyleDescriptorRef = typedef std::shared_ptr<StyleDescriptor>

◆ SunriseSunsetRes

using osmscout::SunriseSunsetRes = typedef std::optional<std::tuple<Timestamp, Timestamp> >

◆ SymbolRef

using osmscout::SymbolRef = typedef std::shared_ptr<Symbol>

◆ TagId

using osmscout::TagId = typedef uint16_t

◆ TagMap

using osmscout::TagMap = typedef std::unordered_map<TagId, std::string>

◆ TextConditionalStyle

◆ TextPartialStyle

Index selectors by type and level.

◆ TextStyleLookupTable

using osmscout::TextStyleLookupTable = typedef std::vector<std::vector<TextStyleSelectorList> >

List of selectors.

◆ TextStyleRef

using osmscout::TextStyleRef = typedef std::shared_ptr<TextStyle>

◆ TextStyleSelector

◆ TextStyleSelectorList

◆ Timestamp

using osmscout::Timestamp = typedef std::chrono::system_clock::time_point

◆ TokenStringRef

typedef std::shared_ptr<TokenString> osmscout::TokenStringRef

◆ TunnelFeatureReader

◆ TurnRestrictionRef

using osmscout::TurnRestrictionRef = typedef std::shared_ptr<TurnRestriction>

◆ TypeDistributionDataFileRef

◆ TypeInfoRef

using osmscout::TypeInfoRef = typedef std::shared_ptr<TypeInfo>

◆ VehicleMask

using osmscout::VehicleMask = typedef uint8_t

◆ WaterIndexRef

using osmscout::WaterIndexRef = typedef std::shared_ptr<WaterIndex>

◆ WayDataFileRef

using osmscout::WayDataFileRef = typedef std::shared_ptr<WayDataFile>

◆ WayRef

using osmscout::WayRef = typedef std::shared_ptr<Way>

◆ WidthFeatureValueReader

Enumeration Type Documentation

◆ BinaryOperator

Enumeration of possible binary operators as used by the various parsers.

Enumerator
operatorLess 
operatorLessEqual 
operatorEqual 
operatorGreaterEqual 
operatorGreater 
operatorNotEqual 

◆ DistanceUnitSystem

Enumerator
Metrics 
Imperial 

◆ OffsetRel

enum osmscout::OffsetRel : int
strong

Offset for rendered line, relative to way.

Enumerator
base 

way center

leftOutline 

left side of the way

rightOutline 

right side of the way

laneDivider 

when way has multiple lanes, line is rendered as its divider

laneForwardLeft 

when way has explicit turns, following offsets may be used to decorate them specially

laneForwardThroughLeft 
laneForwardThrough 
laneForwardThroughRight 
laneForwardRight 
laneBackwardLeft 
laneBackwardThroughLeft 
laneBackwardThrough 
laneBackwardThroughRight 
laneBackwardRight 
sidecar 

special offset for routes, line are stacked next to way, same colors are "collapsed"

◆ OSMRefType

Enumerator
osmRefNone 
osmRefNode 
osmRefWay 
osmRefRelation 

◆ RefType

Enumerator
refNone 
refNode 
refArea 
refWay 

◆ RenderSteps

enum osmscout::RenderSteps : size_t
Enumerator
FirstStep 
Initialize 

Setup internal state of renderer for executing next steps with current projection and parameters.

DumpStatistics 

Prints details for debugging, if debug flag (performance, data) is set in renderer parameter.

CalculatePaths 

Calculate the paths to draw based on the given ways.

CalculateWayShields 

Calculate the label shields on the ways.

ProcessAreas 

Process (complex) areas for rendering.

ProcessRoutes 

Process routes for rendering.

AfterPreprocessing 

Additional postprocessing.

Prerender 

Implementation specific preparation.

DrawBaseMapTiles 

Draw unknown/sea/land tiles and tiles with "coastlines" from base map.

DrawGroundTiles 

Same as previous, but from main db.

DrawOSMTileGrids 

If special style exists, renders grid corresponding to OSM tiles.

DrawAreas 
DrawWays 
DrawWayDecorations 
DrawWayContourLabels 
PrepareAreaLabels 
DrawAreaBorderLabels 
DrawAreaBorderSymbols 
PrepareNodeLabels 
PrepareRouteLabels 
DrawContourLines 
DrawHillShading 
DrawLabels 
Postrender 

Implementation specific final step.

LastStep 

◆ Vehicle

enum osmscout::Vehicle : uint8_t
Enumerator
vehicleFoot 
vehicleBicycle 
vehicleCar 

Function Documentation

◆ AddAddressResult()

◆ AddLocationResult()

◆ AddPOIResult()

◆ AddPostalAreaResult()

◆ AddRegionResult()

◆ AreaSorter()

static bool osmscout::AreaSorter ( const MapPainter::AreaData a,
const MapPainter::AreaData b 
)
static

Return if a > b, a should be drawn before b.

Condition for the case when one area exists in two relations

  • in one as outer ring (type of relation is used) and in second relation as inner ring. In such case, we want to draw area with outer type after that one of inner type

References osmscout::MapPainter::AreaData::boundingBox, osmscout::MapPainter::AreaData::fillStyle, osmscout::GeoCoord::GetLat(), osmscout::GeoCoord::GetLon(), osmscout::GeoBox::GetMaxCoord(), osmscout::GeoBox::GetMinCoord(), and osmscout::MapPainter::AreaData::isOuter.

◆ AsMillis()

template<typename T >
int64_t osmscout::AsMillis ( const std::chrono::duration< T > &  duration)

◆ atanh_pd() [1/3]

double osmscout::atanh_pd ( double  x)
inline

References atanh_pd().

◆ atanh_pd() [2/3]

double osmscout::atanh_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References atanh_pd().

◆ atanh_pd() [3/3]

v2df osmscout::atanh_pd ( v2df  x)
inline

References ARRAY2V2DF, and log_pd().

Referenced by atanh_pd(), and atanh_sin_pd().

◆ atanh_sin_pd() [1/3]

double osmscout::atanh_sin_pd ( double  x)
inline

References atanh_sin_pd().

◆ atanh_sin_pd() [2/3]

double osmscout::atanh_sin_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References atanh_sin_pd().

◆ atanh_sin_pd() [3/3]

v2df osmscout::atanh_sin_pd ( v2df  x)
inline

References atanh_pd(), and dangerous_sin_pd().

Referenced by atanh_sin_pd().

◆ availableMapsModelItemLessThan()

◆ Base64Decode()

static std::vector<char> osmscout::Base64Decode ( const std::string &  in)
inlinestatic

References Base64Chars.

◆ Base64Encode()

static std::string osmscout::Base64Encode ( const std::vector< char > &  in)
inlinestatic

References Base64Chars.

Referenced by osmscout::MapPainterSVG::HasIcon().

◆ BoolToString()

const char * osmscout::BoolToString ( bool  value)

Returns a string representation of the given boolean value (either 'true' or 'false')

Parameters
valuevalue to return
Returns
result of the conversion

◆ BuildStringListFromSubToken()

static std::list<std::string> osmscout::BuildStringListFromSubToken ( const TokenStringRef tokenString,
const std::list< std::string > &  tokens 
)
static

Return a list of token by removing tokenString from the given token list (tokens).

Parameters
tokenStringToken to remove
tokensList to remove token parameter from
Returns
New list

Referenced by SearchForAddressForLocation(), osmscout::LocationService::SearchForLocationByString(), SearchForLocationForRegion(), and SearchForPOIForRegion().

◆ ByteSizeToString()

std::string osmscout::ByteSizeToString ( double  size,
const Locale locale = Locale::ByEnvironmentSafe() 
)

◆ CalculateDistancePointToLineSegment() [1/3]

double osmscout::CalculateDistancePointToLineSegment ( const GeoCoord p,
const GeoCoord a,
const GeoCoord b,
GeoCoord intersection 
)

Calculates the distance between a point p and a line defined by the points a and b.

Parameters
pThe point in distance to a line
aOne point defining the line
bAnother point defining the line
intersectionThe point that is closest to 'p', either 'a', 'b', or a point on the line between 'a' and 'b'.
Returns
The distance

References osmscout::GeoCoord::GetLat(), osmscout::GeoCoord::GetLon(), and osmscout::GeoCoord::Set().

◆ CalculateDistancePointToLineSegment() [2/3]

template<typename N >
double osmscout::CalculateDistancePointToLineSegment ( const N &  p,
const N &  a,
const N &  b 
)

Calculates the distance between a point p and a line defined by the points a and b.

Parameters
pThe point in distance to a line
aOne point defining the line
bAnother point defining the line
Returns
The distance

Referenced by DropRedundantPointsFast(), osmscout::Database::LoadAreasInArea(), osmscout::Database::LoadAreasInRadius(), osmscout::Database::LoadWaysInArea(), and osmscout::Database::LoadWaysInRadius().

◆ CalculateDistancePointToLineSegment() [3/3]

static double osmscout::CalculateDistancePointToLineSegment ( const TransPoint p,
const TransPoint a,
const TransPoint b 
)
static

Calculates the distance between a point p and a line defined by the points a and b.

Parameters
pThe point in distance to a line
aOne point defining the line
bAnother point defining the line
Returns
The distance

References osmscout::TransPoint::x, and osmscout::TransPoint::y.

◆ CalculateDistancePointToPoint()

static double osmscout::CalculateDistancePointToPoint ( const TransPoint a,
const TransPoint b 
)
static

◆ CalculatePathSegmentLengths()

static double* osmscout::CalculatePathSegmentLengths ( cairo_path_t *  path)
static

Calculate an array of double for the path, that contains the length of each path segment.

References CalculatePointDistance().

Referenced by MapPathOnPath().

◆ CalculatePointDistance()

static double osmscout::CalculatePointDistance ( cairo_path_data_t *  a,
cairo_path_data_t *  b 
)
static

◆ CalculateUsedTypes()

template<class S , class A >
void osmscout::CalculateUsedTypes ( const TypeConfig typeConfig,
const std::list< ConditionalStyle< S, A > > &  conditionals,
size_t  maxLevel,
std::vector< TypeInfoSet > &  typeSets 
)

◆ CleanupSearchPatterns()

static void osmscout::CleanupSearchPatterns ( std::list< TokenStringRef > &  patterns)
static

◆ CmdLineAlternativeFlag()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineAlternativeFlag ( Args &&...  args)

◆ CmdLineBoolOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineBoolOption ( Args &&...  args)

◆ CmdLineDoubleOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineDoubleOption ( Args &&...  args)

◆ CmdLineFlag()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineFlag ( Args &&...  args)

◆ CmdLineGeoCoordOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineGeoCoordOption ( Args &&...  args)

◆ CmdLineIntOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineIntOption ( Args &&...  args)

◆ CmdLineLongOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineLongOption ( Args &&...  args)

◆ CmdLineNumberOption()

template<class T , class ... Args>
CmdLineArgParserRef osmscout::CmdLineNumberOption ( Args &&...  args)

◆ CmdLineSizeTOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineSizeTOption ( Args &&...  args)

◆ CmdLineStringListOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineStringListOption ( Args &&...  args)

◆ CmdLineStringOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineStringOption ( Args &&...  args)

◆ CmdLineUIntOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineUIntOption ( Args &&...  args)

◆ CmdLineULongOption()

template<class ... Args>
CmdLineArgParserRef osmscout::CmdLineULongOption ( Args &&...  args)

◆ ComputeSegmentBoxes()

template<typename N >
void osmscout::ComputeSegmentBoxes ( const std::vector< N > &  path,
std::vector< SegmentGeoBox > &  segmentBoxes,
size_t  bound,
size_t  segmentSize = 1000 
)

Helper for FindPathIntersections.

Compute bounding boxes for path segments with length 1000 nodes, up to node index bound (exclusive)

References osmscout::SegmentGeoBox::bbox, osmscout::SegmentGeoBox::from, GetSegmentBoundingBox(), and osmscout::SegmentGeoBox::to.

Referenced by FindIntersection(), FindPathIntersections(), and osmscout::OverlayObject::segments().

◆ ContourLabelSorter()

template<class NativeGlyph >
static bool osmscout::ContourLabelSorter ( const ContourLabel< NativeGlyph > &  a,
const ContourLabel< NativeGlyph > &  b 
)
static

◆ CopyPolygonToCoordBuffer()

◆ cos_pd() [1/3]

double osmscout::cos_pd ( double  x)
inline

References cos_pd().

◆ cos_pd() [2/3]

double osmscout::cos_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References cos_pd().

◆ cos_pd() [3/3]

v2df osmscout::cos_pd ( v2df  x)
inline

References ARRAY2V2DF, ARRAY2V2DI, and POLY_EVAL6.

Referenced by cos_pd().

◆ CrossesElevationLine()

static bool osmscout::CrossesElevationLine ( int32_t  ele,
int32_t  height1,
int32_t  height2 
)
static

◆ CrossingWaysDescriptionToString()

◆ dangerous_sin_pd() [1/3]

double osmscout::dangerous_sin_pd ( double  x)
inline

References dangerous_sin_pd().

◆ dangerous_sin_pd() [2/3]

void osmscout::dangerous_sin_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References dangerous_sin_pd().

◆ dangerous_sin_pd() [3/3]

v2df osmscout::dangerous_sin_pd ( v2df  x)
inline

References POLY_EVAL6.

Referenced by atanh_sin_pd(), and dangerous_sin_pd().

◆ DistanceSquare()

template<typename N >
double osmscout::DistanceSquare ( const N &  a,
const N &  b 
)

◆ DistanceToSegment() [1/3]

double osmscout::DistanceToSegment ( const GeoBox boundingBox,
const GeoCoord segmentStart,
const GeoCoord segmentEnd,
GeoCoord location,
GeoCoord intersection 
)

◆ DistanceToSegment() [2/3]

double osmscout::DistanceToSegment ( const GeoCoord point,
const GeoCoord segmentStart,
const GeoCoord segmentEnd,
double &  r,
GeoCoord intersection 
)

◆ DistanceToSegment() [3/3]

double osmscout::DistanceToSegment ( const std::vector< Point > &  points,
const GeoCoord segmentStart,
const GeoCoord segmentEnd,
GeoCoord location,
GeoCoord intersection 
)

References DistanceToSegment().

◆ DropEqualPoints()

◆ DropRedundantPointsDouglasPeuckerArea()

static void osmscout::DropRedundantPointsDouglasPeuckerArea ( TransBuffer buffer,
double  optimizeErrorTolerance 
)
static

◆ DropRedundantPointsDouglasPeuckerWay()

static void osmscout::DropRedundantPointsDouglasPeuckerWay ( TransBuffer buffer,
double  optimizeErrorTolerance 
)
static

◆ DropRedundantPointsFast()

static void osmscout::DropRedundantPointsFast ( TransBuffer buffer,
double  optimizeErrorTolerance 
)
static

◆ DropSimilarPoints()

static void osmscout::DropSimilarPoints ( TransBuffer buffer,
double  optimizeErrorTolerance 
)
static

◆ DumpGroundTile()

◆ DurationAsHours()

double osmscout::DurationAsHours ( Duration  duration)
inline

◆ DurationAsSeconds()

double osmscout::DurationAsSeconds ( Duration  duration)
inline

◆ DurationOfHours()

Duration osmscout::DurationOfHours ( double  hours)
inline

◆ DurationString()

std::string osmscout::DurationString ( const Duration duration)

◆ EatWhitespace()

static size_t osmscout::EatWhitespace ( const std::string &  text,
size_t  currentPos 
)
static

◆ EnsureSimple()

◆ FloatToString()

std::string osmscout::FloatToString ( double  value,
const Locale locale,
uint32_t  precision = 3 
)

Returns locale-aware string representation of number.

Parameters
value
locale
precision
Returns
UTF-8 string

References osmscout::Locale::GetDecimalSeparator(), osmscout::Locale::GetThousandsSeparator(), and NumberToString().

Referenced by ByteSizeToString().

◆ FormatMotorwayJunctionName()

◆ FormatName()

◆ FullTurnCommand()

static QString osmscout::FullTurnCommand ( const RouteDescription::DirectionDescriptionRef directionDescription)
static

◆ GenerateSearchPatterns()

static std::list<TokenStringRef> osmscout::GenerateSearchPatterns ( const std::list< std::string > &  tokens,
const std::unordered_set< std::string > &  patternExclusions,
size_t  maxWords 
)
static

◆ GetAstronomicalTwilight()

SunriseSunsetRes osmscout::GetAstronomicalTwilight ( const GeoCoord location,
const Timestamp day = Timestamp::clock::now() 
)

Calculate the astronomical twilight time for the given date and given location.

Parameters
dayThe day for which to calculate astronomical twilight
locationthe location
Returns
a two-element Gregorian Calendar array. The first element is the astronomical twilight dawn, the second element is the astronomical twilight dusk. This will return nullopt if there is no astronomical twilight. (Ex: no twilight in Antarctica in December)

References GetSunriseSunset().

◆ getCentroidCell()

Cell osmscout::getCentroidCell ( const Polygon polygon)

◆ GetCivilTwilight()

SunriseSunsetRes osmscout::GetCivilTwilight ( const GeoCoord location,
const Timestamp day = Timestamp::clock::now() 
)

Calculate the civil twilight time for the given date and given location.

Parameters
dayThe day for which to calculate civil twilight
locationthe location
Returns
a two-element Gregorian Calendar array. The first element is the civil twilight dawn, the second element is the civil twilight dusk. This will return nullopt if there is no civil twilight. (Ex: no twilight in Antarctica in December)

References GetSunriseSunset().

◆ GetFeatureStyle()

template<class S , class A >
std::shared_ptr<S> osmscout::GetFeatureStyle ( const StyleResolveContext context,
const std::vector< std::list< StyleSelector< S, A > > > &  styleSelectors,
const FeatureValueBuffer buffer,
const Projection projection 
)

◆ GetGridPoints()

static std::set<GeoCoord> osmscout::GetGridPoints ( const std::vector< Point > &  nodes,
double  gridSizeHoriz,
double  gridSizeVert 
)
static

References GetLineIntersection().

◆ GetHexChar()

static char osmscout::GetHexChar ( size_t  value)
static

◆ GetHexValue()

static size_t osmscout::GetHexValue ( char  digit)
static

◆ GetMaxLevelInConditionals()

template<class S , class A >
void osmscout::GetMaxLevelInConditionals ( const std::list< ConditionalStyle< S, A > > &  conditionals,
size_t &  maxLevel 
)

◆ GetNauticalTwilight()

SunriseSunsetRes osmscout::GetNauticalTwilight ( const GeoCoord location,
const Timestamp day = Timestamp::clock::now() 
)

Calculate the nautical twilight time for the given date and given location.

Parameters
dayThe day for which to calculate nautical twilight
locationthe location
Returns
a two-element Gregorian Calendar array. The first element is the nautical twilight dawn, the second element is the nautical twilight dusk. This will return nullopt if there is no nautical twilight. (Ex: no twilight in Antarctica in December)

References GetSunriseSunset().

◆ getSegDistSq()

double osmscout::getSegDistSq ( const GeoCoord p,
const Point a,
const Point b 
)

◆ GetSegmentBoundingBox()

template<typename N >
void osmscout::GetSegmentBoundingBox ( const std::vector< N > &  path,
size_t  from,
size_t  to,
GeoBox boundingBox 
)

Helper for FindPathIntersections.

Compute bounding box of path segment from node index from (inclusive) to node index to (exclusive)

References osmscout::GeoBox::Invalidate(), and osmscout::GeoBox::Set().

Referenced by ComputeSegmentBoxes(), and FindPathIntersections().

◆ GetSunriseSunset() [1/2]

SunriseSunsetRes osmscout::GetSunriseSunset ( const GeoCoord location,
const Timestamp day,
double  sunAltitude 
)

Calculate the sunrise and sunset times for the given date, given location, and sun altitude.

This is based on the Wikipedia article on the Sunrise equation.

Parameters
dayThe day for which to calculate sunrise and sunset
locationthe location
sunAltitudethe angle between the horizon and the center of the sun's disc.
Returns
a two-element Gregorian Calendar array. The first element is the sunrise, the second element is the sunset. This will return nullopt if there is no sunrise or sunset. (Ex: no sunrise in Antarctica in June)
See also
Sunrise equation on Wikipedia

References osmscout::GeoCoord::GetLat(), and osmscout::GeoCoord::GetLon().

Referenced by GetAstronomicalTwilight(), GetCivilTwilight(), GetNauticalTwilight(), and GetSunriseSunset().

◆ GetSunriseSunset() [2/2]

SunriseSunsetRes osmscout::GetSunriseSunset ( const GeoCoord location,
const Timestamp day = Timestamp::clock::now() 
)

Calculate the sunrise and sunset times for the given date and given location.

This is based on the Wikipedia article on the Sunrise equation.

Parameters
dayThe day for which to calculate sunrise and sunset
locationthe location
Returns
a two-element Gregorian Calendar array. The first element is the sunrise, the second element is the sunset. This will return nullopt if there is no sunrise or sunset. (Ex: no sunrise in Antarctica in June)
See also
Sunrise equation on Wikipedia

References GetSunriseSunset().

◆ GetTokensFromEnd()

std::string osmscout::GetTokensFromEnd ( const std::list< std::string > &  tokens,
size_t  count 
)

Referenced by GenerateSearchPatterns().

◆ GetTokensFromStart()

std::string osmscout::GetTokensFromStart ( const std::list< std::string > &  tokens,
size_t  count 
)

Referenced by GenerateSearchPatterns().

◆ GetUtcOffset()

int osmscout::GetUtcOffset ( )

returns the utc timezone offset (e.g.

-8 hours for PST)

Referenced by MkTimeUTC().

◆ HasStyle()

template<class S , class A >
bool osmscout::HasStyle ( const std::vector< std::vector< std::list< StyleSelector< S, A >>>> &  styleSelectors,
const size_t  level 
)

◆ IsLaneOffset()

◆ IsLowerByteSet() [1/2]

static bool osmscout::IsLowerByteSet ( const unsigned char *  bytes)
static

Referenced by LoadPNG(), and LoadPNGOpenGL().

◆ IsLowerByteSet() [2/2]

static bool osmscout::IsLowerByteSet ( unsigned char *  bytes)
static

◆ IsValidToWrite()

bool osmscout::IsValidToWrite ( const std::vector< Point > &  nodes)

◆ Kilometers()

◆ LabelInstanceSorter()

template<class NativeGlyph , class NativeLabel >
static bool osmscout::LabelInstanceSorter ( const LabelInstance< NativeGlyph, NativeLabel > &  a,
const LabelInstance< NativeGlyph, NativeLabel > &  b 
)
static

◆ LabelLayoutDataSorter()

static bool osmscout::LabelLayoutDataSorter ( const LabelData a,
const LabelData b 
)
inlinestatic

Sort labels for the same object by position.

References osmscout::LabelData::position.

◆ LaneTurnString()

◆ LayoutTextLayout()

void osmscout::LayoutTextLayout ( const QFontMetrics &  fontMetrics,
qreal  proposedWidth,
QTextLayout &  layout,
QRectF &  boundingBox 
)

◆ LoadPNG()

cairo_surface_t * osmscout::LoadPNG ( const std::string &  filename)

◆ LoadPNGOpenGL()

osmscout::OpenGLTextureRef osmscout::LoadPNGOpenGL ( const std::string &  filename)

References IsLowerByteSet().

◆ LoadShader()

bool osmscout::LoadShader ( GLuint &  shader,
GLenum  type,
const std::string &  name,
const std::string &  shaderSource 
)

◆ LoadShaderSource()

bool osmscout::LoadShaderSource ( const std::string &  dirPath,
const std::string &  name,
std::string &  result 
)

◆ log_pd() [1/3]

double osmscout::log_pd ( double  x)
inline

References log_pd().

◆ log_pd() [2/3]

double osmscout::log_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References log_pd().

◆ log_pd() [3/3]

v2df osmscout::log_pd ( v2df  x)
inline

References ARRAY2V2DF, ARRAY2V2DI, and POLY_EVAL3.

Referenced by atanh_pd(), and log_pd().

◆ MapPathOnPath()

static void osmscout::MapPathOnPath ( cairo_t *  draw,
cairo_path_t *  srcPath,
cairo_path_t *  dstPath,
double  xOffset,
double  yOffset 
)
static

◆ Meters()

◆ MkTimeUTC()

time_t osmscout::MkTimeUTC ( struct tm *  timeptr)

https://stackoverflow.com/a/9088549/1632737

the utc analogue of mktime, (much like timegm on some systems)

References GetUtcOffset().

Referenced by ParseISO8601TimeString().

◆ NumberDigits()

template<typename N >
size_t osmscout::NumberDigits ( const N &  number,
size_t  base = 10 
)

References base.

Referenced by StringToNumberSigned().

◆ NumberToString()

std::string osmscout::NumberToString ( long  value,
const Locale locale 
)

Returns locale-aware string representation of number.

Parameters
value
locale
Returns
UTF-8 string

References osmscout::Locale::GetThousandsSeparator().

Referenced by FloatToString(), osmscout::EleFeatureValue::GetLabel(), and osmscout::ElevationChartWidget::paint().

◆ operator!=()

bool osmscout::operator!= ( const MapView a,
const MapView b 
)
inline

◆ operator*()

Vertex2D osmscout::operator* ( const Vertex2D a,
double  scale 
)

◆ operator+() [1/3]

std::string osmscout::operator+ ( const char *  text,
const MagnificationLevel level 
)
inline

◆ operator+() [2/3]

std::string osmscout::operator+ ( const std::string &  text,
const MagnificationLevel level 
)
inline

◆ operator+() [3/3]

Vertex2D osmscout::operator+ ( const Vertex2D a,
const Vertex2D b 
)

◆ operator-()

Vertex2D osmscout::operator- ( const Vertex2D a,
const Vertex2D b 
)

◆ operator<()

bool osmscout::operator< ( const TileCacheKey a,
const TileCacheKey b 
)

◆ operator<<() [1/7]

QDebug & osmscout::operator<< ( QDebug &  out,
const TileCacheKey key 
)

◆ operator<<() [2/7]

std::ostream& osmscout::operator<< ( std::ostream &  os,
const Distance distance 
)
inline

◆ operator<<() [3/7]

std::ostream& osmscout::operator<< ( std::ostream &  os,
const MagnificationLevel level 
)
inline

◆ operator<<() [4/7]

std::ostream& osmscout::operator<< ( std::ostream &  stream,
const DBFileOffset o 
)
inline

◆ operator<<() [5/7]

std::ostream& osmscout::operator<< ( std::ostream &  stream,
const DBId o 
)
inline

◆ operator<<() [6/7]

std::ostream & osmscout::operator<< ( std::ostream &  stream,
const StopClock stopClock 
)

◆ operator<<() [7/7]

std::ostream & osmscout::operator<< ( std::ostream &  stream,
const StopClockNano stopClock 
)

◆ operator==() [1/3]

bool osmscout::operator== ( const MapView a,
const MapView b 
)
inline

◆ operator==() [2/3]

◆ operator==() [3/3]

bool osmscout::operator== ( const TileCacheKey a,
const TileCacheKey b 
)

◆ OptimizeArea()

◆ OptimizeWay()

◆ ParseBackwardTurnStringToOffset()

◆ ParseBoolArgument()

bool osmscout::ParseBoolArgument ( int  argc,
char *  argv[],
int &  currentIndex,
bool &  value 
)

References StringToBool().

◆ ParseForwardTurnStringToOffset()

◆ ParseISO8601TimeString()

bool osmscout::ParseISO8601TimeString ( const std::string &  timeStr,
Timestamp timestamp 
)

Parse time string in ISO 8601 format "2017-11-26T13:46:12.124Z" (UTC timezone) to Timestamp (std::chrono::time_point with millisecond accuracy).

Note that format is not locale specific

Parameters
timeStr
timestamp
Returns
true on success

References m, and MkTimeUTC().

◆ ParseSizeTArgument()

bool osmscout::ParseSizeTArgument ( int  argc,
char *  argv[],
int &  currentIndex,
size_t &  value 
)

References StringToNumber().

◆ ParseStringArgument()

bool osmscout::ParseStringArgument ( int  argc,
char *  argv[],
int &  currentIndex,
std::string &  value 
)

◆ ParseUInt32Argument()

bool osmscout::ParseUInt32Argument ( int  argc,
char *  argv[],
int &  currentIndex,
uint32_t &  value 
)

References StringToNumber().

◆ PathPointTransformer()

static void osmscout::PathPointTransformer ( double &  x,
double &  y,
cairo_path_t *  path,
const double *  pathSegmentLengths 
)
static

Project a point X,Y onto a parameterized path.

The final point is where you get if you walk on the path forward from the beginning for X units, then stop there and walk another Y units perpendicular to the path at that point. In more detail:

There's two pieces of math involved:

The parametric forms are used to answer the question of "where will I be if I walk a distance of X on this path". The Gradient is used to answer the question of "where will I be if then I stop, rotate left for 90 degrees and walk straight for a distance of Y".

Referenced by TransformPathOntoPath().

◆ PathVectorToQDirList()

QList< QDir > osmscout::PathVectorToQDirList ( const std::vector< std::filesystem::path > &  paths)

◆ pointToPolygonDist()

auto osmscout::pointToPolygonDist ( const GeoCoord point,
const Polygon polygon 
)

◆ PolygonCenter() [1/2]

◆ PolygonCenter() [2/2]

GeoCoord osmscout::PolygonCenter ( const std::vector< Point > &  polygon,
double  precision = 1 
)

◆ Pow()

size_t osmscout::Pow ( size_t  a,
size_t  b 
)

◆ qHash()

◆ QStringListToStringVector()

std::vector< std::string > osmscout::QStringListToStringVector ( const QStringList &  list)

◆ ReadFile()

bool osmscout::ReadFile ( const std::string &  filename,
std::vector< char > &  content 
)

◆ RoundDown()

static double osmscout::RoundDown ( double  value)
static

◆ RoundUp()

static double osmscout::RoundUp ( double  value)
static

◆ ScanCoordinate()

static bool osmscout::ScanCoordinate ( const std::string &  text,
size_t &  currentPos,
double &  value,
size_t  maxDigits 
)
static

References EatWhitespace(), and ScanNumber().

Referenced by osmscout::GeoCoord::Parse().

◆ ScanNumber()

static bool osmscout::ScanNumber ( const std::string &  text,
size_t &  currentPos,
double &  value,
size_t  maxDigits 
)
static

Referenced by ScanCoordinate().

◆ SearchForAddressForLocation()

static bool osmscout::SearchForAddressForLocation ( LocationIndexRef locationIndex,
const SearchParameter &  parameter,
const std::list< std::string > &  addressTokens,
const LocationSearchVisitor::Result &  locationMatch,
LocationSearchResult::MatchQuality  regionMatchQuality,
LocationSearchResult::MatchQuality  postalAreaMatchQuality,
LocationSearchResult::MatchQuality  locationMatchQuality,
LocationSearchResult result 
)
static

◆ SearchForLocationForPostalArea()

static bool osmscout::SearchForLocationForPostalArea ( LocationIndexRef locationIndex,
const SearchParameter &  parameter,
const std::string &  locationPattern,
const std::string &  addressPattern,
const PostalAreaSearchVisitor::Result &  postalAreaMatch,
LocationSearchResult::MatchQuality  regionMatchQuality,
LocationSearchResult::MatchQuality  postalAreaMatchQuality,
LocationSearchResult result,
BreakerRef breaker 
)
static

◆ SearchForLocationForRegion()

◆ SearchForPOIForRegion() [1/2]

static bool osmscout::SearchForPOIForRegion ( LocationIndexRef locationIndex,
const SearchParameter &  parameter,
const std::list< std::string > &  poiTokens,
const AdminRegionSearchVisitor::Result &  regionMatch,
LocationSearchResult::MatchQuality  regionMatchQuality,
LocationSearchResult result,
BreakerRef breaker 
)
static

◆ SearchForPOIForRegion() [2/2]

static bool osmscout::SearchForPOIForRegion ( LocationIndexRef locationIndex,
const SearchParameter &  parameter,
const std::string &  poiPattern,
const AdminRegionSearchVisitor::Result &  regionMatch,
LocationSearchResult::MatchQuality  regionMatchQuality,
LocationSearchResult result,
BreakerRef breaker 
)
static

◆ SearchForPostalAreaForRegion()

static bool osmscout::SearchForPostalAreaForRegion ( LocationIndexRef locationIndex,
const SearchParameter &  parameter,
const std::string &  postalAreaPattern,
const std::string &  locationPattern,
const std::string &  addressPattern,
const AdminRegionSearchVisitor::Result &  regionMatch,
LocationSearchResult::MatchQuality  regionMatchQuality,
LocationSearchResult result,
BreakerRef breaker 
)
static

◆ SetThreadName() [1/3]

bool osmscout::SetThreadName ( [[maybe_unused] ] const std::string &  name)

◆ SetThreadName() [2/3]

bool osmscout::SetThreadName ( const std::string &  name)

Try to set current thread name.

Parameters
name
Returns
true if supported and successful, else otherwise

Referenced by osmscout::AsyncWorker::AsyncWorker().

◆ SetThreadName() [3/3]

bool osmscout::SetThreadName ( std::thread &  thread,
const std::string &  name 
)

Try to set thread name.

Parameters
thread
name
Returns
true if supported and successful, else otherwise

◆ ShortTurnCommand()

static QString osmscout::ShortTurnCommand ( const RouteDescription::DirectionDescriptionRef directionDescription)
static

◆ SimplifyPolyLineDouglasPeucker()

static void osmscout::SimplifyPolyLineDouglasPeucker ( TransPoint points,
size_t  beginIndex,
size_t  endIndex,
size_t  endValueIndex,
double  optimizeErrorToleranceSquared 
)
static

◆ sin_cos_pd()

void osmscout::sin_cos_pd ( double  x,
double &  res_sin,
double &  res_cos 
)
inline

References sin_pd().

◆ sin_pd() [1/3]

double osmscout::sin_pd ( double  x)
inline

References sin_pd().

◆ sin_pd() [2/3]

void osmscout::sin_pd ( double  x,
double  y,
double &  res_x,
double &  res_y 
)
inline

References sin_pd().

◆ sin_pd() [3/3]

v2df osmscout::sin_pd ( v2df  x)
inline

References ARRAY2V2DF, and POLY_EVAL6.

Referenced by sin_cos_pd(), and sin_pd().

◆ sincos()

void osmscout::sincos ( double  x,
double &  resSin,
double &  resCos 
)
inline

◆ SortInConditionals()

template<class S , class A >
void osmscout::SortInConditionals ( const TypeConfig typeConfig,
const std::list< ConditionalStyle< S, A > > &  conditionals,
size_t  maxLevel,
std::vector< std::vector< std::list< StyleSelector< S, A > > > > &  selectors 
)

◆ SortInConditionalsBySlot()

template<class S , class A >
void osmscout::SortInConditionalsBySlot ( const TypeConfig typeConfig,
const std::list< ConditionalStyle< S, A > > &  conditionals,
size_t  maxLevel,
std::vector< std::vector< std::vector< std::list< StyleSelector< S, A > > > > > &  selectors 
)

References SortInConditionals().

◆ SplitDestinations()

static QStringList osmscout::SplitDestinations ( const std::string &  destinations)
static

◆ SplitStringToPair()

std::optional< std::pair< std::string, std::string > > osmscout::SplitStringToPair ( const std::string &  str,
const std::string &  separator 
)

Split string by separator to two parts.

Unlike SplitString with maxSize=2, second element contains the rest of the string after first separator. When no separator found, nullopt is returned.

Note
when str is empty nullopt is returned
separator must not be empty
when string ends with separator, and there is just one, second element is empty

Referenced by osmscout::OpeningHours::Parse().

◆ StringToNumberSigned()

template<typename N >
bool osmscout::StringToNumberSigned ( const std::string &  string,
N &  number,
size_t  base = 10 
)

References base, GetDigitValue(), and NumberDigits().

◆ StringToNumberUnsigned()

template<typename N >
bool osmscout::StringToNumberUnsigned ( const std::string &  string,
N &  number,
size_t  base = 10 
)

References base, and GetDigitValue().

Referenced by osmscout::TextSearchIndex::Load().

◆ StringVectorToQStringList()

QStringList osmscout::StringVectorToQStringList ( const std::vector< std::string > &  v)

◆ ThreadExitSignal()

Signal< std::thread::id > & osmscout::ThreadExitSignal ( )

Signal that is emitted on thread exit.

It is not guaranteed that signal will be emitted for all threads, some threads may be still running on program exit. For example detached thread, global scheduler threads, when std::exit is called...

◆ TimestampToISO8601TimeString()

std::string osmscout::TimestampToISO8601TimeString ( const Timestamp timestamp)

Format Timestamp to string in ISO8601 format "2017-11-26T13:46:12.124Z" for UTC timezone.

Parameters
timestamp
Returns
time string

Referenced by osmscout::PositionAgent::Process().

◆ TimestampToQDateTime()

QDateTime osmscout::TimestampToQDateTime ( const osmscout::Timestamp ts)

◆ TransformArea() [1/2]

template<typename C >
void osmscout::TransformArea ( const C &  nodes,
TransBuffer buffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance,
TransPolygon::OutputConstraint  constraint = TransPolygon::noConstraint 
)

Transform form geo to screen coordinates and (optionally) optimize the passed area with the given coordinates.

Template Parameters
Ccontainer type for the geo coordinates of the area
Parameters
nodesArea coordinates
bufferTransBuffer instance for memory caching
projectionProjection to use
optimizeMode of optimization
optimizeErrorTolerance
constraint

References osmscout::TransPolygon::none, OptimizeArea(), osmscout::TransBuffer::Reset(), and osmscout::TransBuffer::TransformGeoToPixel().

Referenced by TransformArea(), and TransformBoundingBox().

◆ TransformArea() [2/2]

template<typename C >
CoordBufferRange osmscout::TransformArea ( const C &  nodes,
TransBuffer transBuffer,
CoordBuffer coordBuffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance 
)

Transform the geo coordinates to display coordinates of the given area and copy the resulting coordinates the the given CoordBuffer.

Template Parameters
CContainer type for the geo coordinates of the area
Parameters
nodesarea coordinates
transBufferTransBuffer instance for memory caching
coordBufferTarget CoordBuffer
projectionProjection to use
optimize
optimizeErrorTolerance
Returns
The resulting coordinate range in the CoordBuffer

References CopyPolygonToCoordBuffer(), osmscout::TransBuffer::IsEmpty(), and TransformArea().

◆ TransformBoundingBox() [1/2]

void osmscout::TransformBoundingBox ( const GeoBox boundingBox,
TransBuffer buffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance,
TransPolygon::OutputConstraint  constraint = TransPolygon::noConstraint 
)

Transform form geo to screen coordinates and (optionally) optimize the passed way with the given coordinates.

Template Parameters
CContainer type for the geo coordinates of the area
Parameters
boundingBoxbounding box
bufferTransBuffer instance for memory caching
projectionProjection to use
optimizeMode of optimization
optimizeErrorTolerance
constraint

References osmscout::GeoBox::GetMaxLat(), osmscout::GeoBox::GetMaxLon(), osmscout::GeoBox::GetMinLat(), osmscout::GeoBox::GetMinLon(), and TransformArea().

Referenced by osmscout::MapPainter::DrawContourLines(), osmscout::MapPainter::DrawHillShading(), and TransformBoundingBox().

◆ TransformBoundingBox() [2/2]

CoordBufferRange osmscout::TransformBoundingBox ( const GeoBox boundingBox,
TransBuffer buffer,
CoordBuffer coordBuffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance 
)

Transform the geo coordinates to display coordinates of the given bounding box and copy the resulting coordinates the the given CoordBuffer.

Template Parameters
CContainer type for the geo coordinates of the area
Parameters
boundingBoxbounding box
transBufferTransBuffer instance for memory caching
coordBufferTarget CoordBuffer
projectionProjection to use
optimize
optimizeErrorTolerance
Returns
The resulting coordinate range in the CoordBuffer

References CopyPolygonToCoordBuffer(), osmscout::TransBuffer::IsEmpty(), and TransformBoundingBox().

◆ TransformPathOntoPath()

static void osmscout::TransformPathOntoPath ( cairo_path_t *  srcPath,
cairo_path_t *  dstPath,
double *  pathSegmentLengths,
double  xOffset,
double  yOffset 
)
static

Project a path using a function.

Each point of the path (including Bezier control points) is passed to the function for transformation.

References PathPointTransformer().

Referenced by MapPathOnPath().

◆ TransformWay() [1/2]

template<typename C >
void osmscout::TransformWay ( const C &  nodes,
TransBuffer buffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance,
TransPolygon::OutputConstraint  constraint = TransPolygon::noConstraint 
)

Transform form geo to screen coordinates and (optionally) optimize the passed way with the given coordinates.

Template Parameters
Ccontainer type for the geo coordinates of the area
Parameters
nodesArea coordinates
bufferTransBuffer instance for memory caching
projectionProjection to use
optimizeMode of optimization
optimizeErrorTolerance
constraint

References osmscout::TransPolygon::none, OptimizeWay(), osmscout::TransBuffer::Reset(), and osmscout::TransBuffer::TransformGeoToPixel().

Referenced by osmscout::MapPainter::DrawContourLines(), and TransformWay().

◆ TransformWay() [2/2]

template<typename C >
CoordBufferRange osmscout::TransformWay ( const C &  nodes,
TransBuffer transBuffer,
CoordBuffer coordBuffer,
const Projection projection,
TransPolygon::OptimizeMethod  optimize,
double  optimizeErrorTolerance 
)

Transform the geo coordinates to display coordinates of the given way and copy the resulting coordinates the the given CoordBuffer.

Template Parameters
CContainer type for the geo coordinates of the area
Parameters
nodesway coordinates
transBufferTransBuffer instance for memory caching
coordBufferTarget CoordBuffer
projectionProjection to use
optimize
optimizeErrorTolerance
Returns
The resulting coordinate range in the CoordBuffer

References CopyPolygonToCoordBuffer(), osmscout::TransBuffer::IsEmpty(), and TransformWay().

◆ Trim()

std::string osmscout::Trim ( const std::string &  str,
char  trimmedChar = ' ' 
)

Trim trimmedChar from begin and end of str.

Referenced by osmscout::OpeningHours::Parse(), and osmscout::EleFeature::Parse().

◆ TurnCommandType()

static QString osmscout::TurnCommandType ( const RouteDescription::DirectionDescriptionRef directionDescription)
static

◆ TurnCommandWithList()

static QString osmscout::TurnCommandWithList ( const RouteDescription::DirectionDescriptionRef directionDescription)
static

◆ UTF8NormForLookup()

std::string osmscout::UTF8NormForLookup ( const std::string &  text)

Normalise the given std::string containing a UTF8 character sequence for tolerant comparison.

It may be used for string lookup typed by human, for example street name, where string are not binary equals, but are "same" for human - for example "Baker Street" and "Baker street"

Normalized string is converted to lowercase, all whitespaces are converted to standard space and multiple following spaces are collapsed to one.

Parameters
textText to get converted
Returns
Converted text

References utf8helper::UTF8Normalize().

Referenced by osmscout::SearchRunnable::GetObjectDetails(), and osmscout::TextSearchIndex::Search().

◆ UTF8StringToLower()

std::string osmscout::UTF8StringToLower ( const std::string &  text)

Convert the given std::string containing a UTF8 character sequence to lower case using the translation table implementation.

Parameters
textText to get converted
Returns
Converted text

References utf8helper::UTF8ToLower().

Referenced by osmscout::ColorFeature::Parse().

◆ UTF8StringToUpper()

std::string osmscout::UTF8StringToUpper ( const std::string &  text)

◆ UTF8Transliterate()

std::string osmscout::UTF8Transliterate ( const std::string &  text)

Transliterate non-ascii characters to one or more characters that are similar to the original character.

When there is no transformation available, original character is keep in place (translation table implementation).

Parameters
textText to get converted
Returns
Converted text

References utf8helper::UTF8Transliterate().

Referenced by osmscout::SearchRunnable::GetObjectDetails(), osmscout::StringMatcherTransliterate::Match(), and osmscout::TextSearchIndex::Search().

◆ vectorToQList()

template<typename T >
QList<T> osmscout::vectorToQList ( const std::vector< T > &  vec)

◆ vehicleStr()

std::string osmscout::vehicleStr ( osmscout::Vehicle  vehicle)

Variable Documentation

◆ ALIGN16_END

const ALIGN16_BEG double _pd_log_inv_1_32 [2] osmscout::ALIGN16_END

◆ Base64Chars

constexpr const char* osmscout::Base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
constexpr

Referenced by Base64Decode(), and Base64Encode().

◆ borderStyleDescriptor

const StyleDescriptorRef osmscout::borderStyleDescriptor =std::make_shared<BorderStyleDescriptor>()
static

◆ CELL_DIMENSION_COUNT

const size_t osmscout::CELL_DIMENSION_COUNT = CELL_DIMENSION_MAX+1

◆ CELL_DIMENSION_MAX

const size_t osmscout::CELL_DIMENSION_MAX = 25

◆ cellDimension

const std::array< CellDimension, CELL_DIMENSION_COUNT > osmscout::cellDimension
Initial value:
= {
CellDimension{360.0, 180.0 },
CellDimension{ 180.0, 90.0 },
CellDimension{ 90.0, 45.0 },
CellDimension{ 45.0, 22.5 },
CellDimension{ 22.5, 11.25 },
CellDimension{ 11.25, 5.625 },
CellDimension{ 5.625, 2.8125 },
CellDimension{ 2.8125, 1.40625 },
CellDimension{ 1.40625, 0.703125 },
CellDimension{ 0.703125, 0.3515625 },
CellDimension{ 0.3515625, 0.17578125 },
CellDimension{ 0.17578125, 0.087890625 },
CellDimension{ 0.087890625, 0.0439453125 },
CellDimension{ 0.0439453125, 0.02197265625 },
CellDimension{ 0.02197265625, 0.010986328125 },
CellDimension{ 0.010986328125, 0.0054931640625 },
CellDimension{ 0.0054931640625, 0.00274658203125 },
CellDimension{ 0.00274658203125, 0.001373291015625 },
CellDimension{ 0.001373291015625, 0.0006866455078125 },
CellDimension{ 0.0006866455078125, 0.00034332275390625 },
CellDimension{ 0.00034332275390625, 0.000171661376953125 },
CellDimension{ 0.000171661376953125, 0.0000858306884765625 },
CellDimension{ 0.0000858306884765625, 0.00004291534423828125 },
CellDimension{ 0.00004291534423828125, 0.000021457672119140625 },
CellDimension{ 0.000021457672119140625, 0.0000107288360595703125 },
CellDimension{ 0.0000107288360595703125, 0.0000107288360595703125 }
}

Referenced by osmscout::AreaAreaIndex::GetAreasInArea(), osmscout::TileId::GetBoundingBox(), osmscout::TileKey::GetBoundingBox(), osmscout::TileId::GetTile(), and osmscout::TileId::GetTopLeftCoord().

◆ debugGroundTiles

constexpr bool osmscout::debugGroundTiles = false
constexpr

◆ debugLabelLayouter

◆ debugRouting

◆ DELTA_ANGLE

double osmscout::DELTA_ANGLE =2*M_PI/16.0
static

We rotate in 16 steps.

Referenced by osmscout::MapWidget::rotateLeft(), and osmscout::MapWidget::rotateRight().

◆ FILE_FORMAT_VERSION

const uint32_t osmscout::FILE_FORMAT_VERSION =25
static

◆ fillStyleDescriptor

const StyleDescriptorRef osmscout::fillStyleDescriptor =std::make_shared<FillStyleDescriptor>()
static

◆ FONT_HEIGHT_FACTOR

double osmscout::FONT_HEIGHT_FACTOR =10
static

Height of the font in pixel in relation to the given fontSize.

Referenced by osmscout::MapPainterNoOp::GetFontHeight().

◆ gradtorad

◆ iconStyleDescriptor

const StyleDescriptorRef osmscout::iconStyleDescriptor =std::make_shared<IconStyleDescriptor>()
static

◆ imageDataKey

cairo_user_data_key_t osmscout::imageDataKey

Referenced by LoadPNG().

◆ INITIAL_DATA_RENDERING_TIMEOUT

int osmscout::INITIAL_DATA_RENDERING_TIMEOUT = 10
static

◆ lineStyleDescriptor

const StyleDescriptorRef osmscout::lineStyleDescriptor =std::make_shared<LineStyleDescriptor>()
static

◆ maxRawCoordValue

constexpr uint32_t osmscout::maxRawCoordValue = 0x7FFFFFF
constexpr

◆ osmScoutInstance

◆ pathShieldStyleDescriptor

const StyleDescriptorRef osmscout::pathShieldStyleDescriptor =std::make_shared<PathShieldStyleDescriptor>()
static

◆ pathSymbolStyleDescriptor

const StyleDescriptorRef osmscout::pathSymbolStyleDescriptor =std::make_shared<PathSymbolStyleDescriptor>()
static

◆ pathTextStyleDescriptor

const StyleDescriptorRef osmscout::pathTextStyleDescriptor =std::make_shared<PathTextStyleDescriptor>()
static

◆ textStyleDescriptor

const StyleDescriptorRef osmscout::textStyleDescriptor =std::make_shared<TextStyleDescriptor>()
static

◆ tileDPI

const double osmscout::tileDPI =96.0
static

◆ UPDATED_DATA_RENDERING_TIMEOUT

int osmscout::UPDATED_DATA_RENDERING_TIMEOUT = 200
static

◆ valueChar

const char* osmscout::valueChar ="0123456789abcdef"
static

◆ X_STEP_0

constexpr int osmscout::X_STEP_0 = 0
constexpr

The X flag is set as follows based on the locking steps Step 0 : X is released Step 1 : X is held, but waits for release of S Step 2 : X was released and left available for one of request in wait Step 3 : X is held Step N : X recursive N-3.

Referenced by osmscout::Latch::lock(), osmscout::Latch::lock_shared(), osmscout::Latch::try_lock_shared(), and osmscout::Latch::unlock().

◆ X_STEP_1

constexpr int osmscout::X_STEP_1 = 1
constexpr

◆ X_STEP_2

constexpr int osmscout::X_STEP_2 = 2
constexpr

◆ X_STEP_3

constexpr int osmscout::X_STEP_3 = 3
constexpr