PilotNetDetector.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-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_PILOTNETDETECTOR_H_
#define DW_PILOTNETDETECTOR_H_

#include <dw/core/Config.h>
#include <dw/core/Types.h>
#include <dw/image/Image.h>
#include <dw/perception/path/camera/PilotNet.h>
#include <dw/calibration/cameramodel/CameraModel.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DW_PILOTNET_MAX_TRAJ_LEN 200

#define DW_PILOTNET_MAX_CAMERA_COUNT 7
#define DW_PILOTNET_MAX_ROI_VIEWS_PER_CAMERA 3
#define DW_PILOTNET_MAX_ROI_VIEWS DW_PILOTNET_MAX_CAMERA_COUNT* DW_PILOTNET_MAX_ROI_VIEWS_PER_CAMERA

typedef enum dwPilotNetDrivingMode {
    DW_PILOTNET_LANE_STABLE,
    DW_PILOTNET_LANE_CHANGE_LEFT_FIRST_HALF,
    DW_PILOTNET_LANE_CHANGE_LEFT_SECOND_HALF,
    DW_PILOTNET_LANE_CHANGE_RIGHT_FIRST_HALF,
    DW_PILOTNET_LANE_CHANGE_RIGHT_SECOND_HALF,
    DW_PILOTNET_LANE_SPLIT_LEFT,
    DW_PILOTNET_LANE_SPLIT_RIGHT,
    DW_PILOTNET_TURN_LEFT,
    DW_PILOTNET_TURN_RIGHT,
    DW_PILOTNET_LANE_LEFT,
    DW_PILOTNET_LANE_RIGHT,
    DW_PILOTNET_MAX_DRIVING_MODES
} dwPilotNetDrivingMode;

typedef enum {
    DW_PILOTNET_FRONT_CENTER_60FOV,
    DW_PILOTNET_FRONT_CENTER_120FOV,
    DW_PILOTNET_FRONT_LEFT_120FOV,
    DW_PILOTNET_FRONT_RIGHT_120FOV,
    DW_PILOTNET_CROSS_LEFT_120FOV,
    DW_PILOTNET_CROSS_RIGHT_120FOV
} dwPilotNetCameraType;

typedef struct
{
    dwPilotNetCameraType camera;
    cudaStream_t stream;
    dwRect inDimensions;
    uint32_t sensorId;
    float32_t fps;
    dwCameraModelHandle_t cameraModel;
    dwTransformation3f cameraExtrinsics;
} dwPilotNetDetectorInputSensor;

typedef struct
{
    dwPilotNetDetectorInputSensor sensors[DW_PILOTNET_MAX_CAMERA_COUNT];
    uint32_t numSensors;
} dwPilotNetDetectorParams;

typedef struct
{
    float32_t curSpeed;
    float32_t lcLength;
} dwPilotNetDetectorState;

typedef struct
{
    dwVector3f leftLaneDivider[DW_PILOTNET_MAX_TRAJ_LEN];
    dwVector3f rightLaneDivider[DW_PILOTNET_MAX_TRAJ_LEN];
    bool leftLaneDividerValid;
    bool rightLaneDividerValid;
} dwPilotNetLaneDivider;

typedef struct
{
    dwTime_t inputTimestamp;
    dwTime_t commandTimeStamp;
    float32_t rotation;
    bool rotationValid;
    float32_t cameraPitch;
    bool cameraPitchValid;
    float32_t lcStatus[DW_PILOTNET_MAX_DRIVING_MODES];
    bool lcStatusValid[DW_PILOTNET_MAX_DRIVING_MODES];
    dwVector3f trajectory[DW_PILOTNET_MAX_DRIVING_MODES][DW_PILOTNET_MAX_TRAJ_LEN];
    bool trajectoryValid[DW_PILOTNET_MAX_DRIVING_MODES];
    dwPilotNetLaneDivider laneDividers[DW_PILOTNET_MAX_DRIVING_MODES];
    size_t trajectoryLen[DW_PILOTNET_MAX_DRIVING_MODES];
} dwPilotNetDetectorOutput;

typedef struct dwPilotNetDetectorObject* dwPilotNetDetectorHandle_t;

DW_API_PUBLIC
dwStatus dwPilotNetDetector_initParams(dwPilotNetDetectorParams* params,
                                       dwPilotNetHandle_t pilotnetDNN);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_initialize(dwPilotNetDetectorHandle_t* pilotnet,
                                       const dwPilotNetDetectorParams* params,
                                       dwPilotNetHandle_t pilotnetDNN);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_release(dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_reset(dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_bindOutput(dwPilotNetDetectorOutput* output,
                                       dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_setState(dwPilotNetDetectorState inputState,
                                     dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_setCameraFrame(const dwImageCUDA* inputFrame,
                                           uint32_t sensorId,
                                           dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_processFrames(dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_infer(dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_processOutput(dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_getVisMaskU8(const dwImageCUDA** dwImg,
                                         uint32_t* numROI,
                                         uint32_t sensorId,
                                         dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_getPatchU8(const dwImageCUDA** dwImg,
                                       uint32_t* numROI,
                                       uint32_t sensorId,
                                       dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_getROIParams(dwRectf* roi,
                                         uint32_t* numROI,
                                         uint32_t sensorId,
                                         dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_convertPointsRigToSensor(dwVector2f* points,
                                                     size_t numPoints,
                                                     const dwVector3f* trajPoints,
                                                     size_t numTrajPoints,
                                                     uint32_t sensorId,
                                                     dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_setSensorExtrinsics(const dwTransformation3f* tx,
                                                const uint32_t sensorId,
                                                dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_getAvailableDrivingModes(bool* modes,
                                                     dwPilotNetDetectorHandle_t pilotnet);

DW_API_PUBLIC
dwStatus dwPilotNetDetector_getDrivingModeString(const char** string,
                                                 dwPilotNetDrivingMode drivingMode);

#ifdef __cplusplus
}
#endif

#endif // DW_PILOTNETDETECTOR_H_