Object.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_WORLD_OBJECT_H_
#define DW_WORLD_OBJECT_H_

#include <dw/core/Context.h>
#include <dw/sensors/Sensors.h>
#include <dw/worldmodel/LaneGraph.h>
#include <dw/world/TrafficSigns.h>
#include <dw/sensors/radar/Radar.h>
#include <dw/rig/CoordinateSystem.h>

#include <dw/worldmodel/Obstacle.h>
#include <dw/worldmodel/LaneAssignment.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DW_OBJECT_MAX_FUSED_PARENT_OBJECT_COUNT 6
#define DW_OBJECT_MAX_BOUNDARY_POINT_COUNT 30

typedef struct dwObjectLaneSpan
{
    uint32_t globalLaneID;
    dwVector3f anchorPoint;
    dwVector3f frontPoint;
    dwVector3f rearPoint;
    float32_t frontDistance;
    float32_t rearDistance;
} dwObjectLaneSpan;

typedef struct dwObjectLaneAssignment
{
    float32_t ratio;
    uint32_t laneId;
    dwLaneGraphLaneType type;
    float32_t predictedRatio;
} dwObjectLaneAssignment;

#define DW_OBJECT_IN_PATH_ANALYZER_MAX_LANE_COUNT 32

typedef struct dwObjectLaneAssignmentList
{
    dwObjectLaneAssignment assignments[DW_OBJECT_IN_PATH_ANALYZER_MAX_LANE_COUNT];
    uint32_t count;
    uint32_t dominantLaneAssignment;
} dwObjectLaneAssignmentList;

DW_DEPRECATED("Use dwCoordinateSystem from dw/rig/CoordinateSystem.h")
typedef enum dwCoordSystem {
    /*
     * DW_COORD_SYSTEM_SENSOR
     * This is the local coordinate system each sensor uses.
     * The conventions used in the SDK vary from sensor to sensor.
     */
    DW_COORD_SYSTEM_SENSOR = DW_COORDINATE_SYSTEM_SENSOR,
    /*
     * DW_COORD_SYSTEM_RIG
     * This coordinate system is well defined as having the origin as the projection
     * of the center of the rear axle onto the nominal ground. X direction points to
     * the motion direction of the vehicle, Y axis points to the left side of the
     * vehicle and Z axis points up to the sky. Velocities and kinematics attribute
     * of detected objects are relative to current ego speed.
     */
    DW_COORD_SYSTEM_RIG = DW_COORDINATE_SYSTEM_VEHICLE_BASE,
    /*
     * DW_COORD_SYSTEM_LOCAL
     * This coordinate system is well defined as having the origin as the projection
     * of the center of the rear axle onto the nominal ground. X direction points to
     * the motion direction of the vehicle, Y axis points to the left side of the
     * vehicle and Z axis points up to the sky. Velocities and kinematics attribute
     * of detected objects are absolute.
     */
    DW_COORD_SYSTEM_LOCAL = DW_COORDINATE_SYSTEM_LOCAL,
    /*
     * DW_COORD_SYSTEM_WORLD
     * This coordinate system represents positions in the map/earth coordinates and is
     * expressed in World Geodetic System 1984 (WGS84) and ENU axis convention.
     * Velocities and kinematics attribute of detected objects are absolute.
     */
    DW_COORD_SYSTEM_WORLD = DW_COORDINATE_SYSTEM_WORLD,
    /*
     * DW_COORD_SYSTEM_CUSTOM
     * This represents any arbitrary coordinate system that the developer wants to use.
     */
    DW_COORD_SYSTEM_CUSTOM = DW_COORDINATE_SYSTEM_CUSTOM,
    DW_COORD_SYSTEM_COUNT
} dwCoordSystem;

typedef enum dwObjectState {
    DW_OBJECT_STATE_STATIONARY          = 0,
    DW_OBJECT_STATE_MOVING              = 1,
    DW_OBJECT_STATE_MOVING_ONCOMING     = 2,
    DW_OBJECT_STATE_MOVING_CROSSTRAFFIC = 3,
    DW_OBJECT_STATE_UNKNOWN             = 4,
    DW_OBJECT_STATE_COUNT
} dwObjectState;

typedef struct dwObjectGeneric
{
    uint64_t id;
    dwObjectClass objectClass;
    float32_t classConfidence;
    dwTime_t timestamp_us;

    // Kinematic information
    // Object kinematic state.
    dwObjectState objectState;
    // Reference coordinate system.
    dwCoordinateSystem coordSystem;
    dwVector3f position;
    dwVector3f velocity;
    float32_t velocityConfidence;
    float32_t orientation_r;
    bool isInverseTTCValid;
    float32_t inverseTimeToCollision_s;

    // Shape information
    bool isBoundaryValid;
    uint32_t boundaryPointCount;
    dwVector3f boundaryPoints[DW_OBJECT_MAX_BOUNDARY_POINT_COUNT];
    dwObjectLaneAssignmentList laneAssignments;

    uint32_t laneSpansCount;
    dwObjectLaneSpan laneSpans[DW_LANEGRAPH_LANE_TYPE_COUNT];
} dwObjectGeneric;

#define DW_OBJECT_CUBOID_2D_COUNT 8
#define DW_OBJECT_MAX_SUBCLASS_COUNT_PER_CLASS 3
#define DW_OBJECT_MAX_SENSOR_COUNT 20
#define DW_OBJECT_MAX_CAMERA_COUNT 7
#define DW_OBJECT_MAX_RADAR_COUNT 1

typedef struct dwObjectCamera
{
    dwObstacle obstacle;
    uint32_t sensorId;
    uint32_t objectSubClass;
    uint32_t clusterCount;
    dwRectf box2D;
    dwVector2f cuboid2D[DW_OBJECT_CUBOID_2D_COUNT];
    dwOrientedBoundingBox3f cuboid3D;
    dwVector2f visibility25D;
    float32_t orientation25D_r;
    float32_t frontMarker25D;
    float32_t rearMarker25D;
    float32_t pointFrontMarker25D;
    float32_t pointRearMarker25D;
    dwVector2f imageVelocity;
    dwVector3f velocityRelative;
    bool isInverseTTCValid;
    float32_t inverseTimeToCollision_s;
    float32_t subclassConfidence[DW_OBJECT_MAX_SUBCLASS_COUNT_PER_CLASS];
    float32_t occlusionConfidenceDNN;
    bool isOccludedDNN;

    // Kinematics
    float32_t distance_m;
    float32_t depth_m;
    float32_t urgency;
    bool isUrgencyValid;
    float32_t longitudinalVelocity;

    bool isVelInTempBaselineValid;
    uint32_t imageVelocityTempBaseline;
    dwVector2f velocityInTempBaseline;
    bool isGeometricFittingValid;
    // Tracking parameters
    bool isSmall;
    float32_t scaleFactor;
    uint32_t age;
    float32_t occlusionConfidence;
    bool isOccluded;
    float32_t curvature;
    float32_t azimuth_r;
    float32_t azimuthRight_r;
    float32_t azimuthLeft_r;
    dwVector2f velocityDirection;
    bool isObjectInFrame;
    dwVector2f anchor;
} dwObjectCamera;

typedef struct dwObjectLidar
{
    dwObstacle obstacle;
    dwObjectGeneric details;
    uint32_t sensorId;
    float32_t confidence;
    dwVector3f rotation;
    dwVector3f dimensions;
    // Confidence obstacle class matches mask DW_OBSTACLE_CLASS_IS_VEHICLE
    float32_t vehicleConfidence;
    // Confidence obstacle class matches mask DW_OBSTACLE_CLASS_IS_PEDESTRIAN or DW_OBSTACLE_CLASS_IS_BIKE
    float32_t vruConfidence;

} dwObjectLidar;

typedef struct dwObjectRadar
{
    dwObstacle obstacle;

    uint32_t sensorId; // Sensor ID
    float32_t radialVelocity;
    float32_t radius;
    float32_t azimuth_r;
    float32_t confidence;
    uint32_t age;
    dwRadarDynamicState dynamicState;
    bool isElevationValid; // maybe elevationAvailable?

} dwObjectRadar;

typedef struct dwObjectFused
{
    dwObstacle obstacle;

    bool isAssociated[DW_OBJECT_MAX_SENSOR_COUNT];            
    uint64_t associatedObjectIds[DW_OBJECT_MAX_SENSOR_COUNT]; 
    // Trajectory circle fitting parameter (center)
    dwVector2f fittedCircleCenter;
    // Trajectory circle fitting parameter (radius)
    float32_t fittedCircleRadius;
    // Z component of found angular velocity with fitted circle
    float32_t angularVelocityZ;
    // Validity of angularVelocityZ
    bool hasAngularVelocity;
    bool isInverseTTCValid;
    float32_t inverseTimeToCollision_s;
} dwObjectFused;

#define MAX_FREESPACE_BOUNDARY_POINT_COUNT 10 * MAX_OBJECT_BOUNDARY_POINT_COUNT

typedef struct dwObjectFreespace
{
    dwObstacle obstacle;
    dwObjectGeneric details;
} dwObjectFreespace;

typedef struct dwObjectTrafficSignal
{
    uint64_t id;
    dwCoordinateSystem coordSystem;
    uint32_t clusterCount;
    dwTime_t timestamp_us;
    // 2D bounding box
    dwBbox2Df box2D;
    // 3D bounding box
    dwBbox3Df box3D;
    // Sign or light
    dwTrafficSignalType type;
    // Raw light class from detection.
    dwTrafficLightClass rawLightType;
    // Processed light class after post processing (e.g. temporal)
    dwTrafficLightClass processedLightType;
    // Raw sign class from detection.
    dwSignClass rawSignType;
    // Processed sign class after post processing (e.g. temporal)
    dwSignClass processedSignType;
    // Confidence value
    float32_t confidence;
    // Valid object or not
    bool valid;
} dwObjectTrafficSignal;

DW_API_PUBLIC
dwStatus dwObjectGeneric_reset(dwObjectGeneric* object);

DW_API_PUBLIC
dwStatus dwObjectCamera_reset(dwObjectCamera* object);

DW_API_PUBLIC
dwStatus dwObjectLidar_reset(dwObjectLidar* object);

DW_API_PUBLIC
dwStatus dwObjectRadar_reset(dwObjectRadar* object);

DW_API_PUBLIC
dwStatus dwObjectFreespace_reset(dwObjectFreespace* object);

DW_API_PUBLIC
dwStatus dwObjectFused_reset(dwObjectFused* object);

DW_API_PUBLIC
dwStatus dwObjectGeneric_toObstacleLaneAssignment(dwObstacleLaneAssignment* out, const dwObjectGeneric* in);

DW_API_PUBLIC
dwStatus dwObjectGeneric_fromObstacleLaneAssignment(dwObjectGeneric* out, const dwObstacleLaneAssignment* in);

DW_API_PUBLIC
dwStatus dwObjectGeneric_toObstacle(dwObstacle* out, const dwObjectGeneric* in);

DW_API_PUBLIC
dwStatus dwObjectGeneric_fromObstacle(dwObjectGeneric* out, const dwObstacle* in);

#ifdef __cplusplus
}
#endif

#endif // DW_WORLD_OBJECT_H_