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) 2016 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>

#ifdef __cplusplus
extern "C" {
#endif


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


//#######################################################################################
// Forward declarations
//#######################################################################################
typedef struct dwMapsLaneDivider dwMapsLaneDivider;
typedef struct dwMapsLaneDividerGroup dwMapsLaneDividerGroup;
typedef struct dwMapsLane dwMapsLane;
typedef struct dwMapsRoadSegment dwMapsRoadSegment;


//#######################################################################################
// 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
} 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_LANE_MARK = 1 << 18
} dwMapsFeatureType;


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


typedef enum dwMapsSide
{
    DW_MAPS_SIDE_RIGHT = 0,
    DW_MAPS_SIDE_LEFT = 1,
    DW_MAPS_SIDE_NONE = 2
} dwMapsSide;


typedef enum dwMapsLaneGeometry
{
    DW_MAPS_LANE_GEOMETRY_LANEDIVIDERRIGHT = 0,
    DW_MAPS_LANE_GEOMETRY_LANEDIVIDERLEFT = 1,
    DW_MAPS_LANE_GEOMETRY_LANECENTER = 2
} dwMapsLaneGeometry;


//#######################################################################################
// 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;


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

#define DW_MAPS_MAX_LANE_CONNECTIONS 100

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


typedef struct dwMapsRoadSegmentConnection
{
    dwMapsRoadSegmentId segmentId;    
    const dwMapsRoadSegment *segment; 
    dwBool sameDirection;             
} dwMapsRoadSegmentConnection;


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

typedef struct dwMapsGeoPoint
{
    float64_t lon;    
    float64_t lat;    
    float64_t height; 
} 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;                   

    dwMapsGeoPolyline 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;   
};


struct dwMapsLane
{
    dwMapsLaneId id;                                    

    dwMapsLaneType type;                                
    dwMapsDirection drivingDirection;                   
    uint32_t speedLimit;                                

    dwMapsGeoPolyline geometry;                         

    const dwMapsLaneDividerGroup *laneDividerGroups[2]; 

    const dwMapsLaneConnection *next;                   
    uint32_t nextCount;                                 

    const dwMapsLaneConnection *previous;               
    uint32_t previousCount;                             

    const dwMapsRoadSegment *roadSegment;               
};


typedef struct dwMapsFeature
{
    uint64_t id;                            
    uint32_t type;                          
    dwMapsGeoPolyline geometry;             

    const dwMapsRoadSegment *roadSegment;   
} dwMapsFeature;

struct dwMapsRoadSegment
{
    dwMapsRoadSegmentId id;                          

    uint32_t type;                                   

    const dwMapsLane *lanes;                         
    uint32_t laneCount;                              

    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 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 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;

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

typedef struct dwMapsHEREConnectionParameters {
    const char *baseURL;
    const char *appId;
    const char *appCode;
    const char *staticMapCatalog;
    const char *liveRoadsCatalog;
} dwMapsHEREConnectionParameters;


typedef struct dwMapsBounds {
    float64_t minLon;            
    float64_t minLat;            
    float64_t maxLon;            
    float64_t maxLat;            
} 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_initializeHERE(dwMapHandle_t *mapHandle,
                               const dwMapsHEREConnectionParameters *params,
                               const char *HEREMapCacheFile,
                               float32_t splinePointSpacing,
                               uint32_t maxRoadSegmentCount,
                               dwContextHandle_t contextHandle);


DW_API_PUBLIC
dwStatus dwMaps_initializeTomTom(dwMapHandle_t *mapHandle,
                                 const char *file,
                                 uint32_t maxRoadSegmentCount,
                                 dwContextHandle_t contextHandle);


DW_API_PUBLIC
dwStatus dwMaps_release(dwMapHandle_t *mapHandle);


DW_API_PUBLIC
dwStatus dwMaps_update(dwBool *updated,
                       const dwMapsBounds *bounds,
                       dwBool download,
                       dwMapHandle_t mapHandle);

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

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


DW_API_PUBLIC
dwStatus dwMaps_deserialize(const char *filename, dwMapHandle_t mapHandle);

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

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


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


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


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


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


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,
                                     dwBool sideRelativeToDrivingDirection);



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

DW_API_PUBLIC
dwStatus dwMaps_transformLaneDividersToLocalLines(dwMapsLaneDividerLineBuffer *lineSegments,
                                                  const dwMapsLaneDividerBuffer *laneDividers,
                                                  const dwMapsGeoPoint *localOrigin,
                                                  const float64_t *localToENURotation33,
                                                  const dwMapsLocalBounds *bounds,
                                                  const dwVector3f *directionFilterVector,
                                                  float32_t directionFilterAngleRadian,
                                                  dwBool ignoreLaneDirection);


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

DW_API_PUBLIC
dwStatus dwMaps_stitchLaneGeometry(dwMapsGeoPointBuffer *polyline,
                                   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(float32_t *distance, const dwMapsGeoPoint *p1, const dwMapsGeoPoint *p2);


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

DW_API_PUBLIC
dwStatus dwMaps_getLaneDividers(dwMapsLaneDividerBuffer *laneDividers,
                                uint32_t typeFilter,
                                const dwMapsBounds *bounds,
                                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_getRoadSegments(dwMapsRoadSegmentBuffer *roadSegments,
                                const dwMapsBounds *bounds,
                                dwConstMapHandle_t mapHandle);


DW_API_PUBLIC
dwStatus dwMaps_getClosestLane(const dwMapsLane **closestLane,
                               dwMapsGeoPoint *closestPoint,
                               const dwMapsGeoPoint *p,
                               dwBool onlyDrivable,
                               dwBool ignoreHeight,
                               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_updateCurrentPose(const dwMapsGeoPoint *position,
                                        const float64_t *localToENURotation33,
                                        dwTime_t timestamp,
                                        dwBool ignoreHeight,
                                        dwBool 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,
                               dwBool doLaneChanges, 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);


#ifdef __cplusplus
}
#endif

#endif // DW_MAPS_MAPS_H__