Obstacle.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-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_WORLD_OBSTACLE_H_
#define DW_WORLD_OBSTACLE_H_

#include <dw/core/Context.h>
#include <dw/sensors/Sensors.h>
#include <dw/sensors/radar/Radar.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DW_OBSTACLE_BOUNDARY_POINT_MAX_COUNT 30u

typedef enum dwObstacleProperties {
    DW_OBSTACLE_PROPERTIES_IS_NONE               = 0,
    DW_OBSTACLE_PROPERTIES_IS_LOW_CONFIDENCE     = (1 << 8),
    DW_OBSTACLE_PROPERTIES_IS_ON_SENSOR_BOUNDARY = (1 << 9),
    DW_OBSTACLE_PROPERTIES_IS_PARTIALLY_OBSERVED = (1 << 10),
    DW_OBSTACLE_PROPERTIES_IS_AT_RANGE_LIMIT     = (1 << 11)
} dwObstacleProperties;

#define DW_OBSTACLE_STATE_NOTMOVING (1 << 8)
#define DW_OBSTACLE_STATE_MOVING (1 << 9)

typedef enum dwObstacleState {
    DW_OBSTACLE_STATE_INVALID = 0,
    DW_OBSTACLE_STATE_INACTIVE = DW_OBSTACLE_STATE_NOTMOVING + 0,
    DW_OBSTACLE_STATE_PARKED = DW_OBSTACLE_STATE_NOTMOVING + 1,
    DW_OBSTACLE_STATE_STOPPED = DW_OBSTACLE_STATE_NOTMOVING + 2,

    DW_OBSTACLE_STATE_FORWARD = DW_OBSTACLE_STATE_MOVING + 0,
    DW_OBSTACLE_STATE_REVERSE = DW_OBSTACLE_STATE_MOVING + 1,
    DW_OBSTACLE_STATE_TURNING_RIGHT = DW_OBSTACLE_STATE_MOVING + 2,
    DW_OBSTACLE_STATE_TURNING_LEFT = DW_OBSTACLE_STATE_MOVING + 3,
    DW_OBSTACLE_STATE_CHANGING_RIGHT = DW_OBSTACLE_STATE_MOVING + 4,
    DW_OBSTACLE_STATE_CHANGING_LEFT = DW_OBSTACLE_STATE_MOVING + 5,
    DW_OBSTACLE_STATE_UTURNING = DW_OBSTACLE_STATE_MOVING + 6,

} dwObstacleState;

typedef enum dwObjectClass {
    DW_OBJECT_CLASS_CAR           = 0, 
    DW_OBJECT_CLASS_TRAFFIC_SIGN  = 1, 
    DW_OBJECT_CLASS_BICYCLE       = 2, 
    DW_OBJECT_CLASS_PEDESTRIAN    = 3, 
    DW_OBJECT_CLASS_TRAFFIC_LIGHT = 4, 
    DW_OBJECT_CLASS_CURB          = 5, 
    DW_OBJECT_CLASS_OTHER         = 6, 
    DW_OBJECT_CLASS_UNKNOWN       = 7, 

    DW_OBJECT_CLASS_NUM_CLASSES
} dwObjectClass;

#define DW_OBSTACLE_CLASS_IS_ANIMATE (1 << 8)     
#define DW_OBSTACLE_CLASS_IS_VIRTUAL (1 << 9)     
#define DW_OBSTACLE_CLASS_IS_VEHICLE (1 << 10)    
#define DW_OBSTACLE_CLASS_IS_BIKE (1 << 11)       
#define DW_OBSTACLE_CLASS_IS_PEDESTRIAN (1 << 12) 
#define DW_OBSTACLE_CLASS_IS_ANIMAL (1 << 13)     
#define DW_OBSTACLE_CLASS_IS_OBJECT (1 << 14)     
#define DW_OBSTACLE_CLASS_IS_UNDEFINED (1 << 15)  

#define DW_OBSTACLE_CLASS_VEHICLE_BASE \
    DW_OBSTACLE_CLASS_IS_VEHICLE + DW_OBSTACLE_CLASS_IS_ANIMATE
#define DW_OBSTACLE_CLASS_BIKE_BASE \
    DW_OBSTACLE_CLASS_IS_BIKE + DW_OBSTACLE_CLASS_IS_ANIMATE
#define DW_OBSTACLE_CLASS_PEDESTRIAN_BASE \
    DW_OBSTACLE_CLASS_IS_PEDESTRIAN + DW_OBSTACLE_CLASS_IS_ANIMATE
#define DW_OBSTACLE_CLASS_ANIMAL_BASE \
    DW_OBSTACLE_CLASS_IS_ANIMAL + DW_OBSTACLE_CLASS_IS_ANIMATE
#define DW_OBSTACLE_CLASS_OBJECT_BASE DW_OBSTACLE_CLASS_IS_OBJECT
#define DW_OBSTACLE_CLASS_UNDEFINED_STATIC_BASE DW_OBSTACLE_CLASS_IS_UNDEFINED
#define DW_OBSTACLE_CLASS_UNDEFINED_ANIMATE_BASE \
    DW_OBSTACLE_CLASS_IS_UNDEFINED + DW_OBSTACLE_CLASS_IS_ANIMATE

typedef enum dwObstacleClass {
    DW_OBSTACLE_CLASS_INVALID = 0, 

    DW_OBSTACLE_CLASS_VEHICLE_UNKNOWN      = DW_OBSTACLE_CLASS_VEHICLE_BASE + 0,
    DW_OBSTACLE_CLASS_VEHICLE_CAR          = DW_OBSTACLE_CLASS_VEHICLE_BASE + 1,
    DW_OBSTACLE_CLASS_VEHICLE_TRUCK        = DW_OBSTACLE_CLASS_VEHICLE_BASE + 2,
    DW_OBSTACLE_CLASS_VEHICLE_BUS          = DW_OBSTACLE_CLASS_VEHICLE_BASE + 3,
    DW_OBSTACLE_CLASS_VEHICLE_EMERGENCY    = DW_OBSTACLE_CLASS_VEHICLE_BASE + 4,
    DW_OBSTACLE_CLASS_VEHICLE_CONSTRUCTION = DW_OBSTACLE_CLASS_VEHICLE_BASE + 5,
    DW_OBSTACLE_CLASS_VEHICLE_POLICE       = DW_OBSTACLE_CLASS_VEHICLE_BASE + 6,
    DW_OBSTACLE_CLASS_VEHICLE_SCHOOL_BUS   = DW_OBSTACLE_CLASS_VEHICLE_BASE + 7,

    DW_OBSTACLE_CLASS_BIKE_UNKNOWN = DW_OBSTACLE_CLASS_BIKE_BASE + 0,
    DW_OBSTACLE_CLASS_BIKE         = DW_OBSTACLE_CLASS_BIKE_BASE + 1,
    DW_OBSTACLE_CLASS_BIKE_MOTOR   = DW_OBSTACLE_CLASS_BIKE_BASE + 2,

    DW_OBSTACLE_CLASS_PEDESTRIAN_UNKNOWN             = DW_OBSTACLE_CLASS_PEDESTRIAN_BASE + 0,
    DW_OBSTACLE_CLASS_PEDESTRIAN_ADULT               = DW_OBSTACLE_CLASS_PEDESTRIAN_BASE + 1,
    DW_OBSTACLE_CLASS_PEDESTRIAN_CHILD               = DW_OBSTACLE_CLASS_PEDESTRIAN_BASE + 2,
    DW_OBSTACLE_CLASS_PEDESTRIAN_CONSTRUCTION_WORKER = DW_OBSTACLE_CLASS_PEDESTRIAN_BASE + 3,
    DW_OBSTACLE_CLASS_PEDESTRIAN_OFFICIAL            = DW_OBSTACLE_CLASS_PEDESTRIAN_BASE + 4,

    DW_OBSTACLE_CLASS_ANIMAL_UNKNOWN = DW_OBSTACLE_CLASS_ANIMAL_BASE + 0,
    DW_OBSTACLE_CLASS_ANIMAL_SMALL = DW_OBSTACLE_CLASS_ANIMAL_BASE + 1,
    DW_OBSTACLE_CLASS_ANIMAL_MEDIUM = DW_OBSTACLE_CLASS_ANIMAL_BASE + 2,
    DW_OBSTACLE_CLASS_ANIMAL_LARGE = DW_OBSTACLE_CLASS_ANIMAL_BASE + 3,

    DW_OBSTACLE_CLASS_OBJECT_UNKNOWN  = DW_OBSTACLE_CLASS_OBJECT_BASE + 0,
    DW_OBSTACLE_CLASS_OBJECT_HAZARD   = DW_OBSTACLE_CLASS_OBJECT_BASE + 1,
    DW_OBSTACLE_CLASS_OBJECT_OFFICIAL = DW_OBSTACLE_CLASS_OBJECT_BASE + 2,
    DW_OBSTACLE_CLASS_OBJECT_CONE     = DW_OBSTACLE_CLASS_OBJECT_BASE + 3,

    DW_OBSTACLE_CLASS_OBJECT_CURB = DW_OBSTACLE_CLASS_OBJECT_BASE + 4,
    DW_OBSTACLE_CLASS_OBJECT_BARRIER = DW_OBSTACLE_CLASS_OBJECT_BASE + 5,
    DW_OBSTACLE_CLASS_OBJECT_PHYSICAL_LANE_LINE = DW_OBSTACLE_CLASS_OBJECT_BASE + 6,

    DW_OBSTACLE_CLASS_OBJECT_HARD_OVERHANG = DW_OBSTACLE_CLASS_OBJECT_BASE + 7,
    DW_OBSTACLE_CLASS_OBJECT_SOFT_OVERHANG = DW_OBSTACLE_CLASS_OBJECT_BASE + 8,
    DW_OBSTACLE_CLASS_OBJECT_SPEED_BUMP = DW_OBSTACLE_CLASS_OBJECT_BASE + 9,
    DW_OBSTACLE_CLASS_OBJECT_POT_HOLE = DW_OBSTACLE_CLASS_OBJECT_BASE + 10,
    DW_OBSTACLE_CLASS_OBJECT_NEGATIVE = DW_OBSTACLE_CLASS_OBJECT_BASE + 11,
    DW_OBSTACLE_CLASS_OBJECT_FORBIDDEN = DW_OBSTACLE_CLASS_OBJECT_BASE + 12,

    DW_OBSTACLE_CLASS_UNDEFINED_STATIC  = DW_OBSTACLE_CLASS_UNDEFINED_STATIC_BASE + 0,
    DW_OBSTACLE_CLASS_UNDEFINED_ANIMATE = DW_OBSTACLE_CLASS_UNDEFINED_ANIMATE_BASE + 0,

    DW_OBSTACLE_CLASS_FORBIDDEN_LANE_LINE = DW_OBSTACLE_CLASS_IS_VIRTUAL + 1,
    DW_OBSTACLE_CLASS_CROSSABLE_LANE_LINE = DW_OBSTACLE_CLASS_IS_VIRTUAL + 2,
    DW_OBSTACLE_CLASS_GORE_AREA           = DW_OBSTACLE_CLASS_IS_VIRTUAL + 3,
    DW_OBSTACLE_CLASS_OCCLUSION           = DW_OBSTACLE_CLASS_IS_VIRTUAL + 4

} dwObstacleClass;

typedef enum dwObstacleStateFlags {
    DW_OBSTACLE_STATE_FLAG_INVALID = 0,

    DW_OBSTACLE_STATE_FLAG_TURN_RIGHT          = (1 << 1), 
    DW_OBSTACLE_STATE_FLAG_TURN_LEFT           = (1 << 2), 
    DW_OBSTACLE_STATE_FLAG_BRAKING             = (1 << 3), 
    DW_OBSTACLE_STATE_FLAG_REVERSE             = (1 << 4), 
    DW_OBSTACLE_STATE_FLAG_HAZARD_FLASHING     = (1 << 5), 
    DW_OBSTACLE_STATE_FLAG_RED_LIGHT_FLASHING  = (1 << 6), 
    DW_OBSTACLE_STATE_FLAG_BLUE_LIGHT_FLASHING = (1 << 7), 

    DW_OBSTACLE_STATE_FLAG_IS_ATTENTIVE = (1 << 8), 
    DW_OBSTACLE_STATE_FLAG_SIGNALING    = (1 << 9), 

} dwObstacleStateFlags;

#define DW_OBSTACLE_MAX_SENSOR_COUNT 64
typedef struct dwObstacle
{
    dwTime_t timestamp_us; 
    uint64_t id;           
    uint64_t sensorIdMask; 
    float32_t confidence;  
    uint32_t prop;         

    dwObjectClass objectClass;     
    dwObstacleClass obstacleClass; 
    float32_t classConfidence;     
    float32_t subclassConfidence;  

    dwObstacleState state;           
    dwObstacleStateFlags stateFlags; 

    dwVector3f position; 
    dwConfidence3f positionConfidence;
    dwVector3f direction; 
    dwConfidence3f directionConfidence;
    dwVector3f velocity_mps; 
    dwConfidence3f velocityConfidence;
    dwVector3f acceleration_mps2; 
    dwConfidence3f accelerationConfidence;
    dwVector3f rotationAxis; 
    dwConfidence3f rotationAxisConfidence;
    float32_t rotationVel_rps; 
    dwConfidence1f rotationVelConfidence;

    uint32_t boundaryPointCount;                                     
    dwVector3f boundaryPoints[DW_OBSTACLE_BOUNDARY_POINT_MAX_COUNT]; 

    float32_t height_m; 
    dwConfidence1f heightConfidence;
    float32_t clearance_m;              
    dwConfidence1f clearanceConfidence; 

    float32_t traversalSpeed_mps;
    dwConfidence1f traversalSpeedConfidence;
} dwObstacle;

#define DW_OBSTACLE_ARRAY_MAX_COUNT 1000

typedef struct dwObstacleArray
{
    uint32_t count;
    dwObstacle obstacles[DW_OBSTACLE_ARRAY_MAX_COUNT];
} dwObstacleArray;

#define DW_OBSTACLE_MAX_LINKS 16

typedef struct dwObstacleLink
{
    uint32_t count;                                
    uint32_t arrayIndex[DW_OBSTACLE_MAX_LINKS];    
    uint32_t obstacleIndex[DW_OBSTACLE_MAX_LINKS]; 
    uint64_t obstacleId[DW_OBSTACLE_MAX_LINKS];    
    float32_t confidence[DW_OBSTACLE_MAX_LINKS];   // [0,1] confidence about linkage
} dwObstacleLink;

typedef struct dwObstacleLinkArray
{
    uint32_t count;
    dwObstacleLink links[DW_OBSTACLE_ARRAY_MAX_COUNT];
} dwObstacleLinkArray;

#define DW_OBSTACLE_SILHOUETTE_MAX_POINTS 128

typedef struct dwObstacleSilhouette
{
    uint64_t obstacleId;                                 
    uint32_t nVertices;                                  
    uint32_t indices[DW_OBSTACLE_SILHOUETTE_MAX_POINTS]; 
} dwObstacleSilhouette;

#define DW_OBSTACLE_SILHOUETTE_MAX_VERTICES DW_OBSTACLE_SILHOUETTE_MAX_POINTS* \
    DW_OBSTACLE_ARRAY_MAX_COUNT

typedef struct dwObstacleSilhouetteArray
{
    uint32_t nObstacles;
    dwObstacleSilhouette silhouettes[DW_OBSTACLE_ARRAY_MAX_COUNT];

    uint32_t nVertices;
    dwVector3f vertices[DW_OBSTACLE_SILHOUETTE_MAX_VERTICES];
} dwObstacleSilhouetteArray;

typedef enum dwObstacleRegionClass {
    DW_OBSTACLE_REGION_INVALID = 0, 

    DW_OBSTACLE_REGION_DRIVABLE = (1 << 8),  
    DW_OBSTACLE_REGION_STATIC   = (1 << 9),  
    DW_OBSTACLE_REGION_ANIMATE  = (1 << 10), 

    DW_OBSTACLE_REGION_NOT_DRIVABLE = (1 << 11),
    DW_OBSTACLE_REGION_NOT_ANIMATE = (1 << 12),
    DW_OBSTACLE_REGION_NOT_STATIC = (1 << 13),
    DW_OBSTACLE_REGION_UNKNOWN = (1 << 14)
} dwObstacleRegionClass;

typedef struct dwObstacleSegment
{
    dwObstacleRegionClass regionClass; 
    float32_t classConfidence;         
    uint64_t sourceIdMask;             
    float32_t distance_m;
    int32_t endIndex;
    uint64_t endObstacleId;
} dwObstacleSegment;

#define DW_OBSTACLE_SECTOR_MAX_SEGMENTS 10
#define DW_OBSTACLE_RDF_MAX_SECTORS 4000

typedef struct dwObstacleSector
{
    uint32_t segmentCount;                                       
    dwObstacleSegment segments[DW_OBSTACLE_SECTOR_MAX_SEGMENTS]; 
} dwObstacleSector;

// Obstacle Radial Distance Map
typedef struct dwObstacleRDM
{
    dwTime_t timestamp_us; 

    //Data
    uint32_t sectorCount;                                  
    dwObstacleSector sectors[DW_OBSTACLE_RDF_MAX_SECTORS]; 

    //Angles are defined so that (cos(angle),sin(angle)) works with the world coordinate
    //system. This means zero starts straight ahead and then going counter-clockwise.
    //To be clear about the direction of the sector, angleMin_r<=angle_max_r always
    //holds and the sector is always counter-clockwise starting from angleMin_r.
    // -PI<angleMin_r<=PI always holds but to allow a sector spanning straight back
    //angleMax_r can be more than PI, but is never more than three PI.
    float32_t angleMin_r; 
    float32_t angleMax_r; 
} dwObstacleRDM;

DW_API_PUBLIC
dwStatus dwObstacle_reset(dwObstacle* obstacle);

#ifdef __cplusplus
}
#endif

#endif // DW_WORLD_OBSTACLE_H_