Maps.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless
// expressly authorized by NVIDIA.  Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2017-2020 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//

#ifndef DW_MAPS_MAPS_H_
#define DW_MAPS_MAPS_H_

#include <dw/core/Config.h>
#include <dw/core/Exports.h>
#include <dw/core/Status.h>
#include <dw/core/Types.h>
#include <dw/core/Context.h>
#include <dw/worldmodel/Location.h>

#ifdef __cplusplus
extern "C" {
#endif

//#######################################################################################
// Handles
//#######################################################################################
typedef struct dwMapObject* dwMapHandle_t;
typedef struct dwMapObject const* dwConstMapHandle_t;

typedef struct dwMapsLocalLayoutObject* dwMapsLocalLayoutHandle_t;
typedef struct dwMapsLocalLayoutObject const* dwConstMapsLocalLayoutHandle_t;

//#######################################################################################
// Forward declarations
//#######################################################################################
typedef struct dwMapsLaneDivider dwMapsLaneDivider;
typedef struct dwMapsLaneDividerGroup dwMapsLaneDividerGroup;
typedef struct dwMapsLaneGroup dwMapsLaneGroup;
typedef struct dwMapsLane dwMapsLane;
typedef struct dwMapsLaneMeta dwMapsLaneMeta;
typedef struct dwMapsRoadSegment dwMapsRoadSegment;
typedef struct dwMapsLaneWaitElement dwMapsLaneWaitElement;
typedef struct dwMapsLaneWaitGroup dwMapsLaneWaitGroup;

//#######################################################################################
// Enums
//#######################################################################################
typedef enum dwMapsMaterial {
    DW_MAPS_MATERIAL_UNKNOWN     = 1 << 0,
    DW_MAPS_MATERIAL_METAL       = 1 << 1,
    DW_MAPS_MATERIAL_CONCRETE    = 1 << 2,
    DW_MAPS_MATERIAL_STONE       = 1 << 3,
    DW_MAPS_MATERIAL_WOOD        = 1 << 4,
    DW_MAPS_MATERIAL_PLASTIC     = 1 << 5,
    DW_MAPS_MATERIAL_TRANSPARENT = 1 << 6,
    DW_MAPS_MATERIAL_PAINT       = 1 << 7,
    DW_MAPS_MATERIAL_BOTTS_DOT   = 1 << 8
} dwMapsMaterial;

typedef enum dwMapsColor {
    DW_MAPS_COLOR_UNKNOWN    = 1 << 0,
    DW_MAPS_COLOR_WHITE      = 1 << 1,
    DW_MAPS_COLOR_LIGHT_GRAY = 1 << 2,
    DW_MAPS_COLOR_GRAY       = 1 << 3,
    DW_MAPS_COLOR_DARK_GRAY  = 1 << 4,
    DW_MAPS_COLOR_BLACK      = 1 << 5,
    DW_MAPS_COLOR_RED        = 1 << 6,
    DW_MAPS_COLOR_YELLOW     = 1 << 7,
    DW_MAPS_COLOR_GREEN      = 1 << 8,
    DW_MAPS_COLOR_CYAN       = 1 << 9,
    DW_MAPS_COLOR_BLUE       = 1 << 10,
    DW_MAPS_COLOR_ORANGE     = 1 << 11
} dwMapsColor;

typedef enum dwMapsLaneDividerType {
    DW_MAPS_LANE_DIVIDER_TYPE_INVISIBLE        = 1 << 0,
    DW_MAPS_LANE_DIVIDER_TYPE_LONG_DASHED      = 1 << 1,
    DW_MAPS_LANE_DIVIDER_TYPE_DOUBLE_SOLID     = 1 << 2,
    DW_MAPS_LANE_DIVIDER_TYPE_SINGLE_SOLID     = 1 << 3,
    DW_MAPS_LANE_DIVIDER_TYPE_SOLID_DASHED     = 1 << 4,
    DW_MAPS_LANE_DIVIDER_TYPE_DASHED_SOLID     = 1 << 5,
    DW_MAPS_LANE_DIVIDER_TYPE_SHORT_DASHED     = 1 << 6,
    DW_MAPS_LANE_DIVIDER_TYPE_SHADED_AREA      = 1 << 7,
    DW_MAPS_LANE_DIVIDER_TYPE_DASHED_BLOCKS    = 1 << 8,
    DW_MAPS_LANE_DIVIDER_TYPE_DOUBLE_DASHED    = 1 << 9,
    DW_MAPS_LANE_DIVIDER_TYPE_CROSSING_ALERT   = 1 << 10,
    DW_MAPS_LANE_DIVIDER_TYPE_CENTER_TURN_LANE = 1 << 12,
    DW_MAPS_LANE_DIVIDER_TYPE_PHYSICAL         = 1 << 13,
    DW_MAPS_LANE_DIVIDER_TYPE_CURB             = 1 << 14,
    DW_MAPS_LANE_DIVIDER_TYPE_WALL_FLAT        = 1 << 15,
    DW_MAPS_LANE_DIVIDER_TYPE_WALL_TUNNEL      = 1 << 16,
    DW_MAPS_LANE_DIVIDER_TYPE_BARRIER_JERSEY   = 1 << 17,
    DW_MAPS_LANE_DIVIDER_TYPE_BARRIER_SOUND    = 1 << 18,
    DW_MAPS_LANE_DIVIDER_TYPE_BARRIER_CABLE    = 1 << 19,
    DW_MAPS_LANE_DIVIDER_TYPE_GUARDRAIL        = 1 << 20,
    DW_MAPS_LANE_DIVIDER_TYPE_FENCE            = 1 << 21,
    DW_MAPS_LANE_DIVIDER_TYPE_RUBBER_POLE      = 1 << 22,
    DW_MAPS_LANE_DIVIDER_TYPE_ROAD_STUDS       = 1 << 23,
    DW_MAPS_LANE_DIVIDER_TYPE_ROAD_EDGE        = 1 << 24,

    DW_MAPS_LANE_DIVIDER_TYPE_ALL = (1u << 25) - 1u
} dwMapsLaneDividerType;

typedef enum dwMapsLaneType {
    DW_MAPS_LANE_TYPE_REGULAR           = 1 << 0,
    DW_MAPS_LANE_TYPE_SHOULDER          = 1 << 1,
    DW_MAPS_LANE_TYPE_DRIVABLE_SHOULDER = 1 << 2,
    DW_MAPS_LANE_TYPE_CAR_POOL          = 1 << 3,
    DW_MAPS_LANE_TYPE_ENTRY             = 1 << 4,
    DW_MAPS_LANE_TYPE_EXIT              = 1 << 5,
    DW_MAPS_LANE_TYPE_CONNECT           = 1 << 6,
    DW_MAPS_LANE_TYPE_EMERGENCY         = 1 << 7,
    DW_MAPS_LANE_TYPE_STOP              = 1 << 8,
    DW_MAPS_LANE_TYPE_EMERGENCY_STOP    = 1 << 9,
    DW_MAPS_LANE_TYPE_ACCELERATE        = 1 << 10,
    DW_MAPS_LANE_TYPE_DECELERATE        = 1 << 11,
    DW_MAPS_LANE_TYPE_AVOID_DANGER      = 1 << 12,
    DW_MAPS_LANE_TYPE_INTERSECTION      = 1 << 13,
    DW_MAPS_LANE_TYPE_TOLL_GATE         = 1 << 14,
    DW_MAPS_LANE_TYPE_CHECK_POINT       = 1 << 15,
    DW_MAPS_LANE_TYPE_TURN_AROUND       = 1 << 16,
    DW_MAPS_LANE_TYPE_FORMING           = 1 << 17,
    DW_MAPS_LANE_TYPE_DESTROY           = 1 << 18,
    DW_MAPS_LANE_TYPE_RAMP              = 1 << 19,
    DW_MAPS_LANE_TYPE_BICYCLE           = 1 << 20,
    DW_MAPS_LANE_TYPE_PEDESTRIAN        = 1 << 21,
} dwMapsLaneType;

typedef enum dwMapsDirection {
    DW_MAPS_DIRECTION_FORWARD  = 1 << 0,
    DW_MAPS_DIRECTION_BACKWARD = 1 << 1,
    DW_MAPS_DIRECTION_BOTH     = 1 << 2,
    DW_MAPS_DIRECTION_NONE     = 1 << 3
} dwMapsDirection;

typedef enum dwMapsRoadSegmentType {
    DW_MAPS_ROAD_SEGMENT_TYPE_DEFAULT = 0,

    DW_MAPS_ROAD_SEGMENT_TYPE_CONTROLLED_ACCESS = 1 << 0,
    DW_MAPS_ROAD_SEGMENT_TYPE_BRIDGE            = 1 << 1,
    DW_MAPS_ROAD_SEGMENT_TYPE_TUNNEL            = 1 << 2,
    DW_MAPS_ROAD_SEGMENT_TYPE_RAMP              = 1 << 3,
    DW_MAPS_ROAD_SEGMENT_TYPE_URBAN             = 1 << 4,
    DW_MAPS_ROAD_SEGMENT_TYPE_TOLLWAY           = 1 << 5,
    DW_MAPS_ROAD_SEGMENT_TYPE_INTERSECTION      = 1 << 6,
    DW_MAPS_ROAD_SEGMENT_TYPE_HIGHWAY           = 1 << 7
} dwMapsRoadSegmentType;

typedef enum dwMapsFeatureType {
    DW_MAPS_FEATURE_UNKNOWN       = 0,
    DW_MAPS_FEATURE_TRAFFIC_SIGN  = 1 << 16,
    DW_MAPS_FEATURE_TRAFFIC_LIGHT = 1 << 17,
    DW_MAPS_FEATURE_ROAD_MARKING  = 1 << 18,
    DW_MAPS_FEATURE_POLE          = 1 << 19,
    DW_MAPS_FEATURE_SPEEDBUMP     = 1 << 20
} dwMapsFeatureType;

typedef enum dwMapsRoadMarkingType {
    DW_MAPS_ROAD_MARKING_TYPE_UNKNOWN    = 0,                                                                
    DW_MAPS_ROAD_MARKING_TYPE_LINE       = 1,                                                                
    DW_MAPS_ROAD_MARKING_TYPE_AREA       = 1 << 1,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_ENTRY      = 1 << 2,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_EXIT       = 1 << 3,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_CROSSWALK  = 1 << 4,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_SYMBOL     = 1 << 5,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_ARROW      = 1 << 6,                                                           
    DW_MAPS_ROAD_MARKING_TYPE_ENTRY_LINE = DW_MAPS_ROAD_MARKING_TYPE_ENTRY | DW_MAPS_ROAD_MARKING_TYPE_LINE, 
    DW_MAPS_ROAD_MARKING_TYPE_EXIT_LINE  = DW_MAPS_ROAD_MARKING_TYPE_EXIT | DW_MAPS_ROAD_MARKING_TYPE_LINE,  
    DW_MAPS_ROAD_MARKING_TYPE_ENTRY_AREA = DW_MAPS_ROAD_MARKING_TYPE_ENTRY | DW_MAPS_ROAD_MARKING_TYPE_AREA, 
    DW_MAPS_ROAD_MARKING_TYPE_EXIT_AREA  = DW_MAPS_ROAD_MARKING_TYPE_EXIT | DW_MAPS_ROAD_MARKING_TYPE_AREA,  
} dwMapsRoadMarkingType;

typedef enum dwMapsSide {
    DW_MAPS_SIDE_LEFT  = DW_SIDE_LEFT,
    DW_MAPS_SIDE_RIGHT = DW_SIDE_RIGHT,
    DW_MAPS_SIDE_NONE  = DW_SIDE_CENTER
} dwMapsSide;

typedef enum dwMapsLaneGeometry {
    DW_MAPS_LANE_GEOMETRY_LANEDIVIDERLEFT  = DW_SIDE_LEFT,
    DW_MAPS_LANE_GEOMETRY_LANEDIVIDERRIGHT = DW_SIDE_RIGHT,
    DW_MAPS_LANE_GEOMETRY_LANECENTER       = DW_SIDE_CENTER
} dwMapsLaneGeometry;

typedef enum dwMapsHDCompliance {
    DW_MAPS_HD_COMPLIANCE_NO  = 0,
    DW_MAPS_HD_COMPLIANCE_YES = 1
} dwMapsHDCompliance;

typedef enum dwMapsTrafficSignalState {
    DW_MAPS_TRAFFIC_SIGNAL_STATE_NONE     = 0,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_RED      = 1 << 0,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_YELLOW   = 1 << 1,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_GREEN    = 1 << 2,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_STEADY   = 1 << 3,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_FLASHING = 1 << 4,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_ARROW    = 1 << 5,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_LEFT     = 1 << 6,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_RIGHT    = 1 << 7,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_STRAIGHT = 1 << 8,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_ANGLED   = 1 << 9,
    DW_MAPS_TRAFFIC_SIGNAL_STATE_MAXIMUM  = 1 << 10
} dwMapsTrafficSignalState;

/*
 * Bitmask to specify the traversability of two adjacent lanes in a lane group.
 * This value must be respected when evaluating lane changes for a lane plan.
 */
typedef enum dwMapsLaneTraversability {
    DW_MAPS_LANE_TRAVERSABILITY_NONE          = 0,
    DW_MAPS_LANE_TRAVERSABILITY_LEFT_TO_RIGHT = 1 << 0,
    DW_MAPS_LANE_TRAVERSABILITY_RIGHT_TO_LEFT = 1 << 1
} dwMapsLaneTraversability;

typedef uint32_t dwMapsLaneTraversabilityMask;

//#######################################################################################
// Global ID structs
//#######################################################################################
typedef struct dwMapsLaneDividerGroupId
{
    uint64_t id[4]; 
} dwMapsLaneDividerGroupId;

typedef struct dwMapsLaneId
{
    uint64_t id[4]; 
} dwMapsLaneId;

typedef struct dwMapsRoadSegmentId
{
    uint64_t id[3]; 
} dwMapsRoadSegmentId;

typedef struct dwMapsElementId
{
    uint64_t id[2]; 
} dwMapsElementId;

//#######################################################################################
// Connection structs
//#######################################################################################

#define DW_MAPS_MAX_LANE_CONNECTIONS 100

typedef struct dwMapsLaneConnection
{
    dwMapsLaneId laneId;    
    const dwMapsLane* lane; 
    bool sameDirection;     
} dwMapsLaneConnection;

typedef struct dwMapsRoadSegmentConnection
{
    dwMapsRoadSegmentId segmentId;       
    const dwMapsRoadSegment* segment;    
    bool sameDirection;                  
    dwTransformation3f connectedToLocal; 
} dwMapsRoadSegmentConnection;

//#######################################################################################
// Data structs
//#######################################################################################

typedef dwGeoPoint dwMapsGeoPoint;

typedef struct dwMapsLine
{
    dwVector3f p[2]; 
} dwMapsLine;

typedef struct dwMapsGeoPolyline
{
    const dwMapsGeoPoint* points; 
    uint32_t pointCount;          
} dwMapsGeoPolyline;

struct dwMapsLaneDivider
{
    dwMapsLaneDividerType type; 
    dwMapsMaterial material;    
    dwMapsColor color;          

    DW_DEPRECATED("replaced by `geometry`")
    dwMapsGeoPolyline absGeometry; 
    dwPolyline3f geometry;         

    const dwMapsLaneDividerGroup* group; 
};

typedef struct dwMapsLaneDividerLine
{
    dwVector3f p[2];                  
    const dwMapsLaneDivider* divider; 
} dwMapsLaneDividerLine;

struct dwMapsLaneDividerGroup
{
    dwMapsLaneDividerGroupId id; 

    const dwMapsLaneDivider* laneDividers; 
    uint32_t laneDividerCount;             

    const dwMapsRoadSegment* roadSegment; 
};

typedef uint64_t dwMapsFeatureId;
#define DW_MAPS_INVALID_FEATURE_ID (ULONG_MAX)

struct dwMapsLaneGroup
{
    uint32_t laneCount;                                 
    const dwMapsLane* const* lanes;                     
    const dwMapsLaneTraversabilityMask* traversability; 

    const dwMapsRoadSegment* roadSegment; 
};

struct dwMapsLaneMeta
{
    dwMapsLaneId id;                  
    dwMapsLaneType type;              
    dwMapsDirection drivingDirection; 
    float32_t speedLimit;             
};

struct dwMapsLane
{
    dwMapsLaneId id; 

    dwMapsLaneType type;              
    dwMapsDirection drivingDirection; 
    float32_t speedLimit;             

    DW_DEPRECATED("replaced by `geometry`")
    dwMapsGeoPolyline absGeometry; 
    dwPolyline3f geometry;         

    const dwMapsLaneGroup* laneGroup; 

    const dwMapsLaneDividerGroup* laneDividerGroups[2]; 

    const dwMapsLaneConnection* next; 
    uint32_t nextCount;               

    const dwMapsLaneConnection* previous; 
    uint32_t previousCount;               

    const dwMapsRoadSegment* roadSegment; 

    const dwMapsLaneWaitElement* waitElements; 
    uint32_t waitElementCount;                 

    const dwMapsLaneWaitGroup* waitGroups; 
    uint32_t waitGroupCount;               
};

typedef struct dwMapsFeature
{
    uint64_t id;   
    uint32_t type; 

    DW_DEPRECATED("replaced by `geometry`")
    dwMapsGeoPolyline absGeometry; 
    dwPolyline3f geometry;         

    const dwMapsRoadSegment* roadSegment; 
} dwMapsFeature;

struct dwMapsRoadSegment
{
    dwMapsRoadSegmentId id; 

    uint32_t type; 

    dwMapsGeoPoint origin; 

    dwMapsHDCompliance hdCompliance; 

    const dwMapsLane* lanes; 
    uint32_t laneCount;      

    const dwMapsLaneGroup* laneGroups; 
    uint32_t laneGroupCount;           

    const dwMapsLaneDividerGroup* laneDividerGroups; 
    uint32_t laneDividerGroupCount;                  

    const dwMapsFeature* features; 
    uint32_t featureCount;         

    const dwMapsRoadSegmentConnection* next; 
    uint32_t nextCount;                      

    const dwMapsRoadSegmentConnection* previous; 
    uint32_t previousCount;                      
};

//#######################################################################################
// User buffer structs
//#######################################################################################

typedef struct dwMapsConfidence
{
    float32_t confidence; // [0, 1]
    float32_t threshold;  // Inlier threshold
    float32_t variance;   // Variance of inliers
} dwMapsConfidence;

typedef struct dwMapsGeoPointBuffer
{
    dwMapsGeoPoint* buffer; 
    uint32_t maxSize;       
    uint32_t size;          
} dwMapsGeoPointBuffer;

typedef struct dwMapsPointBuffer
{
    dwVector3f* buffer; 
    uint32_t maxSize;   
    uint32_t size;      
} dwMapsPointBuffer;

typedef struct dwMapsPolyline3fBuffer
{
    dwPolyline3f* buffer; 
    uint32_t maxSize;     
    uint32_t size;        
} dwMapsPolyline3fBuffer;

typedef struct dwMapsLaneBuffer
{
    dwMapsLane* buffer; 
    uint32_t maxSize;   
    uint32_t size;      
} dwMapsLaneBuffer;

typedef struct dwMapsLanePtrBuffer
{
    const dwMapsLane** buffer; 
    uint32_t maxSize;          
    uint32_t size;             
} dwMapsLanePtrBuffer;

typedef struct dwMapsLaneDividerLineBuffer
{
    dwMapsLaneDividerLine* buffer; 
    uint32_t maxSize;              
    uint32_t size;                 
} dwMapsLaneDividerLineBuffer;

typedef struct dwMapsLaneDividerBuffer
{
    dwMapsLaneDivider* buffer; 
    uint32_t maxSize;          
    uint32_t size;             
} dwMapsLaneDividerBuffer;

typedef struct dwMapsFeatureBuffer
{
    dwMapsFeature* buffer; 
    uint32_t maxSize;      
    uint32_t size;         
} dwMapsFeatureBuffer;

typedef struct dwMapsRoadSegmentBuffer
{
    dwMapsRoadSegment* buffer; 
    uint32_t maxSize;          
    uint32_t size;             
} dwMapsRoadSegmentBuffer;

typedef struct dwMapsRoadSegmentPointerBuffer
{
    const dwMapsRoadSegment** buffer; 
    uint32_t maxSize;                 
    uint32_t size;                    
} dwMapsRoadSegmentPointerBuffer;

typedef struct dwMapsBoolBuffer
{
    bool* buffer;     
    uint32_t maxSize; 
    uint32_t size;    
} dwMapsBoolBuffer;

//#######################################################################################
// Function parameter structs
//#######################################################################################

typedef dwGeoBounds dwMapsBounds;

typedef struct dwMapsLocalBounds
{
    float32_t minX; 
    float32_t minY; 
    float32_t minZ; 
    float32_t maxX; 
    float32_t maxY; 
    float32_t maxZ; 
} dwMapsLocalBounds;

//#######################################################################################
// Initialization functions
//#######################################################################################

DW_API_PUBLIC
dwStatus dwMaps_initialize(dwMapHandle_t* mapHandle,
                           const char* filename,
                           dwContextHandle_t contextHandle);

DW_API_PUBLIC
dwStatus dwMaps_release(dwMapHandle_t mapHandle);

//#######################################################################################
// Serialization functions
//#######################################################################################

typedef enum dwMapsSerializationFormat {
    DW_MAPS_SERIALIZATION_FORMAT_BINARY = 0,
    DW_MAPS_SERIALIZATION_FORMAT_XML    = 1
} dwMapsSerializationFormat;

#define DW_MAPS_SERIALIZATION_FORMAT_XML_VERSION 5

DW_API_PUBLIC
dwStatus dwMaps_serialize(const char* filename, dwMapsSerializationFormat format,
                          dwConstMapHandle_t mapHandle);

//#######################################################################################
// Utility functions
//#######################################################################################

DW_API_PUBLIC
dwStatus dwMaps_computeBounds(dwMapsBounds* bounds,
                              const dwMapsGeoPoint* p,
                              float32_t radiusMeter);

DW_API_PUBLIC
dwStatus dwMaps_computeBearingFromGeoPoints(float64_t* bearingRadian,
                                            const dwMapsGeoPoint* position,
                                            const dwMapsGeoPoint* headingPoint);

DW_API_PUBLIC
dwStatus dwMaps_computeBearingFromRotation(float64_t* bearingRadian,
                                           const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_computeRotationFromBearing(dwMatrix3d* localToENURotation33,
                                           float32_t bearingRadian);

DW_API_PUBLIC
dwStatus dwMaps_computeRotationFromGeoPoints(dwMatrix3d* localToENURotation33,
                                             const dwMapsGeoPoint* position,
                                             const dwMapsGeoPoint* headingPoint);
DW_API_PUBLIC
dwStatus dwMaps_computeRotationFromLocalPoints(dwMatrix3d* localToENURotation33,
                                               const dwVector3f* position,
                                               const dwVector3f* headingPoint);

DW_API_PUBLIC
dwStatus dwMaps_getPointAhead(dwMapsGeoPoint* pointAhead,
                              const dwMapsGeoPoint* position,
                              const dwMatrix3d* localToENURotation33,
                              float32_t distance);

DW_API_PUBLIC
dwStatus dwMaps_transformPolylines(dwMapsPointBuffer* transformedPoints,
                                   const dwMapsGeoPolyline* polylines,
                                   uint32_t polylineCount,
                                   const dwMapsGeoPoint* localOrigin,
                                   const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_transformPolylinesReverse(dwMapsGeoPointBuffer* transformedPoints,
                                          const dwPolyline3f* polylines,
                                          uint32_t polylineCount,
                                          const dwMapsGeoPoint* localOrigin,
                                          const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_transformPoint(dwVector3f* transformedPoint,
                               const dwMapsGeoPoint* point,
                               const dwMapsGeoPoint* localOrigin,
                               const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_transformPointReverse(dwMapsGeoPoint* transformedPoint,
                                      const dwVector3f* point,
                                      const dwMapsGeoPoint* localOrigin,
                                      const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_computeLocalToLocalTransform(dwTransformation3f* transform,
                                             const dwMapsGeoPoint* originSource,
                                             const dwMatrix3d* localToENURotationSource,
                                             const dwMapsGeoPoint* originTarget,
                                             const dwMatrix3d* localToENURotationTarget);
DW_API_PUBLIC
dwStatus dwMaps_interpolatePolylines(uint32_t* srcStartIndex,
                                     uint32_t* targetEndIndex,
                                     dwMapsGeoPointBuffer* interpolatedPoints,
                                     const dwMapsGeoPoint* srcPoints,
                                     uint32_t srcPointCount,
                                     const dwMapsGeoPoint* targetPoints,
                                     uint32_t targetPointCount,
                                     float32_t start,
                                     float32_t end,
                                     float32_t stepSize,
                                     float32_t (*interpolationFn)(float32_t, void*),
                                     void* interpolationFnContext);

DW_API_PUBLIC
dwStatus dwMaps_getNeighborLaneCount(uint32_t* laneCount,
                                     uint32_t* laneCountAccessible,
                                     const dwMapsLane* lane, dwMapsSide side,
                                     bool sideRelativeToDrivingDirection);

DW_API_PUBLIC
dwStatus dwMaps_getNeighborLane(const dwMapsLane** otherLane,
                                const dwMapsLane* currentLane,
                                dwMapsSide side, uint32_t offset,
                                bool sideRelativeToDrivingDirection);

DW_API_PUBLIC
dwStatus dwMaps_getLaneChangeAtGlobalPose(dwMapsSide* laneChangeSide,
                                          uint32_t* laneChangeCount,
                                          float32_t* laneChangeLength,
                                          const dwMapsLane* srcLane,
                                          const dwMapsLane* targetLane,
                                          const dwMapsGeoPoint* position,
                                          const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_getLaneChangeAtLocalPose(dwMapsSide* laneChangeSide,
                                         uint32_t* laneChangeCount,
                                         float32_t* laneChangeLength,
                                         const dwMapsLane* srcLane,
                                         const dwMapsLane* targetLane,
                                         const dwMapsRoadSegment* referenceRoadSegment,
                                         const dwVector3f* position,
                                         const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_getLaneChange(dwMapsSide* laneChangeSide,
                              uint32_t* laneChangeCount,
                              float32_t* laneChangeLength,
                              const dwMapsLane* srcLane,
                              const dwMapsLane* targetLane);

DW_API_PUBLIC
dwStatus dwMaps_isConnectionDrivable(bool* isDrivable,
                                     const dwMapsLane* lane,
                                     const dwMapsLaneConnection* connection);

DW_API_PUBLIC
dwStatus dwMaps_transformRoadFeaturesToLocalSpace(dwMapsPolyline3fBuffer* localPolylines,
                                                  dwMapsPointBuffer* pointBuffer,
                                                  const dwMapsFeatureBuffer* features,
                                                  const dwMapsGeoPoint* localOrigin,
                                                  const dwMatrix3d* localToENURotation33,
                                                  const dwMapsLocalBounds* localBounds);

DW_API_PUBLIC
dwStatus dwMaps_stitchLaneGeometry(dwMapsPointBuffer* polyline,
                                   dwMapsLanePtrBuffer* perPointLanes,
                                   const dwMapsLane* lanes, uint32_t laneCount,
                                   dwMapsLaneGeometry geometrySelection);

DW_API_PUBLIC
dwStatus dwMaps_computePolylineLength(float32_t* length,
                                      const dwMapsGeoPoint* points, uint32_t pointCount);

DW_API_PUBLIC
dwStatus dwMaps_computeDistance(float64_t* distance, const dwMapsGeoPoint* p1, const dwMapsGeoPoint* p2);

DW_API_PUBLIC
dwStatus dwMaps_closestPointOnPolyline(dwMapsGeoPoint* closestPoint,
                                       float64_t* distanceMeters,
                                       uint32_t* lineSegmentIndex,
                                       const dwMapsGeoPoint* p,
                                       const dwMapsGeoPolyline* polyline,
                                       bool ignoreHeight);

DW_API_PUBLIC
dwStatus dwMaps_resamplePolyline(dwMapsGeoPointBuffer* result,
                                 const dwMapsGeoPolyline* polyline,
                                 float32_t stepSize);

DW_API_PUBLIC
dwStatus dwMaps_computeBoundsSize(float32_t* width, float32_t* height, const dwMapsBounds* bounds);

DW_API_PUBLIC
dwStatus dwMaps_getConnectedToLocal(dwTransformation3f* connectedToLocal,
                                    const dwMapsLane* localLane,
                                    const dwMapsLane* connectedLane);

//#######################################################################################
// Find lane splits and merges
//#######################################################################################

#define DW_MAPS_INVALID_LANE_INDEX 99999999

typedef enum dwMapsLaneEventType {
    DW_MAPS_LANEEVENTTYPE_NONE  = 0,
    DW_MAPS_LANEEVENTTYPE_SPLIT = 1 << 0,
    DW_MAPS_LANEEVENTTYPE_MERGE = 1 << 1,
    DW_MAPS_LANEEVENTTYPE_BOTH  = DW_MAPS_LANEEVENTTYPE_SPLIT | DW_MAPS_LANEEVENTTYPE_MERGE
} dwMapsLaneEventType;

typedef struct dwMapsLaneSplitDetails
{
    const dwMapsLane* laneBeforeSplit;                                    
    const dwMapsLaneConnection* splitLanes[DW_MAPS_MAX_LANE_CONNECTIONS]; 
    uint32_t splitCount;                                                  
    uint32_t splitIndex;                                                  
    float32_t laneChangeLengthAfterSplit;                                 
} dwMapsLaneSplitDetails;

typedef struct dwMapsLaneSplit
{
    dwMapsLaneMeta laneBeforeSplit;       
    uint32_t splitCount;                  
    uint32_t splitIndex;                  
    float32_t laneChangeLengthAfterSplit; 
} dwMapsLaneSplit;

typedef struct dwMapsLaneMergeDetails
{
    const dwMapsLane* laneAfterMerge;                                       
    const dwMapsLaneConnection* mergingLanes[DW_MAPS_MAX_LANE_CONNECTIONS]; 
    uint32_t mergingLaneCount;                                              
    uint32_t mergingLaneIndex;                                              
} dwMapsLaneMergeDetails;

typedef struct dwMapsLaneMerge
{
    dwMapsLaneMeta laneAfterMerge; 
    uint32_t mergingLaneCount;     
    uint32_t mergingLaneIndex;     
} dwMapsLaneMerge;

DW_API_PUBLIC
dwStatus dwMaps_getNextLaneEvent(dwMapsLaneEventType* type,
                                 dwMapsLaneSplitDetails* laneSplit,
                                 dwMapsLaneMergeDetails* laneMerge,
                                 float32_t* nextEventDist,
                                 const dwMapsLane* currentLane,
                                 const bool* forwardOnPolyline,
                                 float32_t maxDistance);

DW_API_PUBLIC
dwStatus dwMaps_getNextLaneSplitAtLocalPose(dwMapsLaneSplitDetails* laneSplit,
                                            float32_t* laneSplitDistance,
                                            const dwMapsLane* currentLane,
                                            float32_t maxSearchDistance,
                                            const dwMapsRoadSegment* referenceRoadSegment,
                                            const dwVector3f* position,
                                            const dwMatrix3d* localToENURotation33);

DW_API_PUBLIC
dwStatus dwMaps_getNextLaneSplitAtGlobalPose(dwMapsLaneSplitDetails* laneSplit,
                                             float32_t* laneSplitDistance,
                                             const dwMapsLane* currentLane,
                                             float32_t maxSearchDistance,
                                             const dwMapsGeoPoint* position,
                                             const dwMatrix3d* localToENURotation33);

//#######################################################################################
// Query functions
//#######################################################################################

DW_API_PUBLIC
dwStatus dwMaps_getLane(const dwMapsLane** lane, const dwMapsLaneId* id,
                        dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getLaneDividers(dwMapsLaneDividerBuffer* laneDividers,
                                uint32_t typeFilter,
                                const dwMapsBounds* bounds,
                                dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getLaneDividerGroup(const dwMapsLaneDividerGroup** laneDividerGroup,
                                    const dwMapsLaneDividerGroupId* id,
                                    dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getFeatures(dwMapsFeatureBuffer* features,
                            uint32_t typeFilter,
                            const dwMapsBounds* bounds,
                            dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getFeature(const dwMapsFeature** mapsFeature,
                           const dwMapsFeatureId* id,
                           dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getRoadSegments(dwMapsRoadSegmentBuffer* roadSegments,
                                const dwMapsBounds* bounds,
                                dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getRoadSegmentPointers(dwMapsRoadSegmentPointerBuffer* roadSegmentPointers,
                                       const dwMapsBounds* bounds,
                                       dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getRoadSegment(const dwMapsRoadSegment** roadSegment,
                               const dwMapsRoadSegmentId* id,
                               dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getClosestLaneFromGeoPoint(const dwMapsLane** closestLane,
                                           dwMapsGeoPoint* closestPoint,
                                           const dwMapsGeoPoint* p,
                                           bool onlyDrivable,
                                           bool ignoreHeight,
                                           float32_t maxRadius,
                                           dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getClosestLaneFromLocalPoint(const dwMapsLane** closestLane,
                                             dwVector3f* closestPoint,
                                             const dwMapsRoadSegment* referenceRoadSegment,
                                             const dwVector3f* position,
                                             bool onlyDrivable,
                                             float32_t maxRadius,
                                             dwConstMapHandle_t mapHandle);

DW_API_PUBLIC
dwStatus dwMaps_getClosestLaneOnRoadSegment(const dwMapsLane** closestLane,
                                            dwVector3f* closestPoint,
                                            const dwMapsRoadSegment* referenceRoadSegment,
                                            const dwVector3f* position,
                                            bool onlyDrivable);

DW_API_PUBLIC
dwStatus dwMaps_getBounds(dwMapsBounds* bounds, dwConstMapHandle_t mapHandle);

//#######################################################################################
// Map Tracker
//#######################################################################################

typedef struct dwMapTrackerObject* dwMapTrackerHandle_t;
typedef struct dwMapTrackerObject const* dwConstMapTrackerHandle_t;

DW_API_PUBLIC
dwStatus dwMapTracker_initialize(dwMapTrackerHandle_t* mapTrackerHandle, dwConstMapHandle_t map);

DW_API_PUBLIC
dwStatus dwMapTracker_release(dwMapTrackerHandle_t mapTrackerHandle);

DW_API_PUBLIC
dwStatus dwMapTracker_updateWithGlobalPose(const dwMapsGeoPoint* position,
                                           const dwMatrix3d* localToENURotation33,
                                           dwTime_t timestamp,
                                           bool ignoreHeight,
                                           bool reset,
                                           dwMapTrackerHandle_t mapTrackerHandle);

DW_API_PUBLIC
dwStatus dwMapTracker_updateWithLocalPose(const dwMapsRoadSegment* referenceRoadSegment,
                                          const dwVector3f* position,
                                          const dwMatrix3d* localToENURotation33,
                                          dwTime_t timestamp,
                                          bool reset,
                                          dwMapTrackerHandle_t mapTrackerHandle);

DW_API_PUBLIC
dwStatus dwMapTracker_getCurrentLane(const dwMapsLane** currentLane,
                                     dwConstMapTrackerHandle_t mapTrackerHandle);

DW_API_PUBLIC
dwStatus dwMapTracker_getCurrentCandidateLanes(dwMapsLaneBuffer* lanes,
                                               dwConstMapTrackerHandle_t mapTrackerHandle);

//#######################################################################################
// Lane Tree
//#######################################################################################

typedef struct dwMapsLaneTreeObject* dwMapsLaneTreeHandle_t;
typedef struct dwMapsLaneTreeObject const* dwConstMapsLaneTreeHandle_t;

typedef enum dwMapsLaneTreeLimit {
    DW_MAPS_LANE_TREE_LIMIT_DISTANCE = 0,
    DW_MAPS_LANE_TREE_LIMIT_TIME     = 1
} dwMapsLaneTreeLimit;

typedef struct dwMapsLaneTreeNode dwMapsLaneTreeNode;
struct dwMapsLaneTreeNode
{
    const dwMapsLane* lane; 

    dwMapsLaneTreeNode* parent;   
    dwMapsLaneTreeNode* children; 
    uint32_t childrenCount;       
};

typedef struct dwMapsLaneTreeNodeBuffer
{
    dwMapsLaneTreeNode* buffer; 
    uint32_t maxSize;           
    uint32_t size;              
} dwMapsLaneTreeNodeBuffer;

DW_API_PUBLIC
dwStatus dwMapsLaneTree_initialize(dwMapsLaneTreeHandle_t* laneTreeHandle,
                                   uint32_t maxLaneCount,
                                   dwConstMapHandle_t map);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_release(dwMapsLaneTreeHandle_t laneTreeHandle);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_create(const dwMapsLane* lane,
                               float32_t limit, dwMapsLaneTreeLimit limitType,
                               bool doLaneChanges, bool forward, bool relativeToDrivingDirection,
                               dwMapsLaneTreeHandle_t laneTree);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_get(dwMapsLaneTreeNode** root, dwMapsLaneTreeNodeBuffer* laneTreeNodes,
                            dwConstMapsLaneTreeHandle_t laneTree);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_getLeafCount(uint32_t* leafCount, dwConstMapsLaneTreeHandle_t laneTree);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_getLaneListToLeaf(dwMapsLaneBuffer* laneBuffer, uint32_t leafIndex,
                                          dwConstMapsLaneTreeHandle_t laneTree);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_getLaneCount(uint32_t* laneCount, dwConstMapsLaneTreeHandle_t laneTree);

DW_API_PUBLIC
dwStatus dwMapsLaneTree_getLanes(dwMapsLaneBuffer* laneBuffer, dwConstMapsLaneTreeHandle_t laneTree);

//#######################################################################################
// Local Map Layout
//#######################################################################################

typedef struct dwMapsLocalLayoutSegmentPose
{
    uint32_t componentId;
    const dwMapsRoadSegment* componentRoot; // segment closest to layoutOrigin in this component
    dwTransformation3f segmentToRoot;       // segment ENU to root segment's ENU
    uint32_t hopsFromRoot;                  // number of graph hops from the root segment
} dwMapsLocalLayoutSegmentPose;

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_initialize(dwMapsLocalLayoutHandle_t* localLayoutHandle, uint32_t maxRoadSegments, uint32_t maxComponents);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_release(dwMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_reset(dwMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_addRoadSegmentPointers(const dwMapsRoadSegment** segmentPointers,
                                                  uint32_t count,
                                                  dwMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_addRoadSegments(const dwMapsRoadSegment* segments, uint32_t count,
                                           dwMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_build(const dwMapsGeoPoint* layoutOrigin, dwMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_getComponentCount(uint32_t* componentCount, dwConstMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_getComponentRoot(const dwMapsRoadSegment** segment, uint32_t componentId,
                                            dwConstMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMapsLocalLayout_getSegmentPose(dwMapsLocalLayoutSegmentPose* pose, const dwMapsRoadSegmentId* segmentId,
                                          dwConstMapsLocalLayoutHandle_t localLayoutHandle);

DW_API_PUBLIC
dwStatus dwMaps_transformLaneDividersToLocalLines(dwMapsLaneDividerLineBuffer* lineSegments,
                                                  const dwMapsLaneDividerBuffer* laneDividers,
                                                  const dwMapsGeoPoint* localOrigin,
                                                  const dwMatrix3d* localToENURotation33,
                                                  const dwMapsLocalBounds* localBounds,
                                                  const dwVector3f* directionFilterVector,
                                                  float32_t directionFilterAngleRadian,
                                                  bool ignoreLaneDirection,
                                                  dwConstMapsLocalLayoutHandle_t localLayoutHandle,
                                                  uint32_t componentId);

DW_API_PUBLIC
dwStatus dwMaps_transformRoadFeaturesToLocalLines(dwMapsPolyline3fBuffer* localPolylines,
                                                  dwMapsPointBuffer* localPoints,
                                                  const dwMapsFeatureBuffer* features,
                                                  const dwMapsGeoPoint* localOrigin,
                                                  const dwMatrix3d* localToENURotation33,
                                                  const dwMapsLocalBounds* localBounds,
                                                  dwConstMapsLocalLayoutHandle_t localLayoutHandle,
                                                  uint32_t componentId);

DW_API_PUBLIC
dwStatus dwMaps_transformLaneDividersToLocalLinesViaRelative(dwMapsLaneDividerLineBuffer* lineSegments,
                                                             const dwMapsLaneDividerBuffer* laneDividers,
                                                             const dwMatrix3f rotationLayoutRootToLocal,
                                                             const dwVector3f translationLayoutRootToLocal,
                                                             const dwMapsLocalBounds* localBounds,
                                                             const dwVector3f* directionFilterVector,
                                                             float32_t directionFilterAngleRadian,
                                                             bool ignoreLaneDirection,
                                                             dwConstMapsLocalLayoutHandle_t localLayoutHandle,
                                                             uint32_t componentId);

DW_API_PUBLIC
dwStatus dwMaps_transformFeaturesToLocalLinesViaRelative(dwMapsPolyline3fBuffer* featureLineSegments,
                                                         dwMapsPointBuffer* featurePoints,
                                                         const dwMapsFeatureBuffer* dwFeatures,
                                                         const dwMatrix3f rotationLayoutRootToLocal,
                                                         const dwVector3f translationLayoutRootToLocal,
                                                         const dwMapsLocalBounds* localBounds,
                                                         dwConstMapsLocalLayoutHandle_t localLayoutHandle,
                                                         uint32_t componentId);

#ifdef __cplusplus
}
#endif

#endif // DW_MAPS_MAPS_H_