Lane.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) 2019 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_WORLDMODEL_LANE_H_
#define DW_WORLDMODEL_LANE_H_

#include <dw/core/Types.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef enum dwLaneOccupancy {
    DW_LANE_OCCUPANCY_INVALID = 0, 

    DW_LANE_OCCUPANCY_UNKNOWN    = 1, 
    DW_LANE_OCCUPANCY_UNOCCUPIED = 2, 
    DW_LANE_OCCUPANCY_OCCUPIED   = 3  
} dwLaneOccupancy;

typedef enum dwLaneEdgeClass {
    DW_LANE_EDGE_CLASS_INVALID = 0,

    DW_LANE_EDGE_CLASS_MARKED_CROSSABLE  = 1,
    DW_LANE_EDGE_CLASS_MARKED_DONT_CROSS = 2,
    DW_LANE_EDGE_CLASS_PHYSICAL          = 3,
    DW_LANE_EDGE_CLASS_VIRTUAL           = 4,
    DW_LANE_EDGE_CLASS_UNKNOWN           = 5,

    DW_LANE_EDGE_CLASS_COUNT = 6
} dwLaneEdgeClass;

typedef enum dwLaneEdgeColor {
    DW_LANE_EDGE_COLOR_INVALID = 0,

    DW_LANE_EDGE_COLOR_WHITE   = 1,
    DW_LANE_EDGE_COLOR_YELLOW  = 2,
    DW_LANE_EDGE_COLOR_BLUE    = 3,
    DW_LANE_EDGE_COLOR_RED     = 4,
    DW_LANE_EDGE_COLOR_GREEN   = 5,
    DW_LANE_EDGE_COLOR_BLACK   = 6,
    DW_LANE_EDGE_COLOR_ORANGE  = 7,
    DW_LANE_EDGE_COLOR_MIXED   = 8,
    DW_LANE_EDGE_COLOR_UNKNOWN = 9,

    DW_LANE_EDGE_COLOR_OTHER = 10
} dwLaneEdgeColor;

#define DW_LANE_EDGE_STYLE_IS_GROUP 1

typedef enum dwLaneEdgeStyle {
    DW_LANE_EDGE_STYLE_INVALID = 0,

    //Markings
    DW_LANE_EDGE_STYLE_SOLID_SINGLE         = 1,  
    DW_LANE_EDGE_STYLE_SOLID_GROUP          = 2,  
    DW_LANE_EDGE_STYLE_SHORT_DASHED_SINGLE  = 3,  
    DW_LANE_EDGE_STYLE_SHORT_DASHED_GROUP   = 4,  
    DW_LANE_EDGE_STYLE_LONG_DASHED_SINGLE   = 5,  
    DW_LANE_EDGE_STYLE_LONG_DASHED_GROUP    = 6,  
    DW_LANE_EDGE_STYLE_CIRCULAR_DOT_SINGLE  = 7,  
    DW_LANE_EDGE_STYLE_CIRCULAR_DOT_GROUP   = 8,  
    DW_LANE_EDGE_STYLE_SQUARE_DOT_SINGLE    = 9,  
    DW_LANE_EDGE_STYLE_SQUARE_DOT_GROUP     = 10, 
    DW_LANE_EDGE_STYLE_ZIGZAG_SINGLE        = 11, 
    DW_LANE_EDGE_STYLE_ZIGZAG_GROUP         = 12, 
    DW_LANE_EDGE_STYLE_RUMBLE_SINGLE        = 13, 
    DW_LANE_EDGE_STYLE_RUMBLE_GROUP         = 14, 
    DW_LANE_EDGE_STYLE_OTHER_MARKING_SINGLE = 15, 
    DW_LANE_EDGE_STYLE_OTHER_MARKING_GROUP  = 16, 
    DW_LANE_EDGE_STYLE_AREA                 = 17, 

    //Physical obstacles
    DW_LANE_EDGE_STYLE_ROAD_BOUNDARY    = 20, 
    DW_LANE_EDGE_STYLE_PHYSICAL_DIVIDER = 21, 
    DW_LANE_EDGE_STYLE_TALL_CURB        = 22, 
    DW_LANE_EDGE_STYLE_DRIVABLE_CURB    = 23, 
    DW_LANE_EDGE_STYLE_WALKABLE_CURB    = 24, 
    DW_LANE_EDGE_STYLE_FENCE            = 25, 
    DW_LANE_EDGE_STYLE_BARRIER          = 26, 
    DW_LANE_EDGE_STYLE_WALL             = 27, 
    DW_LANE_EDGE_STYLE_OBSTACLE_BARS    = 28, 
    DW_LANE_EDGE_STYLE_OTHER_PHYSICAL   = 29, 

    //Virtual
    DW_LANE_EDGE_STYLE_INTERSECTION  = 30, 
    DW_LANE_EDGE_STYLE_SPLIT_LEFT    = 31, 
    DW_LANE_EDGE_STYLE_SPLIT_RIGHT   = 32, 
    DW_LANE_EDGE_STYLE_MERGE_LEFT    = 33, 
    DW_LANE_EDGE_STYLE_MERGE_RIGHT   = 34, 
    DW_LANE_EDGE_STYLE_PARKING       = 35, 
    DW_LANE_EDGE_STYLE_OTHER_VIRTUAL = 36, 

    //Other
    DW_LANE_EDGE_STYLE_UNKNOWN = 40, 
    DW_LANE_EDGE_STYLE_OTHER   = 41, 
} dwLaneEdgeStyle;

#define DW_LANE_CHUNK_SIZE_TWO_LOG 3u
#define DW_LANE_CHUNK_SIZE (1u << DW_LANE_CHUNK_SIZE_TWO_LOG)
#define DW_LANE_CHUNK_SIZE_MASK (DW_LANE_CHUNK_SIZE - 1)

typedef struct dwLaneChunk
{
    dwTime_t timestamp_us; 

    // Geometry
    dwVector3f center[DW_LANE_CHUNK_SIZE]; 
    dwVector3f left[DW_LANE_CHUNK_SIZE];   
    dwVector3f right[DW_LANE_CHUNK_SIZE];  
    dwVector3f normal[DW_LANE_CHUNK_SIZE]; 

    // Uncertainty [meters] in lateral direction
    dwConfidence1f centerLateralConfidence;
    dwConfidence1f leftLateralConfidence;
    dwConfidence1f rightLateralConfidence;
    dwConfidence1f normalSidewayConfidence;

    // Uncertainty [meters] in vertical direction
    dwConfidence1f centerVerticalConfidence;
    dwConfidence1f leftVerticalConfidence;
    dwConfidence1f rightVerticalConfidence;
    dwConfidence1f normalForwardConfidence;

    // Visibility 0-255 confidence range that left and right are visible
    uint8_t visibilityConfidenceLeft[DW_LANE_CHUNK_SIZE];  
    uint8_t visibilityConfidenceRight[DW_LANE_CHUNK_SIZE]; 

    // Occupancy
    uint8_t occupancy[DW_LANE_CHUNK_SIZE];
    uint8_t occupancyConfidence[DW_LANE_CHUNK_SIZE]; 

    // Class
    uint8_t leftClass[DW_LANE_CHUNK_SIZE];            
    uint8_t rightClass[DW_LANE_CHUNK_SIZE];           
    uint8_t leftClassConfidence[DW_LANE_CHUNK_SIZE];  
    uint8_t rightClassConfidence[DW_LANE_CHUNK_SIZE]; 

    //Color
    uint8_t leftColor[DW_LANE_CHUNK_SIZE];            
    uint8_t rightColor[DW_LANE_CHUNK_SIZE];           
    uint8_t leftColorConfidence[DW_LANE_CHUNK_SIZE];  
    uint8_t rightColorConfidence[DW_LANE_CHUNK_SIZE]; 

    //Style
    uint8_t leftStyle[DW_LANE_CHUNK_SIZE];            
    uint8_t rightStyle[DW_LANE_CHUNK_SIZE];           
    uint8_t leftStyleConfidence[DW_LANE_CHUNK_SIZE];  
    uint8_t rightStyleConfidence[DW_LANE_CHUNK_SIZE]; 

    //Speed
    float32_t officialSpeed_mps; 
    float32_t commonSpeed_mps;   
} dwLaneChunk;

#define DW_LANE_CHUNK_ARRAY_MAX_COUNT 2000

typedef struct dwLaneChunkArray
{
    uint32_t count;
    dwLaneChunk chunks[DW_LANE_CHUNK_ARRAY_MAX_COUNT];
} dwLaneChunkArray;

#define DW_LANE_IS_VEHICLE (1 << 16)       
#define DW_LANE_IS_OTHER_ANIMATE (1 << 17) 
#define DW_LANE_IS_VRU (1 << 18)           
#define DW_LANE_IS_BIKE (1 << 19)          
#define DW_LANE_IS_PEDESTRIAN (1 << 20)    
#define DW_LANE_IS_INFRA (1 << 21)         
#define DW_LANE_IS_SPECIAL (1 << 22)       

#define DW_LANE_VEHICLE_BASE (DW_LANE_IS_VEHICLE)
#define DW_LANE_SPECIAL_BASE (DW_LANE_IS_VEHICLE + DW_LANE_IS_SPECIAL)
#define DW_LANE_VRU_BASE (DW_LANE_IS_VRU + DW_LANE_IS_OTHER_ANIMATE)
#define DW_LANE_BIKE_BASE (DW_LANE_IS_BIKE + DW_LANE_VRU_BASE)
#define DW_LANE_PEDESTRIAN_BASE (DW_LANE_IS_PEDESTRIAN + DW_LANE_VRU_BASE)
#define DW_LANE_TRAIN_BASE (DW_LANE_IS_INFRA + DW_LANE_IS_OTHER_ANIMATE)
#define DW_LANE_ANIMAL_BASE (DW_LANE_IS_VRU + DW_LANE_IS_OTHER_ANIMATE)

typedef enum dwLaneClass {
    DW_LANE_INVALID = 0, 

    DW_LANE_VEHICLE      = 1 + DW_LANE_VEHICLE_BASE,     
    DW_LANE_HOV          = 2 + DW_LANE_VEHICLE_BASE,     
    DW_LANE_CENTER_TURN  = 3 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_SUICIDE      = 4 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_BUS          = 5 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_TAXI         = 6 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_LOAD_UNLOAD  = 7 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_REVERSIBLE   = 8 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_SHOULDER     = 9 + DW_LANE_SPECIAL_BASE,     
    DW_LANE_DIVIDER_LANE = 10,                           
    DW_LANE_BIKE         = 11 + DW_LANE_BIKE_BASE,       
    DW_LANE_PEDESTRIAN   = 12 + DW_LANE_PEDESTRIAN_BASE, 
    DW_LANE_TRAIN        = 13 + DW_LANE_TRAIN_BASE,      

    DW_LANE_ANIMAL = 14 + DW_LANE_ANIMAL_BASE, 

    DW_LANE_OTHER = 15 
} dwLaneClass;

typedef enum dwLaneEndType {
    DW_LANE_END_INVALID = 0, 

    DW_LANE_END_DISAPPEARS   = 1, 
    DW_LANE_END_CHANGES      = 2, 
    DW_LANE_END_OCCLUSION    = 3, 
    DW_LANE_END_OUT_OF_SCOPE = 4, 

    DW_LANE_END_UNKNOWN = 5, 
} dwLaneEndType;

typedef enum dwLaneTurnsAllowed {
    DW_LANE_TURN_INVALID = 0, 

    DW_LANE_TURN_LEFT           = (1 << 1), 
    DW_LANE_TURN_STRAIGHT       = (1 << 2), 
    DW_LANE_TURN_RIGHT          = (1 << 3), 
    DW_LANE_TURN_UTURN          = (1 << 4), 
    DW_LANE_TURN_DIAGONAL_LEFT  = (1 << 5), 
    DW_LANE_TURN_DIAGONAL_RIGHT = (1 << 6), 

    DW_LANE_TURN_UNMARKED = (1 << 7), 

    DW_LANE_TURN_UNKNOWN = (1 << 8), 
} dwLaneTurnsAllowed;

#define DW_LANE_PREVIOUS_ID_MAX_COUNT 10
#define DW_LANE_CHUNK_INDICES_MAX_COUNT 500

typedef struct dwLane
{
    // Basic information
    dwTime_t timestamp_us;    
    uint64_t currentId;       
    uint32_t previousIdCount; 
    // Matching previous lane IDs (zero=invalid)
    uint64_t previousIds[DW_LANE_PREVIOUS_ID_MAX_COUNT];
    float32_t confidence; 

    // Class
    dwLaneClass laneClass;        
    float32_t classConfidence;    
    float32_t subclassConfidence; 
    bool bidirectional;           

    dwLaneTurnsAllowed turnsAllowed; 

    dwLaneEndType beginType; 
    dwLaneEndType endType;   

    // Chunks with geometry and detailed information
    uint32_t vertexCount; 
    uint32_t chunkCount;  
    uint32_t chunkIndices[DW_LANE_CHUNK_INDICES_MAX_COUNT];
} dwLane;

#define DW_LANE_ARRAY_MAX_COUNT 200U

typedef struct dwLaneArray
{
    uint32_t count;
    dwLane lanes[DW_LANE_ARRAY_MAX_COUNT];
    uint32_t egoIndex; // best guess of what ego lane is
} dwLaneArray;

#define DW_LANE_CONTINUATIONS_MAX_COUNT 16U

typedef struct dwLaneContinuation
{
    uint32_t count;
    uint32_t continuations[DW_LANE_CONTINUATIONS_MAX_COUNT];
} dwLaneContinuation;

typedef struct dwLaneContinuationArray
{
    uint32_t count;
    dwLaneContinuation laneContinuations[DW_LANE_ARRAY_MAX_COUNT];
} dwLaneContinuationArray;

typedef struct dwLaneSegment
{
    bool isValid;            
    uint32_t laneIndex;      
    uint32_t entryVertex;    
    float32_t entryFraction; 
    uint32_t exitVertex;     
    float32_t exitFraction;  
} dwLaneSegment;

#define DW_PATH_SEGMENT_MAX_COUT 8U

typedef struct dwPathSegment
{
    uint32_t count;                                 //Number of lanes referenced by the path segment
    uint32_t laneIndices[DW_PATH_SEGMENT_MAX_COUT]; //array of lane indices into dwLaneArray
    uint32_t entryVertex;                           
    float32_t entryFraction;                        
    uint32_t exitVertex;                            
    float32_t exitFraction;                         
} dwPathSegment;

typedef struct dwLaneVertex
{
    bool isValid;       
    uint32_t laneIndex; 
    uint32_t vertex;    
} dwLaneVertex;

typedef struct dwLaneChange
{
    // Basic information
    dwTime_t timestamp_us; 
    uint64_t id;           

    // path segments involved
    dwPathSegment startSegment;
    dwPathSegment endSegment;
} dwLaneChange;

#define DW_LANE_CHANGE_ARRAY_MAX_COUNT 20U

typedef struct dwLaneChangeArray
{
    uint32_t count;
    dwLaneChange changes[DW_LANE_CHANGE_ARRAY_MAX_COUNT];
} dwLaneChangeArray;

typedef enum dwLaneRelationType {
    DW_LANE_RELATION_NONE = 0,

    DW_LANE_RELATION_CONTINUE = 1,

    DW_LANE_RELATION_CROSSING = 2,

    DW_LANE_RELATION_MERGE = 3,

    DW_LANE_RELATION_FORK = 4,

    DW_LANE_RELATION_CORRESPONDENCE = 5
} dwLaneRelationType;

typedef struct dwLaneRelation
{
    dwLaneSegment first;
    dwLaneSegment second;
    dwLaneRelationType type;
} dwLaneRelation;

#define DW_LANE_RELATION_ARRAY_MAX_COUNT 20

typedef struct dwLaneRelationArray
{
    uint32_t count;
    dwLaneRelation relations[DW_LANE_RELATION_ARRAY_MAX_COUNT];
} dwLaneRelationArray;

#ifdef __cplusplus
}
#endif

#endif // DW_WORLDMODEL_LANE_H_