apollo::perception::camera 命名空间参考

命名空间
namespace	app
namespace	bevformer
namespace	caddn
namespace	darkSCNN
namespace	denseline
namespace	lane
namespace	location_refiner
namespace	petr
namespace	smoke
namespace	tracking_feature
namespace	yolo
namespace	yolox3d

类
class	AdaptiveKalmanFilter
struct	AnchorBox
class	BaseCalibrationService
class	BaseCalibrator
class	BaseCameraPerception
class	BaseCipv
class	BaseFeatureExtractor
class	BaseFilter
class	BaseLaneDetector
class	BaseLanePostprocessor
class	BaseMatcher
class	BaseObstacleDetector
class	BaseObstacleTracker
class	BasePostprocessor
class	BasePredictor
class	BaseSimilar
class	BaseTracker
class	BaseTransformer
struct	BBox3D
class	BEVFORMERObstacleDetector
class	BEVObstacleDetector
class	CaddnObstacleDetector
struct	CalibrationServiceInitOptions
struct	CalibrationServiceOptions
struct	CalibrationServiceParam
struct	CalibratorInitOptions
struct	CalibratorOptions
struct	CalibratorParams
struct	CameraDetectionBEV
class	CameraDetectionBevComponent
struct	CameraDetectionMultiStage
class	CameraDetectionMultiStageComponent
class	CameraDetectionOccComponent
struct	CameraDetectionSingleStage
class	CameraDetectionSingleStageComponent
struct	CameraFrame
class	CameraGroundPlaneDetector
struct	CameraGroundPlaneParams
struct	CameraLocationEstimation
class	CameraLocationEstimationComponent
struct	CameraLocationRefinement
class	CameraLocationRefinementComponent
struct	CameraPerceptionInitOptions
struct	CameraPerceptionOptions
struct	CameraStatus
class	CameraTrack
class	CameraTracker
class	CameraTrackingComponent
struct	CameraTrackingComponentConfig
struct	CameraTrackingFrame
class	CameraTrackManager
class	CarPose
struct	Channel
class	Cipv
struct	CipvInitOptions
struct	CipvOptions
struct	CipvParam
struct	CmpLanePointY
class	ConnectedComponent
class	CosineSimilar
class	DarkSCNNLaneDetector
class	DarkSCNNLanePostprocessor
class	DataProvider
struct	Debug
class	DenselineLaneDetector
class	DenselineLanePostprocessor
struct	DetectionChannel
struct	Dim
class	DisjointSet
struct	EgoLane
struct	EstimationChannel
class	ExtendedKalmanFilter
class	ExternalFeatureExtractor
struct	FeatureExtractorInitOptions
struct	FeatureExtractorLayer
struct	FeatureExtractorOptions
class	FirstOrderRCLowPassFilter
struct	GlobalConfig
class	GPUSimilar
struct	GridAndStride
class	GroundPlaneTracker
class	HistogramEstimator
struct	HistogramEstimatorParams
class	HMMatcher
struct	Hypothesis
struct	image2D
class	KalmanFilterConstState
class	KalmanFilterConstVelocity
struct	KalmanParam
class	LaneBasedCalibrator
class	LaneCameraPerception
struct	LaneDetectorInitOptions
struct	LaneDetectorOptions
struct	LaneLine
class	LaneLineCalibrator
struct	LanePointInfo
struct	LanePostprocessorInitOptions
struct	LanePostprocessorOptions
struct	LineSegment2D
struct	LocalCalibratorInitOptions
class	LocationRefinerPostprocessor
struct	MatcherConfig
struct	MatcherInitOptions
class	MaxNMeanFilter
class	MeanFilter
struct	MinDims
class	MotionServiceComponent
struct	MulticueParam
class	MultiCueTransformer
struct	NMSParam
struct	NormalizedBBox
struct	Object
class	ObjectMaintainer
struct	ObjectTemplate
class	ObjectTemplateManager
struct	ObjectTemplateMeta
class	ObjMapper
struct	ObjMapperOptions
struct	ObjMapperParams
class	ObjPostProcessor
struct	ObjPostProcessorOptions
struct	ObjPostProcessorParams
struct	ObstacleDetectorInitOptions
class	ObstacleReference
struct	ObstacleTrackerInitOptions
struct	ObstacleTrackerOptions
class	OMTObstacleTracker
struct	OmtParam
class	OnlineCalibrationService
struct	PatchIndicator
class	PlaneMotion
struct	PostprocessorInitOptions
struct	PostprocessorOptions
struct	PostprocessorParam
class	ProjectFeature
struct	Reference
struct	ReferenceParam
struct	RefinementChannel
struct	SensorCameraName
struct	SimilarMap
struct	SinglestageParam
class	SingleStageTransformer
class	SmokeObstacleDetector
struct	Target
struct	TargetParam
class	Timer
struct	TrackerConfig
struct	TrackerInitOptions
struct	TrackerOptions
class	TrackingFeatureExtractor
struct	TrackObject
struct	TrackObjectMatcherOptions
struct	TrafficLightFrame
struct	Transform
struct	TransformerInitOptions
struct	TransformerParams
class	TransformServer
class	UndistortionHandler
struct	VanishingPoint
class	Visualizer
struct	WeightParam
struct	YoloBlobs
class	YoloObstacleDetector
class	Yolox3DObstacleDetector

类型定义
typedef std::pair< size_t, size_t >	TrackObjectPair
typedef std::shared_ptr< CameraTrack >	CameraTrackPtr
typedef std::shared_ptr< TrackObject >	TrackObjectPtr
typedef std::vector< TrackObjectPtr >	TrackObjectPtrs
using	Clock = apollo::cyber::Clock
typedef std::map< base::ObjectSubType, std::vector< float > >	TemplateMap
typedef std::vector< base::Point3DF >	Point3DSet
typedef std::vector< base::Point2DF >	Point2DSet
typedef std::shared_ptr< apollo::drivers::Image >	ImageMsgType
typedef std::shared_ptr< localization::LocalizationEstimate >	LocalizationMsgType

枚举
enum class	TrackState { Predict , Associate2D , Associate3D , Track }
enum class	TemplateIndex { CAR_MIN_VOLUME_INDEX , VAN_MIN_VOLUME_INDEX , TRUCK_MIN_VOLUME_INDEX , BUS_MIN_VOLUME_INDEX }
enum class	LaneType { UNKNOWN_LANE = -1 , EGO_LANE = 0 , ADJACENT_LEFT_LANE = 1 , ADJACENT_RIGHT_LANE = 2 }

函数
	CYBER_REGISTER_COMPONENT (CameraDetectionBevComponent)
	REGISTER_OBSTACLE_DETECTOR (BEVObstacleDetector)
base::ObjectSubType	GetSubtype (int cls, const std::vector< base::ObjectSubType > &types)
	Get the Subtype
void	GetObjects (const base::BlobPtr< float > &box3ds, const base::BlobPtr< float > &labels, const base::BlobPtr< float > &scores, const std::vector< base::ObjectSubType > &types, float score_threshold, std::vector< base::ObjectPtr > *objects)
	Get the Objects objects from blob
void	FillBBox3d (const float *bbox, base::ObjectPtr obj)
	Fill the 3d bbox to object
void	Resize (cv::Mat *img, cv::Mat *img_n, int width, int height)
	Image resize function
void	Crop (cv::Mat *img, cv::Mat *img_n, int x, int y, int width, int height)
	Image crop function
void	Normalize (const std::vector< float > &mean, const std::vector< float > &std, float scale, cv::Mat *img)
	Image normalize function
	PERCEPTION_REGISTER_REGISTERER (BaseObstacleDetector)
	CYBER_REGISTER_COMPONENT (CameraDetectionMultiStageComponent)
void	get_intersect_bbox (const NormalizedBBox &bbox1, const NormalizedBBox &bbox2, NormalizedBBox *intersect_bbox)
	Get the intersect bbox object
float	get_bbox_size (const NormalizedBBox &bbox)
float	get_jaccard_overlap (const NormalizedBBox &bbox1, const NormalizedBBox &bbox2)
	Get the jaccard overlap object
void	get_max_score_index (const std::vector< float > &scores, const float threshold, const int top_k, std::vector< std::pair< float, int > > *score_index_vec)
	Get the max score index object
void	apply_softnms_fast (const std::vector< NormalizedBBox > &bboxes, std::vector< float > *scores, const float score_threshold, const float nms_threshold, const int top_k, std::vector< int > *indices, bool is_linear, const float sigma)
	softnms for objects
void	apply_boxvoting_fast (std::vector< NormalizedBBox > *bboxes, std::vector< float > *scores, const float conf_threshold, const float nms_threshold, const float sigma, std::vector< int > *indices)
	filter target detection results based on given thresholds and parameters.
void	apply_nms_fast (const std::vector< NormalizedBBox > &bboxes, const std::vector< float > &scores, const float score_threshold, const float nms_threshold, const float eta, const int top_k, std::vector< int > *indices)
	nms for objects
void	filter_bbox (const MinDims &min_dims, std::vector< base::ObjectPtr > *objects)
	filter out the objects in the object array based on the given minimum dimension conditions and retain the objects that meet the conditions
void	recover_bbox (int roi_w, int roi_h, int offset_y, std::vector< base::ObjectPtr > *objects)
	recover detect bbox result to raw image
void	fill_base (base::ObjectPtr obj, const float *bbox)
	add bbox value to object
void	fill_bbox3d (bool with_bbox3d, base::ObjectPtr obj, const float *bbox)
	add alpha h w l to object
void	fill_frbox (bool with_frbox, base::ObjectPtr obj, const float *bbox)
	add car front and backward bbox value to object
void	fill_lights (bool with_lights, base::ObjectPtr obj, const float *bbox)
	add car lights value to object
void	fill_ratios (bool with_ratios, base::ObjectPtr obj, const float *bbox)
	add ratio value to object
void	fill_area_id (bool with_flag, base::ObjectPtr obj, const float *data)
	add area id value to object
int	get_area_id (float visible_ratios[4])
	calculate the area id based on the visible ratios
const float *	get_cpu_data (bool flag, const base::Blob< float > &blob)
void	get_objects_cpu (const YoloBlobs &yolo_blobs, const cudaStream_t &stream, const std::vector< base::ObjectSubType > &types, const NMSParam &nms, const yolo::ModelParam &model_param, float light_vis_conf_threshold, float light_swt_conf_threshold, base::Blob< bool > *overlapped, base::Blob< int > *idx_sm, std::vector< base::ObjectPtr > *objects)
	Get the objects cpu object
__host__ __device__ float	sigmoid_gpu (float x)
__host__ __device__ float	bbox_size_gpu (const float *bbox, const bool normalized)
__host__ __device__ float	jaccard_overlap_gpu (const float *bbox1, const float *bbox2)
template<typename T >
bool	sort_score_pair_descend (const std::pair< float, T > &pair1, const std::pair< float, T > &pair2)
void	apply_nms (const bool *overlapped, const int num, std::vector< int > *indices)
	Get all boxes with score larger than threshold
void	apply_nms_gpu (const float *bbox_data, const float *conf_data, const std::vector< int > &origin_indices, const int bbox_step, const float confidence_threshold, const int top_k, const float nms_threshold, std::vector< int > *indices, base::Blob< bool > *overlapped, base::Blob< int > *idx_sm, const cudaStream_t &_stream)
	Get all boxes with score larger than threshold
void	compute_overlapped_by_idx_gpu (const int nthreads, const float *bbox_data, const float overlap_threshold, const int *idx, const int num_idx, bool *overlapped_data, const cudaStream_t &_stream)
	Get all boxes with score larger than threshold
int	get_objects_gpu (const YoloBlobs &yolo_blobs, const cudaStream_t &stream, const std::vector< base::ObjectSubType > &types, const NMSParam &nms, const yolo::ModelParam &model_param, float light_vis_conf_threshold, float light_swt_conf_threshold, base::Blob< bool > *overlapped, base::Blob< int > *idx_sm, const std::map< base::ObjectSubType, std::vector< int > > &indices, const std::map< base::ObjectSubType, std::vector< float > > &conf_scores)
	Get the objects gpu object
const float *	get_gpu_data (bool flag, const base::Blob< float > &blob)
	Get the gpu data object
	REGISTER_OBSTACLE_DETECTOR (YoloObstacleDetector)
void	YoloxGetAllObjects (const float *data, const yolox3d::ModelParam &model_param, const float scale, std::vector< std::vector< float > > *objects_out)
	Get all objects accoring to confidence
float	ComputeYoloxOverlap (const base::Rect< float > &a, const base::Rect< float > &b)
void	YoloxFillBase (const std::vector< float > &detect, const int width, const int height, const int image_width, const int image_height, base::ObjectPtr obj)
	Get 2dbbox for objects
void	YoloxFillBbox3d (const yolox3d::ModelParam &model_param, const std::vector< float > &detect, base::ObjectPtr obj)
	Add 3d bbox values for objects
float	YoloxBboxIOU (const std::vector< float > &box1, const std::vector< float > &box2)
	Computes IoU between bboxes.
void	YoloxTruncated (base::ObjectPtr obj, const int image_width, const int image_height)
	object is truncated or not
void	YoloxGetObjectsCpu (const std::shared_ptr< base::Blob< float > > &objects_blob, const yolox3d::ModelParam &model_param, const yolox3d::NMSParam &nms_param, const int width, const int height, const int image_width, const int image_height, std::vector< base::ObjectPtr > *objects)
	Return Yolox Objects
template<typename T >
constexpr T	Yoloxclamp (const T &val, const T &low, const T &high)
	Clamp target value between low and high tools for iou
void	AddShape3DYolox (std::map< std::string, std::vector< int > > *shape_map, const google::protobuf::RepeatedPtrField< common::ModelBlob > &model_blobs)
std::vector< std::string >	GetBlobNames3DYolox (const google::protobuf::RepeatedPtrField< common::ModelBlob > &model_blobs)
cv::Mat	resizeKeepAspectRatioYolox (const cv::Mat &input, const cv::Size &dstSize, const cv::Scalar &bgcolor)
	REGISTER_OBSTACLE_DETECTOR (Yolox3DObstacleDetector)
	CYBER_REGISTER_COMPONENT (CameraDetectionOccComponent)
	REGISTER_OBSTACLE_DETECTOR (BEVFORMERObstacleDetector)
void	BevFormerResize (cv::Mat *img, cv::Mat *img_n, int width, int height)
	Image resize function
void	BevFormerCrop (cv::Mat *img, cv::Mat *img_n, int x, int y, int width, int height)
	Image crop function
void	BevFormerNormalize (const std::vector< float > &mean, const std::vector< float > &std, float scale, cv::Mat *img)
	Image normalize function
	PERCEPTION_REGISTER_REGISTERER (BaseMatcher)
	PERCEPTION_REGISTER_REGISTERER (BaseTracker)
	PERCEPTION_REGISTER_TRACKER (CameraTracker)
	PERCEPTION_REGISTER_MATCHER (HMMatcher)
void	SetSemanticLabel (PointSemanticLabel label, uint8_t *value)
PointSemanticLabel	GetSemanticLabel (uint8_t value)
bool	IsSemanticLabel (PointSemanticLabel label, uint8_t value)
void	SetSceneFlowLabel (PointSemanticLabel label, uint8_t *value)
PointSemanticLabel	GetSceneFlowLabel (uint8_t value)
bool	IsSceneFlowLabelEqual (PointSemanticLabel label, uint8_t value)
	CYBER_REGISTER_COMPONENT (CameraDetectionSingleStageComponent)
	REGISTER_OBSTACLE_DETECTOR (CaddnObstacleDetector)
void	GetCaddnObjects (std::vector< base::ObjectPtr > *objects, const caddn::ModelParam &model_param, const std::vector< base::ObjectSubType > &types, const base::BlobPtr< float > &boxes, const base::BlobPtr< float > &labels, const base::BlobPtr< float > &scores)
	Get the Caddn Objects objects from Blob
void	Bbox3dLidar2Camera (const Eigen::Matrix< float, 3, 4 > &V2C, const Eigen::Matrix< float, 3, 3 > &R, const float *bbox_lidar, std::vector< float > *bbox_camera)
	Get the Caddn Objects objects from Blob
void	FillCaddnBbox3d (base::ObjectPtr obj, const float *bbox)
	Add objects values to object
void	FilterByMinDims (const smoke::MinDims &min_dims, std::vector< base::ObjectPtr > *objects)
void	RecoverBBox (int roi_w, int roi_h, int offset_y, std::vector< base::ObjectPtr > *objects)
void	FillBBox (base::ObjectPtr obj, const float *bbox, int width, int height)
void	FillBBox3d (base::ObjectPtr obj, const float *bbox)
void	GetObjectsCpu (const std::shared_ptr< base::Blob< float > > &output_blob, const std::vector< base::ObjectSubType > &types, const smoke::ModelParam &model_param, std::vector< base::ObjectPtr > *objects, int width, int height)
	REGISTER_OBSTACLE_DETECTOR (SmokeObstacleDetector)
	CYBER_REGISTER_COMPONENT (CameraLocationEstimationComponent)
	PERCEPTION_REGISTER_REGISTERER (BaseTransformer)
	REGISTER_OBSTACLE_TRANSFORMER (MultiCueTransformer)
	REGISTER_OBSTACLE_TRANSFORMER (SingleStageTransformer)
	CYBER_REGISTER_COMPONENT (CameraLocationRefinementComponent)
	PERCEPTION_REGISTER_REGISTERER (BasePostprocessor)
	REGISTER_OBSTACLE_POSTPROCESSOR (LocationRefinerPostprocessor)
	CYBER_REGISTER_COMPONENT (CameraTrackingComponent)
	REGISTER_FEATURE_EXTRACTOR (ExternalFeatureExtractor)
	REGISTER_FEATURE_EXTRACTOR (ProjectFeature)
	REGISTER_FEATURE_EXTRACTOR (TrackingFeatureExtractor)
	PERCEPTION_REGISTER_REGISTERER (BaseFeatureExtractor)
	PERCEPTION_REGISTER_REGISTERER (BaseObstacleTracker)
	PERCEPTION_REGISTER_REGISTERER (BasePredictor)
void	ProjectBox (const base::BBox2DF &box_origin, const Eigen::Matrix3d &transform, base::BBox2DF *box_projected)
	REGISTER_OBSTACLE_TRACKER (OMTObstacleTracker)
void	ConvertGround3ToGround4 (const float &baseline, const std::vector< float > &k_mat, const std::vector< float > &ground3, std::vector< float > *ground4)
bool	ConvertGround4ToGround3 (const float &baseline, const std::vector< float > &k_mat, const std::vector< float > &ground4, std::vector< float > *ground3)
void	GetGroundPlanePitchHeight (const float &baseline, const std::vector< float > &k_mat, const std::vector< float > &ground3, float *pitch, float *cam_height)
void	GetGround3FromPitchHeight (const std::vector< float > &k_mat, const float &baseline, const float &pitch, const float &cam_height, std::vector< float > *ground3)
template<typename T >
void	GroundHypoGenFunc (const T *v, const T *d, T *p)
template<typename T >
void	GroundFittingCostFunc (const T *p, const T *v, const T *d, int n, int *nr_inlier, int *inliers, T *cost, T error_tol)
cv::Mat	GetImage (const std::string &path, bool to_rgb)
void	Resize (const cv::Mat &input_img, cv::Mat *out_img, int width, int height, double fx, double fy, int interpolation)
std::vector< float >	HWC2CHW (const cv::Mat &input_img)
void	Resize (const cv::Mat &input_img, cv::Mat *out_img, cv::Size size, double fx=0, double fy=0, int interpolation=cv::INTER_LINEAR)
	PERCEPTION_REGISTER_CIPV (Cipv)
bool	imageToBlob (const base::Image8U &image, base::Blob< uint8_t > *blob)
bool	imageToGray (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const float coeffs[3])
bool	swapImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const int order[3])
bool	dupImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height)
bool	imageRemap (const base::Image8U &src_img, base::Image8U *dst_img, const int src_width, const int src_height, const base::Blob< float > &map_x, const base::Blob< float > &map_y)
bool	nppImageToBlob (const base::Image8U &image, base::Blob< uint8_t > *blob)
bool	nppImageToGray (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const float coeffs[3])
bool	nppSwapImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const int order[3])
bool	nppDupImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height)
bool	nppImageRemap (const base::Image8U &src_img, base::Image8U *dst_img, const int src_width, const int src_height, const base::Blob< float > &map_x, const base::Blob< float > &map_y)
bool	rppInitDescriptor (RpptDescPtr &descPtr, int width, int height, int channels, int width_step)
bool	rppImageToBlob (const base::Image8U &image, base::Blob< uint8_t > *blob)
bool	rppImageToGray (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const float coeffs[3])
bool	rppSwapImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height, const int order[3])
__global__ void	duplicate_kernel (const unsigned char *src, size_t src_width_step, uchar3 *dst, size_t dst_width_step, int width, int height)
bool	rppDupImageChannels (const base::Image8UPtr &src, const base::Image8UPtr &dst, const int src_width, const int src_height)
__global__ void	remap_pln1_kernel (const unsigned char *src, size_t src_width_step, unsigned char *dst, size_t dst_width_step, const float *mapx, const float *mapy, int width, int height)
__global__ void	remap_pkd3_kernel (const uchar3 *src, size_t src_width_step, uchar3 *dst, size_t dst_width_step, const float *mapx, const float *mapy, int width, int height)
bool	rppImageRemap (const base::Image8U &src_img, base::Image8U *dst_img, const int src_width, const int src_height, const base::Blob< float > &map_x, const base::Blob< float > &map_y)
template<typename Dtype >
Dtype	sigmoid (Dtype x)
template<typename Dtype >
Dtype	gaussian (Dtype x, Dtype mu, Dtype sigma)
template<typename Dtype >
Dtype	sqr (Dtype x)
std::ostream &	operator<< (std::ostream &os, const CarPose &pose)
template<typename T >
T	CalAngleDiff (const T a1, const T a2)
template<typename T >
T	GetSharpAngle (const T &a, const T &b)
template<typename T >
T	GetJaccardIndex (const T *bbox_ref, const T &x_min, const T &y_min, const T &x_max, const T &y_max)
template<typename T >
void	GenRotMatrix (const T &ry, T *rot)
template<typename T >
void	GenCorners (T h, T w, T l, T *x_cor, T *y_cor, T *z_cor)
template<typename T >
bool	Occlude (const T *bbox1, const T &h1, const T *bbox2, const T &h2)
template<typename T >
void	GetBboxFromPts (const T *pts, const int &n, T *bbox)
template<typename T >
int	GetMinIndexVec (const T *vec, const int &n)
template<typename T >
T	GetScoreViaRotDimensionCenter (const T *k_mat, int width, int height, const T *bbox, const T *rot, const T *hwl, const T *location, const bool &check_truncation, T *bbox_res=nullptr, T *bbox_near=nullptr)
template<typename T >
bool	CheckXY (const T &x, const T &y, int width, int height)
template<typename T >
void	UpdateOffsetZ (T x_start, T z_start, T x_end, T z_end, const std::pair< T, T > &range, T *z_offset)
template<typename T >
void	GetDxDzForCenterFromGroundLineSeg (const LineSegment2D< T > &ls, const T *plane, const T *pts_c, const T *k_mat, int width, int height, T ratio_x_over_z, T *dx_dz, bool check_lowerbound=true)
bool	Equal (double x, double target, double eps)
bool	Equal (float x, float target, float eps)
bool	LoadAnchors (const std::string &path, std::vector< float > *anchors)
bool	LoadTypes (const std::string &path, std::vector< base::ObjectSubType > *types)
bool	LoadExpand (const std::string &path, std::vector< float > *expands)
bool	ResizeCPU (const base::Blob< uint8_t > &src_blob, std::shared_ptr< base::Blob< float > > dst_blob, int stepwidth, int start_axis)
void	FillObjectPolygonFromBBox3D (base::Object *object_ptr)
template<typename T >
bool	IsCovered (const base::Rect< T > &rect1, const base::Rect< T > &rect2, float thresh)
template<typename T >
bool	IsCoveredHorizon (const base::Rect< T > &rect1, const base::Rect< T > &rect2, float thresh)
template<typename T >
bool	IsCoveredVertical (const base::Rect< T > &rect1, const base::Rect< T > &rect2, float thresh)
template<typename T >
bool	Contain (const std::vector< T > &array, const T &element)
template<typename T >
bool	OutOfValidRegion (const base::BBox2D< T > box, const T width, const T height, const T border_size=0)
template<typename T >
bool	OutOfValidRegion (const base::Rect< T > rect, const T width, const T height, const T border_size=0)
template<typename T >
void	RefineBox (const base::Rect< T > &box_in, const T width, const T height, base::Rect< T > *box_out)
template<typename T >
void	RefineBox (const base::BBox2D< T > &box_in, const T width, const T height, base::BBox2D< T > *box_out)
template<typename T >
void	CalculateMeanAndVariance (const std::vector< T > &data, T *mean, T *variance)
	REGISTER_CALIBRATION_SERVICE (OnlineCalibrationService)
void	GetYawVelocityInfo (const float &time_diff, const double cam_coord_cur[3], const double cam_coord_pre[3], const double cam_coord_pre_pre[3], float *yaw_rate, float *velocity)
	REGISTER_CALIBRATOR (LaneLineCalibrator)
	PERCEPTION_REGISTER_REGISTERER (BaseCalibrationService)
	PERCEPTION_REGISTER_REGISTERER (BaseCalibrator)
	PERCEPTION_REGISTER_REGISTERER (BaseCipv)
int	WriteLanelines (const bool enabled, const std::string &save_path, const std::vector< base::LaneLine > &lane_objects)
int	WriteCalibrationOutput (bool enabled, const std::string &out_path, const CameraFrame *frame)
	PERCEPTION_REGISTER_CAMERA_PERCEPTION (LaneCameraPerception)
bool	FindCC (const std::vector< unsigned char > &src, int width, int height, const base::RectI &roi, std::vector< ConnectedComponent > *cc)
bool	ImagePoint2Camera (const base::Point2DF &img_point, float pitch_angle, float camera_ground_height, const Eigen::Matrix3f &intrinsic_params_inverse, Eigen::Vector3d *camera_point)
bool	CameraPoint2Image (const Eigen::Vector3d &camera_point, const Eigen::Matrix3f &intrinsic_params, base::Point2DF *img_point)
bool	ComparePoint2DY (const base::Point2DF &point1, const base::Point2DF &point2)
bool	FindKSmallValue (const float *distance, int dim, int k, int *index)
bool	FindKLargeValue (const float *distance, int dim, int k, int *index)
template<typename Dtype >
bool	PolyFit (const EigenVector< Eigen::Matrix< Dtype, 2, 1 > > &pos_vec, const int &order, Eigen::Matrix< Dtype, max_poly_order+1, 1 > *coeff, const bool &is_x_axis=true)
template<typename Dtype >
bool	PolyEval (const Dtype &x, int order, const Eigen::Matrix< Dtype, max_poly_order+1, 1 > &coeff, Dtype *y)
template<typename Dtype >
bool	RansacFitting (const EigenVector< Eigen::Matrix< Dtype, 2, 1 > > &pos_vec, EigenVector< Eigen::Matrix< Dtype, 2, 1 > > *selected_points, Eigen::Matrix< Dtype, 4, 1 > *coeff, const int max_iters=100, const int N=5, const Dtype inlier_thres=static_cast< Dtype >(0.1))
template<class T >
void	QSwap_ (T *a, T *b)
template<class T >
void	QuickSort (int *index, const T *values, int start, int end)
template<class T >
void	QuickSort (int *index, const T *values, int nsize)
	PERCEPTION_REGISTER_REGISTERER (BaseCameraPerception)
	PERCEPTION_REGISTER_REGISTERER (BaseLaneDetector)
	PERCEPTION_REGISTER_REGISTERER (BaseLanePostprocessor)
	REGISTER_LANE_DETECTOR (DarkSCNNLaneDetector)
	REGISTER_LANE_DETECTOR (DenselineLaneDetector)
std::vector< base::LaneLinePositionType >	spatialLUT ({base::LaneLinePositionType::UNKNOWN, base::LaneLinePositionType::FOURTH_LEFT, base::LaneLinePositionType::THIRD_LEFT, base::LaneLinePositionType::ADJACENT_LEFT, base::LaneLinePositionType::EGO_LEFT, base::LaneLinePositionType::EGO_CENTER, base::LaneLinePositionType::EGO_RIGHT, base::LaneLinePositionType::ADJACENT_RIGHT, base::LaneLinePositionType::THIRD_RIGHT, base::LaneLinePositionType::FOURTH_RIGHT, base::LaneLinePositionType::OTHER, base::LaneLinePositionType::CURB_LEFT, base::LaneLinePositionType::CURB_RIGHT})
template<typename T = float>
T	GetPolyValue (T a, T b, T c, T d, T x)
	REGISTER_LANE_POSTPROCESSOR (DarkSCNNLanePostprocessor)
	REGISTER_LANE_POSTPROCESSOR (DenselineLanePostprocessor)
	CYBER_REGISTER_COMPONENT (MotionServiceComponent)
bool	LoadKittiLabel (onboard::CameraFrame *frame, const std::string &kitti_path, const std::string &dist_type)
	Read KITTI labels and fill to frame->detected_objects
bool	FillImage (onboard::CameraFrame *frame, const std::string &file_name)
	Read image from file_name and fill in frame->data_provider
bool	RecoveryImage (onboard::CameraFrame *frame, cv::Mat *cv_img)
	Recovery cv image from frame->data_provider
bool	GetFileListFromPath (const std::string &file_path, std::vector< std::string > *file_list)
	Get the File List From Path object
bool	GetFileListFromFile (const std::string &file_name, std::vector< std::string > *file_list)
	Get the File List From File object
bool	SaveCameraDetectionResult (onboard::CameraFrame *frame, const std::string &file_name)
	Save detection result to file_name
bool	SaveTfDetectionResult (onboard::CameraFrame *frame, const std::string &file_name)
bool	SaveLaneDetectionResult (onboard::CameraFrame *frame, const std::string &file_name)
bool	CameraVisualization (onboard::CameraFrame *frame, const std::string &file_name)
	Save visualization results to file_name(.jpg)
bool	TfVisualization (onboard::CameraFrame *frame, const std::string &file_name)
bool	LaneVisualization (onboard::CameraFrame *frame, const std::string &file_name)
Eigen::Matrix3d	Camera2CarHomograph (const Eigen::Matrix3d &intrinsic, const Eigen::Matrix4d &extrinsic_camera2lidar, const Eigen::Matrix4d &extrinsic_lidar2imu, double pitch_adj)
bool	InitDataProvider (onboard::CameraFrame *camera_frame)
bool	TestDetection ()

变量
const std::map< std::string, base::ObjectSubType >	kNuScenesName2SubTypeMap
constexpr float	minExpPower = -10.0f
constexpr float	maxExpPower = 5.0f
constexpr int	anchorSizeFactor = 2
constexpr int	numScales = 3
constexpr int	kClassOfObstacles = 8
constexpr int	kScoreIndex = 4
constexpr int	kLabelIndex = 5
const base::ObjectSubType	kYoloSubTypeYolox []
const std::map< int, std::string >	kIndex2NuScenesName
const std::map< std::string, base::ObjectSubType >	kApolloName2SubTypeMap
const std::map< int, std::string >	kIndex2ApolloName
const int	MAX_CAMERA_IDX = 2147483647
const std::map< std::string, base::ObjectSubType >	kKITTIName2SubTypeMap
struct {
}	customLess
struct apollo::perception::camera::CameraFrame	EIGEN_ALIGN16
constexpr float	kMinVelocity = 10.0f
constexpr float	kMaxDistObjectToLaneInMeter = 70.0f
constexpr float	kMaxDistObjectToVirtualLaneInMeter = 10.0f
constexpr float	kMaxDistObjectToLaneInPixel = 10.0f
const std::size_t	kDropsHistorySize = 20
const std::size_t	kMaxObjectNum = 100
const std::size_t	kMaxAllowedSkipObject = 10
const uint32_t	THREADS_PER_BLOCK_X = 32
const uint32_t	THREADS_PER_BLOCK_Y = 32
std::vector< base::ObjectSubType >	kTypeCanBeRef
std::vector< base::ObjectSubType >	kTypeRefinedByTemplate
std::vector< base::ObjectSubType >	kTypeRefinedByRef
const float	kYawRateDefault = 0.0f
const float	kVelocityDefault = 8.333f
const float	kTimeDiffDefault = 0.067f
std::map< base::LaneLinePositionType, int >	spatialLUTind
const std::map< std::string, base::ObjectSubType >	object_subtype_map
std::vector< cv::Scalar >	colorlistobj
std::map< base::LaneLinePositionType, cv::Scalar >	colormapline

类型定义说明

CameraTrackPtr

typedef std::shared_ptr<CameraTrack> apollo::perception::camera::CameraTrackPtr

在文件 camera_track.h 第 162 行定义.

Clock

using apollo::perception::camera::Clock = typedef apollo::cyber::Clock

在文件 camera_tracking_component.cc 第 29 行定义.

ImageMsgType

typedef std::shared_ptr<apollo::drivers::Image> apollo::perception::camera::ImageMsgType

在文件 motion_service_component.h 第 41 行定义.

LocalizationMsgType

typedef std::shared_ptr<localization::LocalizationEstimate> apollo::perception::camera::LocalizationMsgType

在文件 motion_service_component.h 第 42 行定义.

Point2DSet

typedef std::vector<base::Point2DF> apollo::perception::camera::Point2DSet

在文件 common_functions.h 第 35 行定义.

Point3DSet

typedef std::vector<base::Point3DF> apollo::perception::camera::Point3DSet

在文件 common_functions.h 第 34 行定义.

TemplateMap

typedef std::map<base::ObjectSubType, std::vector<float> > apollo::perception::camera::TemplateMap

在文件 object_template_manager.h 第 43 行定义.

TrackObjectPair

typedef std::pair<size_t, size_t> apollo::perception::camera::TrackObjectPair

在文件 base_matcher.h 第 34 行定义.

TrackObjectPtr

typedef std::shared_ptr<TrackObject> apollo::perception::camera::TrackObjectPtr

在文件 track_object.h 第 36 行定义.

TrackObjectPtrs

typedef std::vector<TrackObjectPtr> apollo::perception::camera::TrackObjectPtrs

在文件 track_object.h 第 37 行定义.

枚举类型说明

LaneType

enum class apollo::perception::camera::LaneType

strong

枚举值
UNKNOWN_LANE
EGO_LANE
ADJACENT_LEFT_LANE
ADJACENT_RIGHT_LANE

在文件 denseline_lane_postprocessor.h 第 35 行定义.

                    {
  UNKNOWN_LANE = -1,
  EGO_LANE = 0,
  ADJACENT_LEFT_LANE = 1,
  ADJACENT_RIGHT_LANE = 2
};

TemplateIndex

enum class apollo::perception::camera::TemplateIndex

strong

枚举值
CAR_MIN_VOLUME_INDEX
VAN_MIN_VOLUME_INDEX
TRUCK_MIN_VOLUME_INDEX
BUS_MIN_VOLUME_INDEX

在文件 object_template_manager.h 第 36 行定义.

                         {
  CAR_MIN_VOLUME_INDEX,
  VAN_MIN_VOLUME_INDEX,
  TRUCK_MIN_VOLUME_INDEX,
  BUS_MIN_VOLUME_INDEX,
};

TrackState

enum class apollo::perception::camera::TrackState

strong

枚举值
Predict
Associate2D
Associate3D
Track

在文件 camera_frame.h 第 34 行定义.

{ Predict, Associate2D, Associate3D, Track};

函数说明

AddShape3DYolox()

void apollo::perception::camera::AddShape3DYolox	(	std::map< std::string, std::vector< int > > *	shape_map,
		const google::protobuf::RepeatedPtrField< common::ModelBlob > &	model_blobs
	)

在文件 yolox3d_obstacle_detector.cc 第 58 行定义.

                                                                        {
  for (const auto &blob : model_blobs) {
    std::vector<int> shape(blob.shape().begin(), blob.shape().end());
    shape_map->insert(std::make_pair(blob.name(), shape));
  }
}

apply_boxvoting_fast()

void apollo::perception::camera::apply_boxvoting_fast	(	std::vector< NormalizedBBox > *	bboxes,
		std::vector< float > *	scores,
		const float	conf_threshold,
		const float	nms_threshold,
		const float	sigma,
		std::vector< int > *	indices
	)

filter target detection results based on given thresholds and parameters.

参数

bboxes	2d bbox results
scores	scores results of bbox
conf_threshold	confidence threshold
nms_threshold	nms threshold
sigma	sigma parameter
indices	indices of matched objects

在文件 postprocess.cc 第 138 行定义.

                                                                      {
  if (bboxes->size() == 0) {
    return;
  }
  indices->clear();
  for (int i = 0; i < static_cast<int>(bboxes->size()); i++) {
    (*bboxes)[i].mask = false;
    if ((*scores)[i] > conf_threshold) {
      indices->push_back(i);
    }
  }
  for (int count = 0; count < static_cast<int>(indices->size()); count++) {
    int max_box_idx = 0;
 
    for (int i = 1; i < static_cast<int>(indices->size()); i++) {
      int idx = indices->at(i);
      if ((*bboxes)[idx].mask) {
        continue;
      }
      if ((*scores)[idx] > (*scores)[max_box_idx]) {
        max_box_idx = idx;
      }
    }
 
    NormalizedBBox &best_bbox = (*bboxes)[max_box_idx];
    best_bbox.score = (*scores)[max_box_idx];
    best_bbox.mask = true;
    float s_vt = (*scores)[max_box_idx];
    float x1_vt = best_bbox.xmin * s_vt;
    float x2_vt = best_bbox.xmax * s_vt;
    float y1_vt = best_bbox.ymin * s_vt;
    float y2_vt = best_bbox.ymax * s_vt;
    for (int i = 0; i < static_cast<int>(indices->size()); i++) {
      int sub_it = indices->at(i);
      if ((*bboxes)[sub_it].mask) {
        continue;
      }
      float cur_overlap = 0.;
      cur_overlap = get_jaccard_overlap(best_bbox, (*bboxes)[sub_it]);
      if (sigma == 0) {
        (*bboxes)[sub_it].mask = true;
      } else {
        (*scores)[sub_it] *=
            static_cast<float>(exp(-1.0 * pow(cur_overlap, 2) / sigma));
      }
      (*bboxes)[sub_it].score = (*scores)[sub_it];
 
      // Remove it if necessary
      if (cur_overlap > nms_threshold) {
        float s_vt_cur = (*bboxes)[sub_it].score;
        s_vt += s_vt_cur;
        x1_vt += (*bboxes)[sub_it].xmin * s_vt_cur;
        x2_vt += (*bboxes)[sub_it].xmax * s_vt_cur;
        y1_vt += (*bboxes)[sub_it].ymin * s_vt_cur;
        y2_vt += (*bboxes)[sub_it].ymax * s_vt_cur;
      }
    }
    if (s_vt > 0.0001) {
      (*bboxes)[max_box_idx].xmin = x1_vt / s_vt;
      (*bboxes)[max_box_idx].xmax = x2_vt / s_vt;
      (*bboxes)[max_box_idx].ymin = y1_vt / s_vt;
      (*bboxes)[max_box_idx].ymax = y2_vt / s_vt;
    }
  }
}

apply_nms()

void apollo::perception::camera::apply_nms	(	const bool *	overlapped,
		const int	num,
		std::vector< int > *	indices
	)

Get all boxes with score larger than threshold

参数

overlapped	overlap result
num	number of boxes with score larger than threshold
indices	indices of boxes with score larger than threshold

apply_nms_fast()

void apollo::perception::camera::apply_nms_fast	(	const std::vector< NormalizedBBox > &	bboxes,
		const std::vector< float > &	scores,
		const float	score_threshold,
		const float	nms_threshold,
		const float	eta,
		const int	top_k,
		std::vector< int > *	indices
	)

nms for objects

参数

bboxes	input bounding boxes
scores	input scores, size sames to boxes
score_threshold	score threshold
nms_threshold	NMS threshold
eta	eta parameter
top_k	top_k parameter for nms
indices	indices of objects to keep

在文件 postprocess.cc 第 207 行定义.

                                             {
  // Sanity check.
  CHECK_EQ(bboxes.size(), scores.size())
      << "bboxes and scores have different size.";
 
  // Get top_k scores (with corresponding indices).
  std::vector<std::pair<float, int>> score_index_vec;
  get_max_score_index(scores, score_threshold, top_k, &score_index_vec);
 
  // Do nms.
  float adaptive_threshold = nms_threshold;
  indices->clear();
  while (!score_index_vec.empty()) {
    const int idx = score_index_vec.front().second;
    bool keep = true;
    for (int k = 0; k < static_cast<int>(indices->size()); ++k) {
      if (keep) {
        const int kept_idx = (*indices)[k];
        float overlap = get_jaccard_overlap(bboxes[idx], bboxes[kept_idx]);
        keep = overlap <= adaptive_threshold;
      } else {
        break;
      }
    }
    if (keep) {
      indices->push_back(idx);
    }
    score_index_vec.erase(score_index_vec.begin());
    if (keep && eta < 1 && adaptive_threshold > 0.5) {
      adaptive_threshold *= eta;
    }
  }
}

apply_nms_gpu()

void apollo::perception::camera::apply_nms_gpu	(	const float *	bbox_data,
		const float *	conf_data,
		const std::vector< int > &	origin_indices,
		const int	bbox_step,
		const float	confidence_threshold,
		const int	top_k,
		const float	nms_threshold,
		std::vector< int > *	indices,
		base::Blob< bool > *	overlapped,
		base::Blob< int > *	idx_sm,
		const cudaStream_t &	_stream
	)

Get all boxes with score larger than threshold

参数

bbox_data	bbox data
conf_data	conf data
origin_indices	origin indices
bbox_step	bbox step
confidence_threshold	onfidence threshold
top_k	top k
nms_threshold	nms threshold
indices	indices of boxes with score larger than threshold
overlapped	overlap result
idx_sm	indices of boxes with score larger than threshold
_stream	stream

apply_softnms_fast()

void apollo::perception::camera::apply_softnms_fast	(	const std::vector< NormalizedBBox > &	bboxes,
		std::vector< float > *	scores,
		const float	score_threshold,
		const float	nms_threshold,
		const int	top_k,
		std::vector< int > *	indices,
		bool	is_linear,
		const float	sigma
	)

softnms for objects

参数

bboxes	vector of bboxes
scores	vector of scores
score_threshold	threshold for scores
nms_threshold	threshold for nms
top_k	top k scores
indices	indices of object
is_linear	true if is linear
sigma	sigma for gaussian kernel

在文件 postprocess.cc 第 97 行定义.

                                           {
  // Sanity check.
  CHECK_EQ(bboxes.size(), scores->size())
      << "bboxes and scores have different size.";
 
  // Get top_k scores (with corresponding indices).
  std::vector<std::pair<float, int>> score_index_vec;
  get_max_score_index(*scores, score_threshold, top_k, &score_index_vec);
 
  // Do nms.
  indices->clear();
  while (!score_index_vec.empty()) {
    auto best_it =
        max_element(std::begin(score_index_vec), std::end(score_index_vec));
    const int best_idx = (*best_it).second;
    score_index_vec.erase(best_it);
    const NormalizedBBox &best_bbox = bboxes[best_idx];
    indices->push_back(best_idx);
    for (std::vector<std::pair<float, int>>::iterator it =
             score_index_vec.begin();
         it != score_index_vec.end();) {
      int cur_idx = it->second;
      const NormalizedBBox &cur_bbox = bboxes[cur_idx];
 
      float cur_overlap = 0.;
      cur_overlap = get_jaccard_overlap(best_bbox, cur_bbox);
      if (is_linear) {
        (*scores)[cur_idx] *= static_cast<float>((1.0 - cur_overlap));
      } else {
        (*scores)[cur_idx] *=
            static_cast<float>(exp(-1.0 * pow(cur_overlap, 2) / sigma));
      }
      ++it;
    }
  }
}

Bbox3dLidar2Camera()

void apollo::perception::camera::Bbox3dLidar2Camera	(	const Eigen::Matrix< float, 3, 4 > &	V2C,
		const Eigen::Matrix< float, 3, 3 > &	R,
		const float *	bbox_lidar,
		std::vector< float > *	bbox_camera
	)

Get the Caddn Objects objects from Blob

参数

V2C	the object container
R	the rotation matrix
bbox_lidar	lidar boxes
bbox_camera	camera boxes

在文件 postprocess.cc 第 77 行定义.

                                                       {
  float x = *(bbox_lidar + 0);
  float y = *(bbox_lidar + 1);
  float z = *(bbox_lidar + 2);
  float l = *(bbox_lidar + 3);
  float w = *(bbox_lidar + 4);
  float h = *(bbox_lidar + 5);
  float r = *(bbox_lidar + 6);
  r = -r - M_PI / 2.0;
  // 4*1
  Eigen::Vector4f xyz_lidar;
  xyz_lidar << x, y, z - h / 2.0, 1.0;
  Eigen::Matrix<float, 1, 3> pts_rect =
      xyz_lidar.transpose() * (V2C.transpose() * R.transpose());
  std::vector<float> final_result{
      pts_rect(0), pts_rect(1), pts_rect(2), l, h, w, r};
  bbox_camera->assign(final_result.data(),
                      final_result.data() + final_result.size());
}

bbox_size_gpu()

__host__ __device__ float apollo::perception::camera::bbox_size_gpu	(	const float *	bbox,
		const bool	normalized
	)

BevFormerCrop()

void apollo::perception::camera::BevFormerCrop	(	cv::Mat *	img,
		cv::Mat *	img_n,
		int	x,
		int	y,
		int	width,
		int	height
	)

Image crop function

参数

img	The image to be cropped.
x	The x coordinate of the left side of the crop.
y	The y coordinate of the top side of the crop.
width	The width of the crop image.
height	The height of the crop image.

在文件 preprocess.cc 第 28 行定义.

                               {
  cv::Rect roi(x, y, width, height);
  *img_n = (*img)(roi);
}

BevFormerNormalize()

void apollo::perception::camera::BevFormerNormalize	(	const std::vector< float > &	mean,
		const std::vector< float > &	std,
		float	scale,
		cv::Mat *	img
	)

Image normalize function

参数

mean	The mean value of the image.
std	The standard deviation of the image.
scale	The scale value of the image.
im	The image to be normalized.

在文件 preprocess.cc 第 34 行定义.

                                    {
  ACHECK(std.size() == 3);
  for (const auto std_value : std) {
    ACHECK(std_value != 0.0);
  }
  if (scale) {
    (*img).convertTo(*img, CV_32FC3, scale);
  }
  for (int h = 0; h < img->rows; ++h) {
    for (int w = 0; w < img->cols; ++w) {
      img->at<cv::Vec3f>(h, w)[0] =
          (img->at<cv::Vec3f>(h, w)[0] - mean[0]) / std[0];
      img->at<cv::Vec3f>(h, w)[1] =
          (img->at<cv::Vec3f>(h, w)[1] - mean[1]) / std[1];
      img->at<cv::Vec3f>(h, w)[2] =
          (img->at<cv::Vec3f>(h, w)[2] - mean[2]) / std[2];
    }
  }
}

BevFormerResize()

void apollo::perception::camera::BevFormerResize	(	cv::Mat *	img,
		cv::Mat *	img_n,
		int	width,
		int	height
	)

Image resize function

参数

img	The image to be resized.
width	The width of the image.
height	The height of the image.

在文件 preprocess.cc 第 24 行定义.

                                                                      {
  cv::resize(*img, *img_n, cv::Size(width, height));
}

CalAngleDiff()

template<typename T >

T apollo::perception::camera::CalAngleDiff	(	const T	a1,
		const T	a2
	)

在文件 twod_threed_util.h 第 61 行定义.

                                       {
  T diff1 = a1 - a2;
  diff1 = diff1 < 0 ? -diff1 : diff1;
  T diff2 = a1 - a2 + algorithm::Constant<T>::PI() * 2;
  diff2 = diff2 < 0 ? -diff2 : diff2;
  T diff3 = a1 - a2 - algorithm::Constant<T>::PI() * 2;
  diff3 = diff3 < 0 ? -diff3 : diff3;
  return std::min<T>(std::min<T>(diff1, diff2), diff3);
}

CalculateMeanAndVariance()

template<typename T >

void apollo::perception::camera::CalculateMeanAndVariance	(	const std::vector< T > &	data,
		T *	mean,
		T *	variance
	)

在文件 util.h 第 150 行定义.

                                           {
  if (!mean || !variance) {
    return;
  }
  if (data.empty()) {
    *mean = 0;
    *variance = 0;
    return;
  }
  T sum = std::accumulate(data.begin(), data.end(), static_cast<T>(0));
  *mean = sum / data.size();
 
  std::vector<T> diff(data.size());
  std::transform(data.begin(), data.end(), diff.begin(),
                 [mean](T x) { return x - *mean; });
  T sum_of_diff_sqrs = std::inner_product(diff.begin(), diff.end(),
                                          diff.begin(), static_cast<T>(0));
  *variance = sum_of_diff_sqrs / data.size();
}

Camera2CarHomograph()

Eigen::Matrix3d apollo::perception::camera::Camera2CarHomograph	(	const Eigen::Matrix3d &	intrinsic,
		const Eigen::Matrix4d &	extrinsic_camera2lidar,
		const Eigen::Matrix4d &	extrinsic_lidar2imu,
		double	pitch_adj
	)

在文件 visualizer.cc 第 60 行定义.

                      {
  AINFO << "intrinsic parameter of camera: " << intrinsic;
  AINFO << "extrinsic parameter of camera to lidar: " << extrinsic_camera2lidar;
  AINFO << "extrinsic parameter of lidar to imu: " << extrinsic_lidar2imu;
  // rotate 90 degree around z axis to make x point forward
  Eigen::Matrix4d Rz;
  Rz << 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1;
  Eigen::Matrix4d extrinsic_camera2car;
  extrinsic_camera2car = extrinsic_camera2lidar * extrinsic_lidar2imu * Rz;
  // adjust pitch in camera coords
  Eigen::Matrix4d Rx;
  Rx << 1, 0, 0, 0, 0, cos(pitch_adj), -sin(pitch_adj), 0, 0, sin(pitch_adj),
      cos(pitch_adj), 0, 0, 0, 0, 1;
  extrinsic_camera2car = extrinsic_camera2car * Rx;
  AINFO << "extrinsic parameter from camera to car: " << extrinsic_camera2car;
 
  // compute the homography matrix, such that H [u, v, 1]' ~ [X_l, Y_l, 1]
  Eigen::Matrix3d K = intrinsic;
  Eigen::Matrix3d R = extrinsic_camera2car.block(0, 0, 3, 3);
  Eigen::Vector3d T = extrinsic_camera2car.block(0, 3, 3, 1);
  Eigen::Matrix3d H;
 
  H.block(0, 0, 3, 2) = (K * R.transpose()).block(0, 0, 3, 2);
  H.block(0, 2, 3, 1) = -K * R.transpose() * T;
  return H.inverse();
}

CameraPoint2Image()

bool apollo::perception::camera::CameraPoint2Image	(	const Eigen::Vector3d &	camera_point,
		const Eigen::Matrix3f &	intrinsic_params,
		base::Point2DF *	img_point
	)

在文件 common_functions.cc 第 226 行定义.

                                                {
  Eigen::Vector3f camera_point3f;
  camera_point3f(0, 0) = static_cast<float>(camera_point(0, 0));
  camera_point3f(1, 0) = static_cast<float>(camera_point(1, 0));
  camera_point3f(2, 0) = static_cast<float>(camera_point(2, 0));
  Eigen::MatrixXf img_point3f = intrinsic_params * camera_point3f;
  if (fabs(img_point3f(2, 0)) < lane_eps_value) {
    return false;
  }
  img_point->x = img_point3f(0, 0) / img_point3f(2, 0);
  img_point->y = img_point3f(1, 0) / img_point3f(2, 0);
  return true;
}

CameraVisualization()

bool apollo::perception::camera::CameraVisualization	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

Save visualization results to file_name(.jpg)

参数

frame	CameraFrame
file_name	Image contains visualization results

返回

true

false

在文件 visualizer.cc 第 40 行定义.

                                                     {
  cv::Mat cv_img(frame->data_provider->src_height(),
                 frame->data_provider->src_width(), CV_8UC3,
                 cv::Scalar(0, 0, 0));
 
  RecoveryImage(frame, &cv_img);
 
  int obj_id = 0;
  for (auto obj : frame->detected_objects) {
    auto& supp = obj->camera_supplement;
    auto& box = supp.box;
    auto area_id = supp.area_id;
 
    cv::rectangle(
        cv_img,
        cv::Point(static_cast<int>(box.xmin), static_cast<int>(box.ymin)),
        cv::Point(static_cast<int>(box.xmax), static_cast<int>(box.ymax)),
        cv::Scalar(0, 0, 0), 8);
    float xmid = (box.xmin + box.xmax) / 2;
    ACHECK(area_id > 0 && area_id < 9);
    if (area_id & 1) {
      cv::rectangle(
          cv_img,
          cv::Point(static_cast<int>(box.xmin), static_cast<int>(box.ymin)),
          cv::Point(static_cast<int>(box.xmax), static_cast<int>(box.ymax)),
          kFaceColors[area_id / 2], 2);
    } else {
      auto& tl = supp.cut_off_ratios[2];
      auto& tr = supp.cut_off_ratios[3];
      auto&& left_ratio = supp.visible_ratios[(area_id / 2) % 4];
      auto w = box.xmax - box.xmin;
      auto x = box.xmin;
      auto tm = std::max(tl, tr);
      if (tm > 1e-2) {
        if (tl > tr) {
          xmid = (x - w * tl) + (w + w * tl) * left_ratio;
        } else if (tl < tr) {
          xmid = x + (w + w * tr) * left_ratio;
        }
      } else {
        xmid = x + w * left_ratio;
      }
      cv::rectangle(
          cv_img,
          cv::Point(static_cast<int>(box.xmin), static_cast<int>(box.ymin)),
          cv::Point(static_cast<int>(xmid), static_cast<int>(box.ymax)),
          kFaceColors[(area_id / 2) % 4], 3);
      cv::rectangle(
          cv_img, cv::Point(static_cast<int>(xmid), static_cast<int>(box.ymin)),
          cv::Point(static_cast<int>(box.xmax), static_cast<int>(box.ymax)),
          kFaceColors[area_id / 2 - 1], 2);
    }
    fprintf(stderr,
            "obj-%02d: %.3f %.3f %.3f %.3f -- %.3f %.3f %.3f %.3f "
            "-- %.0f %.0f %.0f %d\n",
            obj_id, supp.visible_ratios[0], supp.visible_ratios[1],
            supp.visible_ratios[2], supp.visible_ratios[3],
            supp.cut_off_ratios[0], supp.cut_off_ratios[1],
            supp.cut_off_ratios[2], supp.cut_off_ratios[3], box.xmin, xmid,
            box.xmax, area_id);
    std::stringstream text;
    auto& name = base::kSubType2NameMap.at(obj->sub_type);
    text << name[0] << name[1] << name[2] << " - " << obj_id++;
    cv::putText(
        cv_img, text.str(),
        cv::Point(static_cast<int>(box.xmin), static_cast<int>(box.ymin)),
        cv::FONT_HERSHEY_PLAIN, 2, cv::Scalar(255, 0, 0), 2);
  }
 
  cv::imwrite(file_name.c_str(), cv_img);
  return true;
}

CheckXY()

template<typename T >

bool apollo::perception::camera::CheckXY	(	const T &	x,
		const T &	y,
		int	width,
		int	height
	)

在文件 twod_threed_util.h 第 245 行定义.

                                                            {
  T max_x = static_cast<T>(width - 1);
  T max_y = static_cast<T>(height - 1);
  return x <= max_x && x >= (T)0 && y <= max_y && y >= (T)0;
}

ComparePoint2DY()

bool apollo::perception::camera::ComparePoint2DY	(	const base::Point2DF &	point1,
		const base::Point2DF &	point2
	)

在文件 common_functions.cc 第 241 行定义.

                                                 {
  return point1.y < point2.y;
}

compute_overlapped_by_idx_gpu()

void apollo::perception::camera::compute_overlapped_by_idx_gpu	(	const int	nthreads,
		const float *	bbox_data,
		const float	overlap_threshold,
		const int *	idx,
		const int	num_idx,
		bool *	overlapped_data,
		const cudaStream_t &	_stream
	)

Get all boxes with score larger than threshold

参数

nthreads	number of threads
bbox_data	bbox data
overlap_threshold	overlap threshold
idx	bbox index
num_idx	number of bbox index
overlapped_data	overlap result
_stream	stream

ComputeYoloxOverlap()

float apollo::perception::camera::ComputeYoloxOverlap	(	const base::Rect< float > &	a,
		const base::Rect< float > &	b
	)

在文件 postprocess.cc 第 295 行定义.

                                                    {
  base::Rect<float> intersection = a & b;
  base::Rect<float> unionsection = a | b;
  if (unionsection.Area() == 0) return 0.0f;
  return intersection.Area() / unionsection.Area();
}

Contain()

template<typename T >

bool apollo::perception::camera::Contain	(	const std::vector< T > &	array,
		const T &	element
	)

在文件 util.h 第 64 行定义.

                                                          {
  for (const auto &item : array) {
    if (item == element) {
      return true;
    }
  }
  return false;
}

ConvertGround3ToGround4()

void apollo::perception::camera::ConvertGround3ToGround4	(	const float &	baseline,
		const std::vector< float > &	k_mat,
		const std::vector< float > &	ground3,
		std::vector< float > *	ground4
	)

在文件 camera_ground_plane.cc 第 27 行定义.

                                                        {
  CHECK_GT(baseline, 0.0f);
  CHECK_EQ(k_mat.size(), 9U);
  CHECK_EQ(ground3.size(), 3U);
  CHECK_NOTNULL(ground4);
  CHECK_EQ(ground4->size(), 4U);
  const float &b = baseline;
  const float &fx = k_mat[0];
  const float &fy = k_mat[4];
  const float &cy = k_mat[5];
  ground4->data()[0] = 0.0f;
  ground4->data()[1] = ground3[0] * fy;
  ground4->data()[2] = ground3[0] * cy + ground3[2];
  ground4->data()[3] = ground3[1] * b * fx;
  float norm = algorithm::ISqrt(algorithm::ISquaresum3(ground4->data()));
  algorithm::IScale4(ground4->data(), algorithm::IRec(norm));
}

ConvertGround4ToGround3()

bool apollo::perception::camera::ConvertGround4ToGround3	(	const float &	baseline,
		const std::vector< float > &	k_mat,
		const std::vector< float > &	ground4,
		std::vector< float > *	ground3
	)

在文件 camera_ground_plane.cc 第 48 行定义.

                                                        {
  CHECK_GT(baseline, 0.0f);
  CHECK_EQ(k_mat.size(), 9U);
  CHECK_EQ(ground4.size(), 4U);
  CHECK_NOTNULL(ground3);
  CHECK_EQ(ground3->size(), 3U);
  // normalization
  float p[4] = {ground4[0], ground4[1], ground4[2], ground4[3]};
  float norm = algorithm::ISqrt(algorithm::ISquaresum3(p));
  algorithm::IScale4(p, algorithm::IRec(norm));
  if (p[0] > 1e-3) {
    AERROR << "Have roll in the ground plane: " << p[0];
    ground3->assign(3, 0.f);
    return false;
  }
  // no roll
  const float &b = baseline;
  const float &fx = k_mat[0];
  const float &fy = k_mat[4];
  const float &cy = k_mat[5];
  ground3->data()[0] = p[1] * algorithm::IRec(fy);
  ground3->data()[1] = p[3] * algorithm::IRec(b * fx);
  ground3->data()[2] = p[2] - ground3->data()[0] * cy;
  return true;
}

Crop()

void apollo::perception::camera::Crop	(	cv::Mat *	img,
		cv::Mat *	img_n,
		int	x,
		int	y,
		int	width,
		int	height
	)

Image crop function

参数

img	The image to be cropped.
x	The x coordinate of the left side of the crop.
y	The y coordinate of the top side of the crop.
width	The width of the crop image.
height	The height of the crop image.

在文件 preprocess.cc 第 28 行定义.

                                                                         {
  cv::Rect roi(x, y, width, height);
  *img_n = (*img)(roi);
}

CYBER_REGISTER_COMPONENT() [1/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraDetectionBevComponent

)

CYBER_REGISTER_COMPONENT() [2/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraDetectionMultiStageComponent

)

CYBER_REGISTER_COMPONENT() [3/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraDetectionOccComponent

)

CYBER_REGISTER_COMPONENT() [4/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraDetectionSingleStageComponent

)

CYBER_REGISTER_COMPONENT() [5/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraLocationEstimationComponent

)

CYBER_REGISTER_COMPONENT() [6/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraLocationRefinementComponent

)

CYBER_REGISTER_COMPONENT() [7/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

CameraTrackingComponent

)

CYBER_REGISTER_COMPONENT() [8/8]

apollo::perception::camera::CYBER_REGISTER_COMPONENT

(

MotionServiceComponent

)

dupImageChannels()

bool apollo::perception::camera::dupImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height
	)

在文件 image_data_operations.cc 第 55 行定义.

                                                                 {
  return nppDupImageChannels(src, dst, src_width, src_height);
}

duplicate_kernel()

__global__ void apollo::perception::camera::duplicate_kernel	(	const unsigned char *	src,
		size_t	src_width_step,
		uchar3 *	dst,
		size_t	dst_width_step,
		int	width,
		int	height
	)

在文件 image_data_operations_rpp.h 第 160 行定义.

                                                                               {
  const size_t i = hipBlockDim_x * hipBlockIdx_x + hipThreadIdx_x;
  const size_t j = hipBlockDim_y * hipBlockIdx_y + hipThreadIdx_y;
  image2D<unsigned char> src_img{src, src_width_step};
  image2D<uchar3> dst_img{dst, dst_width_step};
 
  if (i < width && j < height) {
    unsigned char value = src_img(i, j);
    dst_img(i, j).x = value;
    dst_img(i, j).y = value;
    dst_img(i, j).z = value;
  }
}

Equal() [1/2]

bool apollo::perception::camera::Equal	(	double	x,
		double	target,
		double	eps
	)

在文件 util.cc 第 24 行定义.

                                                {
  return std::abs(x - target) < eps;
}

Equal() [2/2]

bool apollo::perception::camera::Equal	(	float	x,
		float	target,
		float	eps
	)

在文件 util.cc 第 27 行定义.

                                             {
  return std::abs(x - target) < eps;
}

fill_area_id()

void apollo::perception::camera::fill_area_id	(	bool	with_flag,
		base::ObjectPtr	obj,
		const float *	data
	)

add area id value to object

参数

with_flag	true: area id is exist
obj	object result
data	area id

在文件 postprocess.cc 第 374 行定义.

                                                                        {
  if (with_flag) {
    obj->camera_supplement.area_id = static_cast<int>(data[0]);
  }
}

fill_base()

void apollo::perception::camera::fill_base	(	base::ObjectPtr	obj,
		const float *	bbox
	)

add bbox value to object

参数

obj	object result
bbox	[N, 4]

在文件 postprocess.cc 第 316 行定义.

                                                     {
  obj->camera_supplement.box.xmin = bbox[0];
  obj->camera_supplement.box.ymin = bbox[1];
  obj->camera_supplement.box.xmax = bbox[2];
  obj->camera_supplement.box.ymax = bbox[3];
}

fill_bbox3d()

void apollo::perception::camera::fill_bbox3d	(	bool	with_bbox3d,
		base::ObjectPtr	obj,
		const float *	bbox
	)

add alpha h w l to object

参数

with_bbox3d	whether to add alpha h w l to object
obj	object
bbox	the bbox of object

在文件 postprocess.cc 第 323 行定义.

                                                                        {
  if (with_box3d) {
    obj->camera_supplement.alpha = bbox[0];
    obj->size[2] = bbox[1];
    obj->size[1] = bbox[2];
    obj->size[0] = bbox[3];
  }
}

fill_frbox()

void apollo::perception::camera::fill_frbox	(	bool	with_frbox,
		base::ObjectPtr	obj,
		const float *	bbox
	)

add car front and backward bbox value to object

参数

with_frbox	whether to add car front and backward bbox value to object
obj	object
bbox	the bbox of object

在文件 postprocess.cc 第 332 行定义.

                                                                       {
  if (with_frbox) {
    obj->camera_supplement.front_box.xmin = bbox[0];
    obj->camera_supplement.front_box.ymin = bbox[1];
    obj->camera_supplement.front_box.xmax = bbox[2];
    obj->camera_supplement.front_box.ymax = bbox[3];
 
    obj->camera_supplement.back_box.xmin = bbox[4];
    obj->camera_supplement.back_box.ymin = bbox[5];
    obj->camera_supplement.back_box.xmax = bbox[6];
    obj->camera_supplement.back_box.ymax = bbox[7];
  }
}

fill_lights()

void apollo::perception::camera::fill_lights	(	bool	with_lights,
		base::ObjectPtr	obj,
		const float *	bbox
	)

add car lights value to object

参数

with_lights	lights info
obj	object to be filled
bbox	the bbox of object

在文件 postprocess.cc 第 346 行定义.

                                                                         {
  if (with_lights) {
    obj->car_light.brake_visible = bbox[0];
    obj->car_light.brake_switch_on = bbox[1];
    obj->car_light.left_turn_visible = bbox[2];
    obj->car_light.left_turn_switch_on = bbox[3];
    obj->car_light.right_turn_visible = bbox[4];
    obj->car_light.right_turn_switch_on = bbox[5];
  }
}

fill_ratios()

void apollo::perception::camera::fill_ratios	(	bool	with_ratios,
		base::ObjectPtr	obj,
		const float *	bbox
	)

add ratio value to object

参数

with_ratios	ratio value will be added to object
obj	object to be filled
bbox	the bbox of object

在文件 postprocess.cc 第 357 行定义.

                                                                         {
  if (with_ratios) {
    // visible ratios of face a/b/c/d
    obj->camera_supplement.visible_ratios[0] = bbox[0];
    obj->camera_supplement.visible_ratios[1] = bbox[1];
    obj->camera_supplement.visible_ratios[2] = bbox[2];
    obj->camera_supplement.visible_ratios[3] = bbox[3];
 
    // cut off on width and length (3D)
    obj->camera_supplement.cut_off_ratios[0] = bbox[4];
    obj->camera_supplement.cut_off_ratios[1] = bbox[5];
    // cut off on left and right side (2D)
    obj->camera_supplement.cut_off_ratios[2] = bbox[6];
    obj->camera_supplement.cut_off_ratios[3] = bbox[7];
  }
}

FillBBox()

void apollo::perception::camera::FillBBox	(	base::ObjectPtr	obj,
		const float *	bbox,
		int	width,
		int	height
	)

在文件 postprocess.cc 第 80 行定义.

                                                                           {
  obj->camera_supplement.box.xmin = bbox[2] / width;
  obj->camera_supplement.box.ymin = bbox[3] / height;
  obj->camera_supplement.box.xmax = bbox[4] / width;
  obj->camera_supplement.box.ymax = bbox[5] / height;
}

FillBBox3d() [1/2]

void apollo::perception::camera::FillBBox3d	(	base::ObjectPtr	obj,
		const float *	bbox
	)

在文件 postprocess.cc 第 87 行定义.

                                                      {
  obj->camera_supplement.alpha = bbox[1];
  // todo: why obj size not put in camera_supplement
  obj->size[2] = bbox[6];
  obj->size[1] = bbox[7];
  obj->size[0] = bbox[8];
 
  obj->camera_supplement.local_center[0] = bbox[9];
  obj->camera_supplement.local_center[1] = bbox[10];
  obj->camera_supplement.local_center[2] = bbox[11];
}

FillBBox3d() [2/2]

void apollo::perception::camera::FillBBox3d	(	const float *	bbox,
		base::ObjectPtr	obj
	)

Fill the 3d bbox to object

参数

bbox
obj

在文件 postprocess.cc 第 71 行定义.

                                                      {
  obj->camera_supplement.local_center[0] = bbox[0];
  obj->camera_supplement.local_center[1] = bbox[1];
  obj->camera_supplement.local_center[2] = bbox[2];
  // size: length, width, height of bbox
  obj->size[0] = bbox[4];
  obj->size[1] = bbox[3];
  obj->size[2] = bbox[5];
 
  // yaw
  obj->theta = bbox[6];
 
  obj->center(0) = static_cast<double>(obj->camera_supplement.local_center[0]);
  obj->center(1) = static_cast<double>(obj->camera_supplement.local_center[1]);
  obj->center(2) = static_cast<double>(obj->camera_supplement.local_center[2]);
}

FillCaddnBbox3d()

void apollo::perception::camera::FillCaddnBbox3d	(	base::ObjectPtr	obj,
		const float *	bbox
	)

Add objects values to object

参数

obj	object
bbox	bbox result

在文件 postprocess.cc 第 109 行定义.

                                                           {
  obj->camera_supplement.alpha = bbox[6];
  obj->size[2] = bbox[3];
  obj->size[1] = bbox[4];
  obj->size[0] = bbox[5];
 
  obj->camera_supplement.local_center[0] = bbox[0];
  obj->camera_supplement.local_center[1] = bbox[1];
  obj->camera_supplement.local_center[2] = bbox[2];
}

FillImage()

bool apollo::perception::camera::FillImage	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

Read image from file_name and fill in frame->data_provider

参数

frame	onboard::CameraFrame
file_name	image file

返回

true

false

在文件 util.cc 第 28 行定义.

                                                                      {
  // Read image from file_name
  cv::Mat image = cv::imread(file_name);
  if (image.empty()) {
    AERROR << "Read image failed! " << file_name;
    return false;
  }
 
  // Fill image to frame->data_provider
  bool res = frame->data_provider->FillImageData(image.rows, image.cols,
                                                 image.data, "bgr8");
  if (!res) {
    AERROR << "Fill image failed! " << file_name;
    return false;
  }
  return true;
}

FillObjectPolygonFromBBox3D()

void apollo::perception::camera::FillObjectPolygonFromBBox3D

(

base::Object *

object_ptr

)

在文件 util.cc 第 157 行定义.

                                                         {
  if (!object_ptr) {
    return;
  }
  const double length = object_ptr->size(0);
  const double width = object_ptr->size(1);
  //  const double height = object_ptr->size(2);
  double x1 = length / 2;
  double x2 = -x1;
  double y1 = width / 2;
  double y2 = -y1;
  double len = sqrt(object_ptr->direction[0] * object_ptr->direction[0] +
                    object_ptr->direction[1] * object_ptr->direction[1]);
  double cos_theta = object_ptr->direction[0] / len;
  double sin_theta = -object_ptr->direction[1] / len;
 
  object_ptr->polygon.resize(4);
  object_ptr->polygon[0].x =
      x1 * cos_theta + y1 * sin_theta + object_ptr->center[0];
  object_ptr->polygon[0].y =
      y1 * cos_theta - x1 * sin_theta + object_ptr->center[1];
  object_ptr->polygon[0].z = 0.0;
 
  object_ptr->polygon[1].x =
      x1 * cos_theta + y2 * sin_theta + object_ptr->center[0];
  object_ptr->polygon[1].y =
      y2 * cos_theta - x1 * sin_theta + object_ptr->center[1];
  object_ptr->polygon[1].z = 0.0;
 
  object_ptr->polygon[2].x =
      x2 * cos_theta + y2 * sin_theta + object_ptr->center[0];
  object_ptr->polygon[2].y =
      y2 * cos_theta - x2 * sin_theta + object_ptr->center[1];
  object_ptr->polygon[2].z = 0.0;
 
  object_ptr->polygon[3].x =
      x2 * cos_theta + y1 * sin_theta + object_ptr->center[0];
  object_ptr->polygon[3].y =
      y1 * cos_theta - x2 * sin_theta + object_ptr->center[1];
  object_ptr->polygon[3].z = 0.0;
}

filter_bbox()

void apollo::perception::camera::filter_bbox	(	const MinDims &	min_dims,
		std::vector< base::ObjectPtr > *	objects
	)

filter out the objects in the object array based on the given minimum dimension conditions and retain the objects that meet the conditions

参数

min_dims	minimum dimensions of the bounding box
objects	list of objects

在文件 postprocess.cc 第 245 行定义.

                                                    {
  int valid_obj_idx = 0;
  int total_obj_idx = 0;
  while (total_obj_idx < static_cast<int>(objects->size())) {
    const auto &obj = (*objects)[total_obj_idx];
    if ((obj->camera_supplement.box.ymax - obj->camera_supplement.box.ymin) >=
            min_dims.min_2d_height &&
        (min_dims.min_3d_height <= 0 ||
         obj->size[2] >= min_dims.min_3d_height) &&
        (min_dims.min_3d_width <= 0 || obj->size[1] >= min_dims.min_3d_width) &&
        (min_dims.min_3d_length <= 0 ||
         obj->size[0] >= min_dims.min_3d_length)) {
      (*objects)[valid_obj_idx] = (*objects)[total_obj_idx];
      ++valid_obj_idx;
    }
    ++total_obj_idx;
  }
  AINFO << valid_obj_idx << " of " << total_obj_idx << " obstacles kept";
  objects->resize(valid_obj_idx);
  AINFO << "Number of detected obstacles: " << objects->size();
}

FilterByMinDims()

void apollo::perception::camera::FilterByMinDims	(	const smoke::MinDims &	min_dims,
		std::vector< base::ObjectPtr > *	objects
	)

在文件 postprocess.cc 第 26 行定义.

                                                        {
  std::size_t valid_index = 0, cur_index = 0;
  while (cur_index < objects->size()) {
    const auto& obj = objects->at(cur_index);
    float height =
        obj->camera_supplement.box.ymax - obj->camera_supplement.box.ymin;
    if (height >= min_dims.min_2d_height() &&
        obj->size[2] >= min_dims.min_3d_height() &&
        obj->size[1] >= min_dims.min_3d_width() &&
        obj->size[0] >= min_dims.min_3d_length()) {
      if (valid_index != cur_index)
        objects->at(valid_index) = objects->at(cur_index);
      ++valid_index;
    }
    ++cur_index;
  }
 
  objects->resize(valid_index);
  AINFO << valid_index << " of " << cur_index << " obstacles kept";
}

FindCC()

bool apollo::perception::camera::FindCC	(	const std::vector< unsigned char > &	src,
		int	width,
		int	height,
		const base::RectI &	roi,
		std::vector< ConnectedComponent > *	cc
	)

在文件 common_functions.cc 第 83 行定义.

                                                                     {
  if (src.empty()) {
    AERROR << "input image is empty";
    return false;
  }
 
  cc->clear();
  int x_min = roi.x;
  int y_min = roi.y;
  int x_max = x_min + roi.width - 1;
  int y_max = y_min + roi.height - 1;
  if (x_min < 0) {
    AERROR << "x_min is less than zero: " << x_min;
    return false;
  }
  if (y_min < 0) {
    AERROR << "y_min is less than zero: " << y_min;
    return false;
  }
  if (x_max >= width) {
    AERROR << "x_max is larger than image width: " << x_max << "|" << width;
    return false;
  }
  if (y_max >= height) {
    AERROR << "y_max is larger than image height: " << y_max << "|" << height;
    return false;
  }
  if (roi.width <= 1 && roi.height <= 1) {
    AERROR << "too small roi range";
    return false;
  }
 
  size_t total_pix = static_cast<size_t>(roi.width * roi.height);
  std::vector<int> frame_label(total_pix);
  DisjointSet labels(total_pix);
  std::vector<int> root_map;
  root_map.reserve(total_pix);
 
  int x = 0;
  int y = 0;
  int left_val = 0;
  int up_val = 0;
  int cur_idx = 0;
  int left_idx = 0;
  int up_idx = 0;
 
  // first loop logic
  for (y = y_min; y <= y_max; y++) {
    int row_start = y * width;
    for (x = x_min; x <= x_max; x++, cur_idx++) {
      left_idx = cur_idx - 1;
      up_idx = cur_idx - width;
 
      if (x == x_min) {
        left_val = 0;
      } else {
        left_val = src[row_start + x - 1];
      }
 
      if (y == y_min) {
        up_val = 0;
      } else {
        up_val = src[row_start - width + x];
      }
 
      if (src[row_start + x] > 0) {
        if (left_val == 0 && up_val == 0) {
          // current pixel is foreground and has no connected neighbors
          frame_label[cur_idx] = labels.Add();
          root_map.push_back(-1);
        } else if (left_val != 0 && up_val == 0) {
          // current pixel is foreground and has left neighbor connected
          frame_label[cur_idx] = frame_label[left_idx];
        } else if (left_val == 0 && up_val != 0) {
          // current pixel is foreground and has up neighbor connect
          frame_label[cur_idx] = frame_label[up_idx];
        } else {
          // current pixel is foreground
          // and is connected to left and up neighbors
          frame_label[cur_idx] = (frame_label[left_idx] > frame_label[up_idx])
                                     ? frame_label[up_idx]
                                     : frame_label[left_idx];
          labels.Unite(frame_label[left_idx], frame_label[up_idx]);
        }
      } else {
        frame_label[cur_idx] = -1;
      }
    }  //  end for x
  }    //  end for y
  AINFO << "subset number = " << labels.Size();
 
  // second loop logic
  cur_idx = 0;
  int curt_label = 0;
  int cc_count = 0;
  for (y = y_min; y <= y_max; y++) {
    for (x = x_min; x <= x_max; x++, cur_idx++) {
      curt_label = frame_label[cur_idx];
      if (curt_label >= 0 && curt_label < static_cast<int>(labels.Num())) {
        curt_label = labels.Find(curt_label);
        if (curt_label >= static_cast<int>(root_map.size())) {
          AERROR << "curt_label should be smaller than root_map.size() "
                 << curt_label << " vs. " << root_map.size();
          return false;
        }
        if (root_map.at(curt_label) != -1) {
          (*cc)[root_map.at(curt_label)].AddPixel(x, y);
        } else {
          cc->push_back(ConnectedComponent(x, y));
          root_map.at(curt_label) = cc_count++;
        }
      }
    }  // end for x
  }    // end for y
  AINFO << "cc number = " << cc_count;
 
  return true;
}

FindKLargeValue()

bool apollo::perception::camera::FindKLargeValue	(	const float *	distance,
		int	dim,
		int	k,
		int *	index
	)

在文件 common_functions.cc 第 292 行定义.

                                                                        {
  if (dim < k) {
    AWARN << "dim is smaller than k";
    return false;
  }
  if (k <= 0) {
    AWARN << "k is smaller than 0";
    return false;
  }
  std::vector<float> large_value(k);
  std::vector<int> large_index(k);
  //  sort the large value vector
  QuickSort(&(large_index[0]), distance, k);
  for (int i = 0; i < k; i++) {
    index[i] = large_index[k - 1 - i];
    large_value[i] = distance[index[i]];
  }
 
  for (int i = k; i < dim; i++) {
    float min_value = large_value[k - 1];
    if (distance[i] <= min_value) {
      continue;
    }
    int locate_index = -1;
    if (distance[i] > large_value[0]) {
      locate_index = 0;
    } else {
      for (int j = 0; j < k - 1; j++) {
        if (distance[i] <= large_value[j] &&
            distance[i] >= large_value[j + 1]) {
          locate_index = j + 1;
          break;
        }  //  if
      }    //  for
    }      //  else
    if (locate_index == -1) {
      return false;
    }
    for (int j = k - 2; j >= locate_index; j--) {
      large_value[j + 1] = large_value[j];
      index[j + 1] = index[j];
    }
    large_value[locate_index] = distance[i];
    index[locate_index] = i;
  }
  return true;
}

FindKSmallValue()

bool apollo::perception::camera::FindKSmallValue	(	const float *	distance,
		int	dim,
		int	k,
		int *	index
	)

在文件 common_functions.cc 第 246 行定义.

                                                                        {
  if (dim < k) {
    AWARN << "dim is smaller than k";
    return false;
  }
  if (k <= 0) {
    AWARN << "k is smaller than 0";
    return false;
  }
  std::vector<float> small_value(k);
  //  sort the small value vector
  QuickSort(index, distance, k);
  for (int i = 0; i < k; i++) {
    small_value[i] = distance[index[i]];
  }
 
  for (int i = k; i < dim; i++) {
    float max_value = small_value[k - 1];
    if (distance[i] >= max_value) {
      continue;
    }
    int locate_index = -1;
    if (distance[i] < small_value[0]) {
      locate_index = 0;
    } else {
      for (int j = 0; j < k - 1; j++) {
        if (distance[i] >= small_value[j] &&
            distance[i] <= small_value[j + 1]) {
          locate_index = j + 1;
          break;
        }  //  if
      }    //  for
    }      //  else
    if (locate_index == -1) {
      return false;
    }
    for (int j = k - 2; j >= locate_index; j--) {
      small_value[j + 1] = small_value[j];
      index[j + 1] = index[j];
    }
    small_value[locate_index] = distance[i];
    index[locate_index] = i;
  }
  return true;
}

gaussian()

template<typename Dtype >

Dtype apollo::perception::camera::gaussian ( Dtype  x, Dtype  mu, Dtype  sigma  )

inline

在文件 math_functions.h 第 30 行定义.

                                                      {
  return static_cast<Dtype>(
      std::exp(-(x - mu) * (x - mu) / (2 * sigma * sigma)));
}

GenCorners()

template<typename T >

void apollo::perception::camera::GenCorners	(	T	h,
		T	w,
		T	l,
		T *	x_cor,
		T *	y_cor,
		T *	z_cor
	)

在文件 twod_threed_util.h 第 111 行定义.

                                                             {
  T half_w = static_cast<T>(w * 0.5f);
  T half_l = static_cast<T>(l * 0.5f);
  y_cor[0] = y_cor[1] = y_cor[2] = y_cor[3] = (T)0;
  y_cor[4] = y_cor[5] = y_cor[6] = y_cor[7] = -h;
  x_cor[0] = x_cor[4] = half_l;
  z_cor[0] = z_cor[4] = half_w;
  x_cor[1] = x_cor[5] = half_l;
  z_cor[1] = z_cor[5] = -half_w;
  x_cor[2] = x_cor[6] = -half_l;
  z_cor[2] = z_cor[6] = -half_w;
  x_cor[3] = x_cor[7] = -half_l;
  z_cor[3] = z_cor[7] = half_w;
}

GenRotMatrix()

template<typename T >

void apollo::perception::camera::GenRotMatrix	(	const T &	ry,
		T *	rot
	)

在文件 twod_threed_util.h 第 101 行定义.

                                       {
  rot[0] = static_cast<T>(cos(ry));
  rot[2] = static_cast<T>(sin(ry));
  rot[4] = static_cast<T>(1.0f);
  rot[6] = static_cast<T>(-sin(ry));
  rot[8] = static_cast<T>(cos(ry));
  rot[1] = rot[3] = rot[5] = rot[7] = static_cast<T>(0);
}

get_area_id()

int apollo::perception::camera::get_area_id

(

float

visible_ratios[4]

)

calculate the area id based on the visible ratios

参数

visible_ratios

visible ratios

返回

int area_id

在文件 postprocess.cc 第 380 行定义.

                                         {
  int area_id = 0;
  int max_face = 0;
  for (int i = 1; i < 4; i++) {
    if (visible_ratios[i] > visible_ratios[max_face]) {
      max_face = i;
    }
  }
  int left_face = (max_face + 1) % 4;
  int right_face = (max_face + 3) % 4;
  const float eps = 1e-3f;
  float max_ratio = visible_ratios[max_face];
  float left_ratio = visible_ratios[left_face];
  float right_ratio = visible_ratios[right_face];
  memset(visible_ratios, 0, 4 * sizeof(visible_ratios[0]));
  if (left_ratio < eps && right_ratio < eps) {
    area_id = (max_face * 2 + 1);
    visible_ratios[max_face] = 1.f;
  } else if (left_ratio > right_ratio) {
    area_id = (max_face * 2 + 2);
    auto &&sum_ratio = left_ratio + max_ratio;
    visible_ratios[max_face] = max_ratio / sum_ratio;
    visible_ratios[left_face] = left_ratio / sum_ratio;
  } else {
    area_id = (max_face * 2);
    if (area_id == 0) {
      area_id = 8;
    }
    auto &&sum_ratio = right_ratio + max_ratio;
    visible_ratios[max_face] = max_ratio / sum_ratio;
    visible_ratios[right_face] = right_ratio / sum_ratio;
  }
  return area_id;
}

get_bbox_size()

float apollo::perception::camera::get_bbox_size

(

const NormalizedBBox &

bbox

)

在文件 postprocess.cc 第 43 行定义.

                                                {
  if (bbox.xmax < bbox.xmin || bbox.ymax < bbox.ymin) {
    // If bbox is invalid (e.g. xmax < xmin or ymax < ymin), return 0.
    return 0;
  } else {
    if (bbox.size >= 0) {
      return bbox.size;
    } else {
      float width = bbox.xmax - bbox.xmin;
      float height = bbox.ymax - bbox.ymin;
      return width * height;
    }
  }
}

get_cpu_data()

const float * apollo::perception::camera::get_cpu_data	(	bool	flag,
		const base::Blob< float > &	blob
	)

在文件 postprocess.cc 第 415 行定义.

                                                                  {
  return flag ? blob.cpu_data() : nullptr;
}

get_gpu_data()

const float * apollo::perception::camera::get_gpu_data	(	bool	flag,
		const base::Blob< float > &	blob
	)

Get the gpu data object

参数

flag	flag to get the gpu data object
blob	blob to get the gpu data object

返回

const float* the gpu data object

get_intersect_bbox()

void apollo::perception::camera::get_intersect_bbox	(	const NormalizedBBox &	bbox1,
		const NormalizedBBox &	bbox2,
		NormalizedBBox *	intersect_bbox
	)

Get the intersect bbox object

参数

bbox1	[in] first bbox
bbox2	[in] second bbox
intersect_bbox	[out] intersect bbox

在文件 postprocess.cc 第 25 行定义.

                                                        {
  if (bbox2.xmin > bbox1.xmax || bbox2.xmax < bbox1.xmin ||
      bbox2.ymin > bbox1.ymax || bbox2.ymax < bbox1.ymin) {
    // Return [0, 0, 0, 0] if there is no intersection.
    intersect_bbox->xmin = 0;
    intersect_bbox->ymin = 0;
    intersect_bbox->xmax = 0;
    intersect_bbox->ymax = 0;
  } else {
    intersect_bbox->xmin = std::max(bbox1.xmin, bbox2.xmin);
    intersect_bbox->ymin = std::max(bbox1.ymin, bbox2.ymin);
    intersect_bbox->xmax = std::min(bbox1.xmax, bbox2.xmax);
    intersect_bbox->ymax = std::min(bbox1.ymax, bbox2.ymax);
  }
}

get_jaccard_overlap()

float apollo::perception::camera::get_jaccard_overlap	(	const NormalizedBBox &	bbox1,
		const NormalizedBBox &	bbox2
	)

Get the jaccard overlap object

参数

bbox1	[in] first bbox
bbox2	[in] second bbox

返回

float jaccard overlap

在文件 postprocess.cc 第 58 行定义.

                                                       {
  NormalizedBBox intersect_bbox;
  get_intersect_bbox(bbox1, bbox2, &intersect_bbox);
  float intersect_width = 0.f;
  float intersect_height = 0.f;
  intersect_width = intersect_bbox.xmax - intersect_bbox.xmin;
  intersect_height = intersect_bbox.ymax - intersect_bbox.ymin;
 
  if (intersect_width > 0 && intersect_height > 0) {
    float intersect_size = intersect_width * intersect_height;
    float bbox1_size = get_bbox_size(bbox1);
    float bbox2_size = get_bbox_size(bbox2);
    return intersect_size / (bbox1_size + bbox2_size - intersect_size);
  } else {
    return 0.;
  }
}

get_max_score_index()

void apollo::perception::camera::get_max_score_index	(	const std::vector< float > &	scores,
		const float	threshold,
		const int	top_k,
		std::vector< std::pair< float, int > > *	score_index_vec
	)

Get the max score index object

参数

scores	the scores array
threshold	threshold value
top_k	top k
score_index_vec	output index array

在文件 postprocess.cc 第 77 行定义.

                                                                          {
  // Generate index score pairs.
  for (int i = 0; i < static_cast<int>(scores.size()); ++i) {
    if (scores[i] > threshold) {
      score_index_vec->push_back(std::make_pair(scores[i], i));
    }
  }
 
  // Sort the score pair according to the scores in descending order
  std::stable_sort(score_index_vec->begin(), score_index_vec->end(),
                   sort_score_pair_descend<int>);
 
  // Keep top_k scores if needed.
  if (top_k > -1 && top_k < static_cast<int>(score_index_vec->size())) {
    score_index_vec->resize(top_k);
  }
}

get_objects_cpu()

void apollo::perception::camera::get_objects_cpu	(	const YoloBlobs &	yolo_blobs,
		const cudaStream_t &	stream,
		const std::vector< base::ObjectSubType > &	types,
		const NMSParam &	nms,
		const yolo::ModelParam &	model_param,
		float	light_vis_conf_threshold,
		float	light_swt_conf_threshold,
		base::Blob< bool > *	overlapped,
		base::Blob< int > *	idx_sm,
		std::vector< base::ObjectPtr > *	objects
	)

Get the objects cpu object

参数

yolo_blobs	YOLO blobs
stream	CUDA stream
types	object types
nms	nms params
model_param	model params
light_vis_conf_threshold	light vis conf threshold
light_swt_conf_threshold	light swt conf threshold
overlapped	overlapped blob
idx_sm	idx sm blob
objects	object blob

在文件 postprocess.cc 第 419 行定义.

                                                        {
  std::map<base::ObjectSubType, std::vector<int>> indices;
  std::map<base::ObjectSubType, std::vector<float>> conf_scores;
  int num_kept = 0;
  int num_classes = types.size();
  num_kept = get_objects_gpu(yolo_blobs, stream, types, nms, model_param,
                             light_vis_conf_threshold, light_swt_conf_threshold,
                             overlapped, idx_sm, indices, conf_scores);
  objects->clear();
 
  if (num_kept == 0) {
    return;
  }
 
  objects->reserve(num_kept + static_cast<int>(objects->size()));
  const float *cpu_box_data = yolo_blobs.res_box_blob->cpu_data();
 
  ObjectMaintainer maintainer;
  for (auto it = indices.begin(); it != indices.end(); ++it) {
    base::ObjectSubType label = it->first;
    if (conf_scores.find(label) == conf_scores.end()) {
      // Something bad happened if there are no predictions for current label.
      continue;
    }
    const std::vector<float> &scores = conf_scores.find(label)->second;
    std::vector<int> &indice = it->second;
    for (size_t j = 0; j < indice.size(); ++j) {
      int idx = indice[j];
      const float *bbox = cpu_box_data + idx * kBoxBlockSize;
      if (scores[idx] < model_param.confidence_threshold()) {
        continue;
      }
 
      base::ObjectPtr obj = nullptr;
      obj.reset(new base::Object);
      obj->type = base::kSubType2TypeMap.at(label);
      obj->sub_type = label;
      obj->type_probs.assign(
          static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE), 0);
      obj->sub_type_probs.assign(
          static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
      float total = 1e-5;
      for (int k = 0; k < num_classes; ++k) {
        auto &vis_type_k = types[k];
        auto &obj_type_k = base::kSubType2TypeMap.at(vis_type_k);
        auto &conf_score = conf_scores[vis_type_k][idx];
        obj->type_probs[static_cast<int>(obj_type_k)] += conf_score;
        obj->sub_type_probs[static_cast<int>(vis_type_k)] = conf_score;
        total += conf_score;
      }
      obj->confidence = obj->type_probs[static_cast<int>(obj->type)];
      for (size_t k = 0; k < obj->type_probs.size(); ++k) {
        obj->type_probs[k] /= total;
      }
      fill_base(obj, bbox);
      fill_bbox3d(model_param.with_box3d(), obj, bbox + 4);
      fill_frbox(model_param.with_frbox(), obj, bbox + 8);
      fill_lights(model_param.with_lights(), obj, bbox + 16);
      fill_ratios(model_param.with_ratios(), obj, bbox + 22);
      fill_area_id(model_param.num_areas() > 0, obj, bbox + 30);
 
      // todo: maintainer just found?
      if (maintainer.Add(idx, obj)) {
        objects->push_back(obj);
      }
    }
  }
}

get_objects_gpu()

int apollo::perception::camera::get_objects_gpu	(	const YoloBlobs &	yolo_blobs,
		const cudaStream_t &	stream,
		const std::vector< base::ObjectSubType > &	types,
		const NMSParam &	nms,
		const yolo::ModelParam &	model_param,
		float	light_vis_conf_threshold,
		float	light_swt_conf_threshold,
		base::Blob< bool > *	overlapped,
		base::Blob< int > *	idx_sm,
		const std::map< base::ObjectSubType, std::vector< int > > &	indices,
		const std::map< base::ObjectSubType, std::vector< float > > &	conf_scores
	)

Get the objects gpu object

参数

yolo_blobs	YOLO blobs
stream	Stream to use
types	Type of object
nms	NMS type
model_param	Model's parameter
light_vis_conf_threshold	Light vis confidence threshold
light_swt_conf_threshold	Light swt confidence threshold
overlapped	Overlapped objects
idx_sm	Indices of objects in blob
indices	Indices of objects in blob
conf_scores	Confidence scores of objects

返回

int

GetBboxFromPts()

template<typename T >

void apollo::perception::camera::GetBboxFromPts	(	const T *	pts,
		const int &	n,
		T *	bbox
	)

在文件 twod_threed_util.h 第 147 行定义.

                                                         {
  bbox[0] = bbox[2] = pts[0];
  bbox[1] = bbox[3] = pts[1];
  int i2 = 2;
  for (int i = 1; i < n; ++i) {
    T x = pts[i2];
    T y = pts[i2 + 1];
    bbox[0] = std::min(bbox[0], x);
    bbox[1] = std::min(bbox[1], y);
    bbox[2] = std::max(bbox[2], x);
    bbox[3] = std::max(bbox[3], y);
    i2 += 2;
  }
}

GetBlobNames3DYolox()

std::vector< std::string > apollo::perception::camera::GetBlobNames3DYolox

(

const google::protobuf::RepeatedPtrField< common::ModelBlob > &

model_blobs

)

在文件 yolox3d_obstacle_detector.cc 第 67 行定义.

                                                                        {
  std::vector<std::string> blob_names;
  for (const auto &blob : model_blobs) {
    blob_names.push_back(blob.name());
  }
  return blob_names;
}

GetCaddnObjects()

void apollo::perception::camera::GetCaddnObjects	(	std::vector< base::ObjectPtr > *	objects,
		const caddn::ModelParam &	model_param,
		const std::vector< base::ObjectSubType > &	types,
		const base::BlobPtr< float > &	boxes,
		const base::BlobPtr< float > &	labels,
		const base::BlobPtr< float > &	scores
	)

Get the Caddn Objects objects from Blob

参数

objects	The objects container
model_param	The Caddn model param
types	The object types
boxes	The boxes container
labels	The labels container
scores	The scores container

在文件 postprocess.cc 第 25 行定义.

                                                       {
  objects->clear();
  const float *boxes_data = boxes->cpu_data();
  const float *labels_data = labels->cpu_data();
  const float *scores_data = scores->cpu_data();
 
  int len_pred = 7;
  for (int i = 0; i < labels->num(); ++i) {
    const float *bbox = boxes_data + i * len_pred;
    float score = *(scores_data + i);
    if (score < model_param.score_threshold()) {
      continue;
    }
 
    float label = *(labels_data + i);
    base::ObjectPtr obj = nullptr;
    obj.reset(new base::Object);
    obj->sub_type = GetSubtype(label, types);
    obj->type = base::kSubType2TypeMap.at(obj->sub_type);
    obj->type_probs.assign(static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE),
                           0);
    obj->sub_type_probs.assign(
        static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
    obj->type_probs[static_cast<int>(obj->type)] = score;
    obj->sub_type_probs[static_cast<int>(obj->sub_type)] = score;
    obj->confidence = score;
 
    // todo(zero): Need to be converted to camera coordinates and
    // converted to KITTI coordinates
    Eigen::Matrix<float, 3, 4> velo_to_cam;
    velo_to_cam << 0.00753374, -0.9999714, -0.0006166, -0.00406977, 0.01480249,
        0.00072807, -0.9998902, -0.07631618, 0.9998621, 0.00752379, 0.01480755,
        -0.2717806;
 
    Eigen::Matrix<float, 3, 3> R;
    R << 0.9999239, 0.00983776, -0.00744505, -0.0098698, 0.9999421, -0.00427846,
        0.00740253, 0.00435161, 0.9999631;
 
    std::vector<float> test_result(7);
    Bbox3dLidar2Camera(velo_to_cam, R, bbox, &test_result);
 
    FillCaddnBbox3d(obj, test_result.data());
 
    objects->push_back(obj);
  }
}

GetDxDzForCenterFromGroundLineSeg()

template<typename T >

void apollo::perception::camera::GetDxDzForCenterFromGroundLineSeg	(	const LineSegment2D< T > &	ls,
		const T *	plane,
		const T *	pts_c,
		const T *	k_mat,
		int	width,
		int	height,
		T	ratio_x_over_z,
		T *	dx_dz,
		bool	check_lowerbound = true
	)

在文件 twod_threed_util.h 第 277 行定义.

                                                                     {
  const T Z_RESOLUTION = static_cast<T>(1e-1);
  const T Z_UNSTABLE_RATIO = static_cast<T>(0.3f);
 
  dx_dz[0] = dx_dz[1] = (T)0;
  ACHECK(ls.pt_start[0] < ls.pt_end[0]);
  if (!CheckXY(ls.pt_start[0], ls.pt_start[1], width, height) ||
      !CheckXY(ls.pt_end[0], ls.pt_end[1], width, height)) {
    return;
  }
  T pt_of_line_seg_l[3] = {0};
  T pt_of_line_seg_r[3] = {0};
  bool is_front_l = algorithm::IBackprojectPlaneIntersectionCanonical(
      ls.pt_start, k_mat, plane, pt_of_line_seg_l);
  bool is_front_r = algorithm::IBackprojectPlaneIntersectionCanonical(
      ls.pt_end, k_mat, plane, pt_of_line_seg_r);
  if (!is_front_l || !is_front_r) {
    return;
  }
  ADEBUG << "l&r on-ground points: " << pt_of_line_seg_l[0] << ", "
         << pt_of_line_seg_l[1] << ", " << pt_of_line_seg_l[2] << " | "
         << pt_of_line_seg_r[0] << ", " << pt_of_line_seg_r[1] << ", "
         << pt_of_line_seg_r[2];
 
  // get transform
  T rot[9] = {0};
  T t[3] = {0};
  T pos[3] = {pt_of_line_seg_l[0], pt_of_line_seg_l[1], pt_of_line_seg_l[2]};
  T v[3] = {pt_of_line_seg_r[0] - pt_of_line_seg_l[0],
            pt_of_line_seg_r[1] - pt_of_line_seg_l[1],
            pt_of_line_seg_r[2] - pt_of_line_seg_l[2]};
  T ry = static_cast<T>(-atan2(v[2], v[0]));
  GenRotMatrix(ry, rot);
  algorithm::ITranspose3x3(rot);
  algorithm::IScale3(pos, (T)-1);
  algorithm::IMultAx3x3(rot, pos, t);
  ADEBUG << "ry: " << ry;
 
  T l[3] = {0};
  T pt1[3] = {0};
  T pt2[3] = {ratio_x_over_z, (T)0, (T)1};
  T pt1_local[3] = {0};
  T pt2_local[3] = {0};
 
  // transform to local birdview coordinates
  std::pair<T, T> range;
  range.first = 0;
  range.second = algorithm::ISqrt(
      algorithm::ISqr(v[0]) + algorithm::ISqr(v[2]));
  T pts_local[12] = {0};
  algorithm::IProjectThroughExtrinsic(rot, t, pts_c, pts_local);
  algorithm::IProjectThroughExtrinsic(rot, t, pts_c + 3, pts_local + 3);
  algorithm::IProjectThroughExtrinsic(rot, t, pts_c + 6, pts_local + 6);
  algorithm::IProjectThroughExtrinsic(rot, t, pts_c + 9, pts_local + 9);
 
  algorithm::IProjectThroughExtrinsic(rot, t, pt1, pt1_local);
  algorithm::IProjectThroughExtrinsic(rot, t, pt2, pt2_local);
  T x[2] = {pt1_local[0], pt1_local[2]};
  T xp[2] = {pt2_local[0], pt2_local[2]};
  algorithm::ILineFit2d(x, xp, l);
 
  T zs[4] = {pts_local[2], pts_local[5], pts_local[8], pts_local[11]};
  T z_offset = static_cast<T>(0);
  bool all_positive = zs[0] > 0.0f && zs[1] > 0.f && zs[2] > 0.f && zs[3] > 0.f;
  if (all_positive) {
    z_offset = std::min(zs[0], std::min(zs[1], std::min(zs[2], zs[3])));
  } else {
    z_offset = std::max(zs[0], std::max(zs[1], std::max(zs[2], zs[3])));
    T xs[4] = {pts_local[0], pts_local[3], pts_local[6], pts_local[9]};
    // 1 -> 2
    UpdateOffsetZ(xs[0], zs[0], xs[1], zs[1], range, &z_offset);
    // 2 -> 3
    UpdateOffsetZ(xs[1], zs[1], xs[2], zs[2], range, &z_offset);
    // 3 -> 4
    UpdateOffsetZ(xs[2], zs[2], xs[3], zs[3], range, &z_offset);
    // 4 -> 1
    UpdateOffsetZ(xs[3], zs[3], xs[0], zs[0], range, &z_offset);
  }
  if (z_offset < Z_RESOLUTION && z_offset > -Z_RESOLUTION) {
    return;
  }
 
  // judge & convert back to camera coordinates
  if (z_offset > static_cast<T>(0.0f) && check_lowerbound) {
    return;
  }
 
  T center_c[3] = {0};
  center_c[0] = (pts_c[0] + pts_c[3] + pts_c[6] + pts_c[9]) / 4;
  center_c[2] = (pts_c[2] + pts_c[5] + pts_c[8] + pts_c[11]) / 4;
  T z_avg = center_c[2];
 
  T dz_local = -z_offset;
  T dx_local =
      -l[1] * dz_local * algorithm::IRec(l[0]); /*enforce to be along the ray*/
 
  T center_local[3] = {0};
  algorithm::IProjectThroughExtrinsic(rot, t, center_c, center_local);
  center_local[0] += dx_local;
  center_local[1] = 0;
  center_local[2] += dz_local;
  T center_local_to_c[3] = {0};
  algorithm::ISub3(t, center_local);
  algorithm::IMultAtx3x3(rot, center_local, center_local_to_c);
  dx_dz[0] = center_local_to_c[0] - center_c[0];
  dx_dz[1] = center_local_to_c[2] - center_c[2];
 
  T dz_max = z_avg * Z_UNSTABLE_RATIO;
  if (z_offset > static_cast<T>(0.0f) && std::abs(dx_dz[1]) > dz_max) {
    dx_dz[0] = dx_dz[1] = 0;
  }
}

GetFileListFromFile()

bool apollo::perception::camera::GetFileListFromFile	(	const std::string &	file_name,
		std::vector< std::string > *	file_list
	)

Get the File List From File object

参数

file_name	A file containing all filenames
file_list	Array of output filenames

返回

true success

false fail

在文件 util.cc 第 64 行定义.

                                                          {
  std::ifstream in(file_name.c_str());
 
  if (!in) {
    AERROR << "Failed to open file: " << file_name;
    return false;
  }
 
  std::string line;
  while (std::getline(in, line)) {
    if (!line.empty()) {
      file_list->push_back(line);
    }
  }
 
  in.close();
  return true;
}

GetFileListFromPath()

bool apollo::perception::camera::GetFileListFromPath	(	const std::string &	file_path,
		std::vector< std::string > *	file_list
	)

Get the File List From Path object

参数

file_path	A file path containing all filenames
file_list	Array of output filenames

返回

true success

false fail

在文件 util.cc 第 58 行定义.

                                                          {
  // todo(zero): need complete
  return true;
}

GetGround3FromPitchHeight()

void apollo::perception::camera::GetGround3FromPitchHeight	(	const std::vector< float > &	k_mat,
		const float &	baseline,
		const float &	pitch,
		const float &	cam_height,
		std::vector< float > *	ground3
	)

在文件 camera_ground_plane.cc 第 97 行定义.

                                                          {
  CHECK_EQ(k_mat.size(), 9U);
  CHECK_GT(baseline, 0.0f);
  CHECK_GT(cam_height, 0.0f);
  CHECK_NOTNULL(ground3);
  CHECK_EQ(ground3->size(), 3U);
  float sin_pitch = static_cast<float>(sin(pitch));
  float cos_pitch = static_cast<float>(cos(pitch));
  std::vector<float> ground4 = {0, cos_pitch, -sin_pitch, -cam_height};
  ConvertGround4ToGround3(baseline, k_mat, ground4, ground3);
}

GetGroundPlanePitchHeight()

void apollo::perception::camera::GetGroundPlanePitchHeight	(	const float &	baseline,
		const std::vector< float > &	k_mat,
		const std::vector< float > &	ground3,
		float *	pitch,
		float *	cam_height
	)

在文件 camera_ground_plane.cc 第 77 行定义.

                                                  {
  CHECK_GT(baseline, 0.0f);
  CHECK_EQ(k_mat.size(), 9U);
  CHECK_EQ(ground3.size(), 3U);
  CHECK_NOTNULL(pitch);
  CHECK_NOTNULL(cam_height);
  std::vector<float> ground4(4, 0.0f);
  ConvertGround3ToGround4(baseline, k_mat, ground3, &ground4);
  if (ground4[3] > 0.0f) {
    algorithm::IScale4(ground4.data(), -1.0f);
  }
  *cam_height = -ground4[3];
  double cos_pitch = ground4[1];
  double sin_pitch = -ground4[2];
  *pitch = static_cast<float>(atan2(sin_pitch, cos_pitch));
}

GetImage()

cv::Mat apollo::perception::camera::GetImage	(	const std::string &	path,
		bool	to_rgb
	)

在文件 camera_preprocess_general_util.cc 第 26 行定义.

                                                   {
  cv::Mat img = cv::imread(path);
 
  if (!img.data) {
    throw std::runtime_error("Failed to read image: " + path);
  }
 
  if (to_rgb && img.channels() == 3) {
    cv::cvtColor(img, img, cv::COLOR_BGR2RGB);
  }
  return img;
}

GetJaccardIndex()

template<typename T >

T apollo::perception::camera::GetJaccardIndex	(	const T *	bbox_ref,
		const T &	x_min,
		const T &	y_min,
		const T &	x_max,
		const T &	y_max
	)

在文件 twod_threed_util.h 第 86 行定义.

                                                  {
  T overlap_x = std::min(bbox_ref[2], x_max) - std::max(bbox_ref[0], x_min);
  T overlap_y = std::min(bbox_ref[3], y_max) - std::max(bbox_ref[1], y_min);
  if (overlap_y <= (T)0 || overlap_x <= (T)0) {
    return (T)0;
  }
  T inter_area = overlap_x * overlap_y;
  T union_area = (y_max - y_min) * (x_max - x_min) +
                 (bbox_ref[3] - bbox_ref[1]) * (bbox_ref[2] - bbox_ref[0]) -
                 inter_area;
  return inter_area * algorithm::IRec(union_area);
}

GetMinIndexVec()

template<typename T >

int apollo::perception::camera::GetMinIndexVec	(	const T *	vec,
		const int &	n
	)

在文件 twod_threed_util.h 第 163 行定义.

                                               {
  CHECK_GT(n, 0);
  int index = 0;
  T min_val = vec[0];
  for (int i = 1; i < n; ++i) {
    if (vec[i] < min_val) {
      min_val = vec[i];
      index = i;
    }
  }
  return index;
}

GetObjects()

void apollo::perception::camera::GetObjects	(	const base::BlobPtr< float > &	box3ds,
		const base::BlobPtr< float > &	labels,
		const base::BlobPtr< float > &	scores,
		const std::vector< base::ObjectSubType > &	types,
		float	score_threshold,
		std::vector< base::ObjectPtr > *	objects
	)

Get the Objects objects from blob

参数

box3ds	The input box 3ds blob
labels	The input labels blob
scores	The input scores blob
types	The input types blob
score_threshold	The threshold for score to be considered
objects	The output objects blob

在文件 postprocess.cc 第 35 行定义.

                                                                          {
  const auto bbox_ptr = box3ds->cpu_data();
  const auto label_ptr = labels->cpu_data();
  const auto score_ptr = scores->cpu_data();
 
  int feature_size = box3ds->shape(1);
  objects->clear();
  for (int i = 0; i < scores->count(); ++i) {
    float score = score_ptr[i];
    if (score < score_threshold) {
      continue;
    }
 
    base::ObjectPtr obj;
    obj.reset(new base::Object());
 
    obj->sub_type = GetSubtype(label_ptr[i], types);
    obj->type = base::kSubType2TypeMap.at(obj->sub_type);
    obj->type_probs.assign(static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE),
                           0);
    obj->sub_type_probs.assign(
        static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
    obj->type_probs[static_cast<int>(obj->type)] = score;
    obj->sub_type_probs[static_cast<int>(obj->sub_type)] = score;
    obj->confidence = score;
 
    FillBBox3d(bbox_ptr + i * feature_size, obj);
 
    objects->push_back(obj);
  }
}

GetObjectsCpu()

void apollo::perception::camera::GetObjectsCpu	(	const std::shared_ptr< base::Blob< float > > &	output_blob,
		const std::vector< base::ObjectSubType > &	types,
		const smoke::ModelParam &	model_param,
		std::vector< base::ObjectPtr > *	objects,
		int	width,
		int	height
	)

在文件 postprocess.cc 第 108 行定义.

                                          {
  const float* detect_result = output_blob->cpu_data();
  objects->clear();
  auto shape = output_blob->shape();
 
  int len_pred = shape[1];
  int total = shape[0] * shape[1];
  int step = 0;
  while (step < total) {
    const float* bbox = detect_result + step;
    step += len_pred;
    float score = bbox[13];
    if (score < model_param.confidence_threshold()) {
      continue;
    }
 
    base::ObjectPtr obj = std::make_shared<base::Object>();
    int label = static_cast<int>(bbox[0]);
    obj->sub_type = GetSubtype(label, types);
    obj->type = base::kSubType2TypeMap.at(obj->sub_type);
    obj->type_probs.assign(
        static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE), 0);
    obj->sub_type_probs.assign(
        static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
    obj->type_probs[static_cast<int>(obj->type)] = score;
    obj->sub_type_probs[static_cast<int>(obj->sub_type)] = score;
    obj->confidence = score;
 
    FillBBox(obj, bbox, width, height);
    FillBBox3d(obj, bbox);
    objects->push_back(obj);
  }
}

GetPolyValue()

template<typename T = float>

T apollo::perception::camera::GetPolyValue	(	T	a,
		T	b,
		T	c,
		T	d,
		T	x
	)

在文件 darkSCNN_lane_postprocessor.cc 第 66 行定义.

                                        {
  T y = d;
  T v = x;
  y += (c * v);
  v *= x;
  y += (b * v);
  v *= x;
  y += (a * v);
  return y;
}

GetSceneFlowLabel()

PointSemanticLabel apollo::perception::camera::GetSceneFlowLabel ( uint8_t  value )

inline

在文件 utils.h 第 47 行定义.

                                                           {
  return static_cast<PointSemanticLabel>(value >> 4);
}

GetScoreViaRotDimensionCenter()

template<typename T >

T apollo::perception::camera::GetScoreViaRotDimensionCenter	(	const T *	k_mat,
		int	width,
		int	height,
		const T *	bbox,
		const T *	rot,
		const T *	hwl,
		const T *	location,
		const bool &	check_truncation,
		T *	bbox_res = nullptr,
		T *	bbox_near = nullptr
	)

在文件 twod_threed_util.h 第 177 行定义.

                                                                               {
  T h = hwl[0];
  T w = hwl[1];
  T l = hwl[2];
  T x_corners[8] = {0};
  T y_corners[8] = {0};
  T z_corners[8] = {0};
  GenCorners(h, w, l, x_corners, y_corners, z_corners);
 
  T x_min = std::numeric_limits<float>::max();
  T x_max = -std::numeric_limits<float>::max();
  T y_min = std::numeric_limits<float>::max();
  T y_max = -std::numeric_limits<float>::max();
  T x_proj[3];
  T x_box[3];
  T pts_proj[16];
  for (int i = 0; i < 8; ++i) {
    x_box[0] = x_corners[i];
    x_box[1] = y_corners[i];
    x_box[2] = z_corners[i];
    algorithm::IProjectThroughKRt(k_mat, rot, location, x_box, x_proj);
    x_proj[0] *= algorithm::IRec(x_proj[2]);
    x_proj[1] *= algorithm::IRec(x_proj[2]);
 
    if (bbox_near != nullptr) {
      int i2 = i * 2;
      pts_proj[i2] = x_proj[0];
      pts_proj[i2 + 1] = x_proj[1];
    }
    x_min = std::min(x_min, x_proj[0]);
    x_max = std::max(x_max, x_proj[0]);
    y_min = std::min(y_min, x_proj[1]);
    y_max = std::max(y_max, x_proj[1]);
    if (check_truncation) {
      x_min = std::min(std::max(x_min, (T)0), (T)(width - 1));
      x_max = std::min(std::max(x_max, (T)0), (T)(width - 1));
      y_min = std::min(std::max(y_min, (T)0), (T)(height - 1));
      y_max = std::min(std::max(y_max, (T)0), (T)(height - 1));
    }
  }
  if (bbox_res != nullptr) {
    bbox_res[0] = x_min;
    bbox_res[1] = y_min;
    bbox_res[2] = x_max;
    bbox_res[3] = y_max;
  }
  if (bbox_near != nullptr) {
    T bbox_front[4] = {0};
    T bbox_rear[4] = {0};
    std::swap(pts_proj[4], pts_proj[8]);
    std::swap(pts_proj[5], pts_proj[9]);
    std::swap(pts_proj[6], pts_proj[10]);
    std::swap(pts_proj[7], pts_proj[11]);
    GetBboxFromPts(pts_proj, 4, bbox_front);
    GetBboxFromPts(pts_proj + 8, 4, bbox_rear);
    if (bbox_rear[3] - bbox_rear[1] > bbox_front[3] - bbox_front[1]) {
      memcpy(bbox_near, bbox_rear, sizeof(T) * 4);
    } else {
      memcpy(bbox_near, bbox_front, sizeof(T) * 4);
    }
  }
  return GetJaccardIndex(bbox, x_min, y_min, x_max, y_max);
}

GetSemanticLabel()

PointSemanticLabel apollo::perception::camera::GetSemanticLabel ( uint8_t  value )

inline

在文件 utils.h 第 33 行定义.

                                                          {
  return static_cast<PointSemanticLabel>(value & 15);
}

GetSharpAngle()

template<typename T >

T apollo::perception::camera::GetSharpAngle ( const T &  a, const T &  b  )

inline

在文件 twod_threed_util.h 第 72 行定义.

                                               {
  /*a and b are in [-pi, pi)*/
  const T pi = algorithm::Constant<T>::PI();
  T angle = std::abs(a - b);
  if (angle > pi) {
    angle -= pi;
  }
  angle = std::min(angle, pi - angle);
  return angle;
}

GetSubtype()

base::ObjectSubType apollo::perception::camera::GetSubtype	(	int	cls,
		const std::vector< base::ObjectSubType > &	types
	)

Get the Subtype

Get the Subtype objects from Blob

参数

cls	Input class label
types	Output type label

返回

base::ObjectSubType

参数

cls	the object container
types	the object types

返回

base::ObjectSubType

在文件 postprocess.cc 第 26 行定义.

                                                                          {
  if (cls < 0 || cls >= static_cast<int>(types.size())) {
    return base::ObjectSubType::UNKNOWN;
  }
 
  return types[cls];
}

GetYawVelocityInfo()

void apollo::perception::camera::GetYawVelocityInfo	(	const float &	time_diff,
		const double	cam_coord_cur[3],
		const double	cam_coord_pre[3],
		const double	cam_coord_pre_pre[3],
		float *	yaw_rate,
		float *	velocity
	)

在文件 lane_based_calibrator.cc 第 24 行定义.

                                         {
  assert(yaw_rate != nullptr);
  assert(velocity != nullptr);
  double time_diff_r = algorithm::IRec(static_cast<double>(time_diff));
  double dist = algorithm::ISqrt(
      algorithm::ISquaresumDiffU2(cam_coord_cur, cam_coord_pre));
  *velocity = static_cast<float>(dist * time_diff_r);
 
  double offset_cur[2] = {
      cam_coord_cur[0] - cam_coord_pre[0],
      cam_coord_cur[1] - cam_coord_pre[1],
  };
  double offset_pre[2] = {
      cam_coord_pre[0] - cam_coord_pre_pre[0],
      cam_coord_pre[1] - cam_coord_pre_pre[1],
  };
  double yaw_cur = atan2(offset_cur[1], offset_cur[0]);
  double yaw_pre = atan2(offset_pre[1], offset_pre[0]);
  double yaw_rate_db = (yaw_cur - yaw_pre) * time_diff_r;
  *yaw_rate = static_cast<float>(yaw_rate_db);
}

GroundFittingCostFunc()

template<typename T >

void apollo::perception::camera::GroundFittingCostFunc	(	const T *	p,
		const T *	v,
		const T *	d,
		int	n,
		int *	nr_inlier,
		int *	inliers,
		T *	cost,
		T	error_tol
	)

在文件 camera_ground_plane.h 第 179 行定义.

                                        {
  *cost = static_cast<T>(0.0f);
  *nr_inlier = 0;
  const T *refx = v;
  const T *refp = d;
  for (int i = 0; i < n; ++i) {
    T d_proj = refx[0] * p[0] + p[1];
    T proj_err = static_cast<T>(fabs(d_proj - refp[0]));
    if (proj_err < error_tol) {
      inliers[(*nr_inlier)++] = i;
      *cost += proj_err;
    }
    ++refx;
    ++refp;
  }
}

GroundHypoGenFunc()

template<typename T >

void apollo::perception::camera::GroundHypoGenFunc	(	const T *	v,
		const T *	d,
		T *	p
	)

在文件 camera_ground_plane.h 第 168 行定义.

                                                     {
  // disp = p0 * y + p1 -> l = {p0, -1, p1}
  T x[2] = {v[0], d[0]};
  T xp[2] = {v[1], d[1]};
  T l[3] = {0};
  algorithm::ILineFit2d(x, xp, l);
  p[0] = -l[0] * algorithm::IRec(l[1]);
  p[1] = -l[2] * algorithm::IRec(l[1]);
}

HWC2CHW()

std::vector< float > apollo::perception::camera::HWC2CHW

(

const cv::Mat &

input_img

)

在文件 camera_preprocess_general_util.cc 第 69 行定义.

                                                 {
  int channel = input_img.channels();
  int width = input_img.cols;
  int height = input_img.rows;
 
  std::vector<cv::Mat> input_channels(channel);
  cv::split(input_img, input_channels);
 
  std::vector<float> result(channel * width * height);
  auto data = result.data();
  int channel_length = width * height;
 
  for (int i = 0; i < channel; ++i) {
    memcpy(data, input_channels[i].data, channel_length * sizeof(float));
    data += channel_length;
  }
  return result;
}

ImagePoint2Camera()

bool apollo::perception::camera::ImagePoint2Camera	(	const base::Point2DF &	img_point,
		float	pitch_angle,
		float	camera_ground_height,
		const Eigen::Matrix3f &	intrinsic_params_inverse,
		Eigen::Vector3d *	camera_point
	)

在文件 common_functions.cc 第 203 行定义.

                                                    {
  Eigen::MatrixXf pt_m(3, 1);
  pt_m << img_point.x, img_point.y, 1;
  const Eigen::MatrixXf& org_camera_point = intrinsic_params_inverse * pt_m;
  //
  float cos_pitch = static_cast<float>(cos(pitch_angle));
  float sin_pitch = static_cast<float>(sin(pitch_angle));
  Eigen::Matrix3f pitch_matrix;
  pitch_matrix << 1, 0, 0, 0, cos_pitch, sin_pitch, 0, -sin_pitch, cos_pitch;
  const Eigen::MatrixXf& rotate_point = pitch_matrix * org_camera_point;
  if (fabs(rotate_point(1, 0)) < lane_eps_value) {
    return false;
  }
  float scale = camera_ground_height / rotate_point(1, 0);
  (*camera_point)(0) = scale * org_camera_point(0, 0);
  (*camera_point)(1) = scale * org_camera_point(1, 0);
  (*camera_point)(2) = scale * org_camera_point(2, 0);
  return true;
}

imageRemap()

bool apollo::perception::camera::imageRemap	(	const base::Image8U &	src_img,
		base::Image8U *	dst_img,
		const int	src_width,
		const int	src_height,
		const base::Blob< float > &	map_x,
		const base::Blob< float > &	map_y
	)

在文件 image_data_operations.cc 第 60 行定义.

                                              {
  return nppImageRemap(src_img, dst_img, src_width, src_height, map_x, map_y);
}

imageToBlob()

bool apollo::perception::camera::imageToBlob	(	const base::Image8U &	image,
		base::Blob< uint8_t > *	blob
	)

在文件 image_data_operations.cc 第 39 行定义.

                                                                    {
  return nppImageToBlob(image, blob);
}

imageToGray()

bool apollo::perception::camera::imageToGray	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const float	coeffs[3]
	)

在文件 image_data_operations.cc 第 43 行定义.

                                        {
  return nppImageToGray(src, dst, src_width, src_height, coeffs);
}

InitDataProvider()

bool apollo::perception::camera::InitDataProvider

(

onboard::CameraFrame *

camera_frame

)

在文件 offline_camera_detection.cc 第 53 行定义.

                                                        {
  DataProvider::InitOptions init_options;
  init_options.sensor_name = FLAGS_camera_name;
  init_options.image_height = FLAGS_height;
  init_options.image_width = FLAGS_width;
  init_options.device_id = FLAGS_gpu_id;
 
  bool res = camera_frame->data_provider->Init(init_options);
  return res;
}

IsCovered()

template<typename T >

bool apollo::perception::camera::IsCovered	(	const base::Rect< T > &	rect1,
		const base::Rect< T > &	rect2,
		float	thresh
	)

在文件 util.h 第 39 行定义.

                             {
  base::RectF inter = rect1 & rect2;
  return inter.Area() / rect1.Area() > thresh;
}

IsCoveredHorizon()

template<typename T >

bool apollo::perception::camera::IsCoveredHorizon	(	const base::Rect< T > &	rect1,
		const base::Rect< T > &	rect2,
		float	thresh
	)

在文件 util.h 第 45 行定义.

                                    {
  base::RectF inter = rect1 & rect2;
  if (inter.Area() > 0) {
    return inter.width / rect1.width > thresh;
  }
  return false;
}

IsCoveredVertical()

template<typename T >

bool apollo::perception::camera::IsCoveredVertical	(	const base::Rect< T > &	rect1,
		const base::Rect< T > &	rect2,
		float	thresh
	)

在文件 util.h 第 54 行定义.

                                     {
  base::RectF inter = rect1 & rect2;
  if (inter.Area() > 0) {
    return inter.height / rect1.height > thresh;
  }
  return false;
}

IsSceneFlowLabelEqual()

bool apollo::perception::camera::IsSceneFlowLabelEqual ( PointSemanticLabel  label, uint8_t  value  )

inline

在文件 utils.h 第 51 行定义.

                                                                           {
  return (value >> 4) == static_cast<uint8_t>(label);
}

IsSemanticLabel()

bool apollo::perception::camera::IsSemanticLabel ( PointSemanticLabel  label, uint8_t  value  )

inline

在文件 utils.h 第 37 行定义.

                                                                     {
  return (value & 15) == static_cast<uint8_t>(label);
}

jaccard_overlap_gpu()

__host__ __device__ float apollo::perception::camera::jaccard_overlap_gpu	(	const float *	bbox1,
		const float *	bbox2
	)

LaneVisualization()

bool apollo::perception::camera::LaneVisualization	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

在文件 visualizer.cc 第 119 行定义.

                                                   {
  return true;
}

LoadAnchors()

bool apollo::perception::camera::LoadAnchors	(	const std::string &	path,
		std::vector< float > *	anchors
	)

在文件 util.cc 第 31 行定义.

                                                                   {
  int num_anchors = 0;
  std::ifstream ifs(path, std::ifstream::in);
  ifs >> num_anchors;
  if (!ifs.good()) {
    AERROR << "Failed to get number of anchors!";
    return false;
  }
  (*anchors).resize(num_anchors * 2);
  for (int i = 0; i < num_anchors; ++i) {
    ifs >> (*anchors)[i * 2] >> (*anchors)[i * 2 + 1];
    if (!ifs.good()) {
      AERROR << "Failed to load the " << i << "-th anchor!";
      return false;
    }
  }
  ifs.close();
  return true;
}

LoadExpand()

bool apollo::perception::camera::LoadExpand	(	const std::string &	path,
		std::vector< float > *	expands
	)

在文件 util.cc 第 72 行定义.

                                                                  {
  std::ifstream ifs(path, std::ifstream::in);
  if (!ifs.good()) {
    AERROR << "expand_list not found: " << path;
    return false;
  }
  float expand;
  AINFO << "Expand nums: ";
  while (ifs >> expand) {
    expands->push_back(expand);
    AINFO << "\t\t" << expand;
  }
  ifs.close();
  return true;
}

LoadKittiLabel()

bool apollo::perception::camera::LoadKittiLabel	(	onboard::CameraFrame *	frame,
		const std::string &	kitti_path,
		const std::string &	dist_type
	)

Read KITTI labels and fill to frame->detected_objects

参数

frame	onboard::CameraFrame
kitti_path	kitti path include labels
dist_type	"H-from-h" or "H-on-h"

返回

true

false

在文件 ground_truth.cc 第 43 行定义.

                                {
  frame->detected_objects.clear();
  FILE *fp = fopen(kitti_path.c_str(), "r");
  if (fp == nullptr) {
    AERROR << "Failed to load object file: " << kitti_path;
    return false;
  }
 
  while (!feof(fp)) {
    base::ObjectPtr obj = nullptr;
    obj.reset(new base::Object);
    float trash = 0.0f;
    float score = 0.0f;
    char type[255];
    float x1 = 0.0f;
    float y1 = 0.0f;
    float x2 = 0.0f;
    float y2 = 0.0f;
    memset(type, 0, sizeof(type));
 
    int ret = 0;
    ret = fscanf(fp, "%254s %f %f %lf %f %f %f %f %f %f %f %lf %lf %lf %f %f",
                 type, &trash, &trash, &obj->camera_supplement.alpha, &x1, &y1,
                 &x2, &y2, &obj->size[2], &obj->size[1], &obj->size[0],
                 &obj->center[0], &obj->center[1], &obj->center[2], &obj->theta,
                 &score);
    AINFO << "fscanf return: " << ret;
    if (dist_type == "H-from-h") {
      obj->size[0] = static_cast<float>(obj->center[2]);
    } else if (dist_type == "H-on-h") {
      obj->size[0] = static_cast<float>(obj->center[2]) * (y2 - y1);
    } else {
      AERROR << "Not supported dist type! " << dist_type;
      return false;
    }
    obj->camera_supplement.box.xmin = std::max<float>(x1, 0);
    obj->camera_supplement.box.ymin = std::max<float>(y1, 0);
    obj->camera_supplement.box.xmax =
        std::min<float>(
            x2, static_cast<float>(frame->data_provider->src_width()));
    obj->camera_supplement.box.ymax =
        std::min<float>(
            y2, static_cast<float>(frame->data_provider->src_height()));
    obj->camera_supplement.area_id = 5;
 
    if (object_subtype_map.find(type) == object_subtype_map.end()) {
      obj->sub_type = base::ObjectSubType::UNKNOWN;
    } else {
      obj->sub_type = object_subtype_map.at(type);
    }
    obj->type = base::kSubType2TypeMap.at(obj->sub_type);
    obj->type_probs.assign(
        static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE), 0);
    obj->sub_type_probs.assign(
        static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
    obj->sub_type_probs[static_cast<int>(obj->sub_type)] = score;
    obj->type_probs[static_cast<int>(obj->type)] = score;
 
    frame->detected_objects.push_back(obj);
  }
 
  fclose(fp);
  return true;
}

LoadTypes()

bool apollo::perception::camera::LoadTypes	(	const std::string &	path,
		std::vector< base::ObjectSubType > *	types
	)

在文件 util.cc 第 51 行定义.

                                                    {
  std::ifstream ifs(path, std::ifstream::in);
  if (!ifs.good()) {
    AERROR << "Type_list not found: " << path;
    return false;
  }
  std::string type;
  AINFO << "Supported types: ";
  while (ifs >> type) {
    if (base::kName2SubTypeMap.find(type) == base::kName2SubTypeMap.end()) {
      AERROR << "Invalid type: " << type;
      return false;
    }
    (*types).push_back(base::kName2SubTypeMap.at(type));
    AINFO << "\t\t" << type;
  }
  AINFO << "\t\t" << (*types).size() << " in total.";
  ifs.close();
  return true;
}

Normalize()

void apollo::perception::camera::Normalize	(	const std::vector< float > &	mean,
		const std::vector< float > &	std,
		float	scale,
		cv::Mat *	img
	)

Image normalize function

参数

mean	The mean value of the image.
std	The standard deviation of the image.
scale	The scale value of the image.
im	The image to be normalized.

在文件 preprocess.cc 第 33 行定义.

                                        {
  ACHECK(std.size() == 3);
  for (const auto std_value : std) {
    ACHECK(std_value != 0.0);
  }
  if (scale) {
    (*img).convertTo(*img, CV_32FC3, scale);
  }
  for (int h = 0; h < img->rows; ++h) {
    for (int w = 0; w < img->cols; ++w) {
      img->at<cv::Vec3f>(h, w)[0] =
          (img->at<cv::Vec3f>(h, w)[0] - mean[0]) / std[0];
      img->at<cv::Vec3f>(h, w)[1] =
          (img->at<cv::Vec3f>(h, w)[1] - mean[1]) / std[1];
      img->at<cv::Vec3f>(h, w)[2] =
          (img->at<cv::Vec3f>(h, w)[2] - mean[2]) / std[2];
    }
  }
}

nppDupImageChannels()

bool apollo::perception::camera::nppDupImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height
	)

在文件 image_data_operations_npp.h 第 76 行定义.

                                                                    {
  NppStatus status;
  NppiSize roi;
  roi.height = src_height;
  roi.width = src_width;
  status = nppiDup_8u_C1C3R(src->gpu_data(), src->width_step(),
                            dst->mutable_gpu_data(), dst->width_step(), roi);
  if (status != NPP_SUCCESS) {
    return false;
  }
  return true;
}

nppImageRemap()

bool apollo::perception::camera::nppImageRemap	(	const base::Image8U &	src_img,
		base::Image8U *	dst_img,
		const int	src_width,
		const int	src_height,
		const base::Blob< float > &	map_x,
		const base::Blob< float > &	map_y
	)

在文件 image_data_operations_npp.h 第 91 行定义.

                                                 {
  NppiInterpolationMode remap_mode = NPPI_INTER_LINEAR;
  NppiSize image_size;
  image_size.width = src_width;
  image_size.height = src_height;
  NppiRect remap_roi = {0, 0, src_width, src_height};
  NppStatus status = NPP_SUCCESS;
  int d_map_step = static_cast<int>(map_x.shape(1) * sizeof(float));
  switch (src_img.channels()) {
    case 1:
      status = nppiRemap_8u_C1R(src_img.gpu_data(), image_size,
                                src_img.width_step(), remap_roi,
                                map_x.gpu_data(), d_map_step, map_y.gpu_data(),
                                d_map_step, dst_img->mutable_gpu_data(),
                                dst_img->width_step(), image_size, remap_mode);
      break;
    case 3:
      status = nppiRemap_8u_C3R(src_img.gpu_data(), image_size,
                                src_img.width_step(), remap_roi,
                                map_x.gpu_data(), d_map_step, map_y.gpu_data(),
                                d_map_step, dst_img->mutable_gpu_data(),
                                dst_img->width_step(), image_size, remap_mode);
      break;
    default:
      AERROR << "Invalid number of channels: " << src_img.channels();
      return false;
  }
  if (status != NPP_SUCCESS) {
    AERROR << "NPP_CHECK_NPP - status = " << status;
    return false;
  }
  return true;
}

nppImageToBlob()

bool apollo::perception::camera::nppImageToBlob	(	const base::Image8U &	image,
		base::Blob< uint8_t > *	blob
	)

在文件 image_data_operations_npp.h 第 22 行定义.

                                                                       {
  NppStatus status;
  NppiSize roi;
  roi.height = image.rows();
  roi.width = image.cols();
  blob->Reshape({1, roi.height, roi.width, image.channels()});
  if (image.channels() == 1) {
    status = nppiCopy_8u_C1R(
        image.gpu_data(), image.width_step(), blob->mutable_gpu_data(),
        blob->count(2) * static_cast<int>(sizeof(uint8_t)), roi);
  } else {
    status = nppiCopy_8u_C3R(
        image.gpu_data(), image.width_step(), blob->mutable_gpu_data(),
        blob->count(2) * static_cast<int>(sizeof(uint8_t)), roi);
  }
  if (status != NPP_SUCCESS) {
    return false;
  }
  return true;
}

nppImageToGray()

bool apollo::perception::camera::nppImageToGray	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const float	coeffs[3]
	)

在文件 image_data_operations_npp.h 第 43 行定义.

                                           {
  NppStatus status;
  NppiSize roi;
  roi.height = src_height;
  roi.width = src_width;
  status = nppiColorToGray_8u_C3C1R(src->gpu_data(), src->width_step(),
                                    dst->mutable_gpu_data(), dst->width_step(),
                                    roi, coeffs);
  if (status != NPP_SUCCESS) {
    return false;
  }
  return true;
}

nppSwapImageChannels()

bool apollo::perception::camera::nppSwapImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const int	order[3]
	)

在文件 image_data_operations_npp.h 第 59 行定义.

                                              {
  NppStatus status;
  NppiSize roi;
  roi.height = src_height;
  roi.width = src_width;
  status = nppiSwapChannels_8u_C3R(src->gpu_data(), src->width_step(),
                                   dst->mutable_gpu_data(), dst->width_step(),
                                   roi, order);
  if (status != NPP_SUCCESS) {
    return false;
  }
  return true;
}

Occlude()

template<typename T >

bool apollo::perception::camera::Occlude	(	const T *	bbox1,
		const T &	h1,
		const T *	bbox2,
		const T &	h2
	)

在文件 twod_threed_util.h 第 127 行定义.

                                                                       {
  T overlap_x = std::min(bbox1[2], bbox2[2]) - std::max(bbox1[0], bbox2[0]);
  T overlap_y = std::min(bbox1[3], bbox2[3]) - std::max(bbox1[1], bbox2[1]);
  if (overlap_y <= (T)0 || overlap_x <= (T)0) {
    return false;
  }
  const T HEIGHT_BIG_MOT = static_cast<T>(3.0f);
  const T OCC_RATIO = (T)0.1f;
  T bh1 = bbox1[3] - bbox1[1];
  T bh2 = bbox2[3] - bbox2[1];
  T inter_area = overlap_x * overlap_y;
  T area = bh2 * (bbox2[2] - bbox2[0]);
  T occ_ratio = inter_area * algorithm::IRec(area);
  T thres_occ_ratio = h2 < HEIGHT_BIG_MOT ? 2 * OCC_RATIO : OCC_RATIO;
  bool occ = occ_ratio > thres_occ_ratio &&
             h1 * algorithm::IRec(bh1) < h2 * algorithm::IRec(bh2);
  return occ;
}

operator<<()

std::ostream & apollo::perception::camera::operator<<	(	std::ostream &	os,
		const CarPose &	pose
	)

在文件 pose.cc 第 60 行定义.

                                                            {
  os << pose.pose_;
  return os;
}

OutOfValidRegion() [1/2]

template<typename T >

bool apollo::perception::camera::OutOfValidRegion	(	const base::BBox2D< T >	box,
		const T	width,
		const T	height,
		const T	border_size = 0
	)

在文件 util.h 第 74 行定义.

                                               {
  if (box.xmin < border_size || box.ymin < border_size) {
    return true;
  }
  if (box.xmax + border_size > width || box.ymax + border_size > height) {
    return true;
  }
  return false;
}

OutOfValidRegion() [2/2]

template<typename T >

bool apollo::perception::camera::OutOfValidRegion	(	const base::Rect< T >	rect,
		const T	width,
		const T	height,
		const T	border_size = 0
	)

在文件 util.h 第 85 行定义.

                                               {
  base::BBox2D<T> box(rect);
  return OutOfValidRegion(box, width, height, border_size);
}

PERCEPTION_REGISTER_CAMERA_PERCEPTION()

apollo::perception::camera::PERCEPTION_REGISTER_CAMERA_PERCEPTION

(

LaneCameraPerception

)

PERCEPTION_REGISTER_CIPV()

apollo::perception::camera::PERCEPTION_REGISTER_CIPV

(

Cipv

)

PERCEPTION_REGISTER_MATCHER()

apollo::perception::camera::PERCEPTION_REGISTER_MATCHER

(

HMMatcher

)

PERCEPTION_REGISTER_REGISTERER() [1/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseCalibrationService

)

PERCEPTION_REGISTER_REGISTERER() [2/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseCalibrator

)

PERCEPTION_REGISTER_REGISTERER() [3/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseCameraPerception

)

PERCEPTION_REGISTER_REGISTERER() [4/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseCipv

)

PERCEPTION_REGISTER_REGISTERER() [5/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseFeatureExtractor

)

PERCEPTION_REGISTER_REGISTERER() [6/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseLaneDetector

)

PERCEPTION_REGISTER_REGISTERER() [7/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseLanePostprocessor

)

PERCEPTION_REGISTER_REGISTERER() [8/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseMatcher

)

PERCEPTION_REGISTER_REGISTERER() [9/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseObstacleDetector

)

PERCEPTION_REGISTER_REGISTERER() [10/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseObstacleTracker

)

PERCEPTION_REGISTER_REGISTERER() [11/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BasePostprocessor

)

PERCEPTION_REGISTER_REGISTERER() [12/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BasePredictor

)

PERCEPTION_REGISTER_REGISTERER() [13/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseTracker

)

PERCEPTION_REGISTER_REGISTERER() [14/14]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER

(

BaseTransformer

)

PERCEPTION_REGISTER_TRACKER()

apollo::perception::camera::PERCEPTION_REGISTER_TRACKER

(

CameraTracker

)

PolyEval()

template<typename Dtype >

bool apollo::perception::camera::PolyEval	(	const Dtype &	x,
		int	order,
		const Eigen::Matrix< Dtype, max_poly_order+1, 1 > &	coeff,
		Dtype *	y
	)

在文件 common_functions.h 第 96 行定义.

                        {
  int poly_order = order;
  if (order > max_poly_order) {
    AERROR << "the order of polynomial function must be smaller than "
           << max_poly_order;
    return false;
  }
 
  *y = static_cast<Dtype>(0);
  for (int j = 0; j <= poly_order; ++j) {
    *y += static_cast<Dtype>(coeff(j) * std::pow(x, j));
  }
 
  return true;
}

PolyFit()

template<typename Dtype >

bool apollo::perception::camera::PolyFit	(	const EigenVector< Eigen::Matrix< Dtype, 2, 1 > > &	pos_vec,
		const int &	order,
		Eigen::Matrix< Dtype, max_poly_order+1, 1 > *	coeff,
		const bool &	is_x_axis = true
	)

在文件 common_functions.h 第 51 行定义.

                                           {
  if (coeff == nullptr) {
    AERROR << "The coefficient pointer is NULL.";
    return false;
  }
 
  if (order > max_poly_order) {
    AERROR << "The order of polynomial must be smaller than " << max_poly_order;
    return false;
  }
 
  int n = static_cast<int>(pos_vec.size());
  if (n <= order) {
    AERROR << "The number of points should be larger than the order. #points = "
           << pos_vec.size();
    return false;
  }
 
  // create data matrix
  Eigen::Matrix<Dtype, Eigen::Dynamic, Eigen::Dynamic> A(n, order + 1);
  Eigen::Matrix<Dtype, Eigen::Dynamic, 1> y(n);
  Eigen::Matrix<Dtype, Eigen::Dynamic, 1> result;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j <= order; ++j) {
      A(i, j) = static_cast<Dtype>(
          std::pow(is_x_axis ? pos_vec[i].x() : pos_vec[i].y(), j));
    }
    y(i) = is_x_axis ? pos_vec[i].y() : pos_vec[i].x();
  }
 
  // solve linear least squares
  result = A.householderQr().solve(y);
  assert(result.size() == order + 1);
 
  for (int j = 0; j <= max_poly_order; ++j) {
    (*coeff)(j) = (j <= order) ? result(j) : static_cast<Dtype>(0);
  }
 
  return true;
}

ProjectBox()

void apollo::perception::camera::ProjectBox	(	const base::BBox2DF &	box_origin,
		const Eigen::Matrix3d &	transform,
		base::BBox2DF *	box_projected
	)

在文件 omt_obstacle_tracker.cc 第 356 行定义.

                                            {
  Eigen::Vector3d point;
  //  top left
  point << box_origin.xmin, box_origin.ymin, 1;
  point = transform * point;
  box_projected->xmin = static_cast<float>(point[0] / point[2]);
  box_projected->ymin = static_cast<float>(point[1] / point[2]);
  //  bottom right
  point << box_origin.xmax, box_origin.ymax, 1;
  point = transform * point;
  box_projected->xmax = static_cast<float>(point[0] / point[2]);
  box_projected->ymax = static_cast<float>(point[1] / point[2]);
}

QSwap_()

template<class T >

void apollo::perception::camera::QSwap_	(	T *	a,
		T *	b
	)

在文件 common_functions.h 第 283 行定义.

                        {
  T temp = *a;
  *a = *b;
  *b = temp;
}

QuickSort() [1/2]

template<class T >

void apollo::perception::camera::QuickSort	(	int *	index,
		const T *	values,
		int	nsize
	)

在文件 common_functions.h 第 340 行定义.

                                                       {
  for (int ii = 0; ii < nsize; ii++) {
    index[ii] = ii;
  }
  QuickSort(index, values, 0, nsize);
}

QuickSort() [2/2]

template<class T >

void apollo::perception::camera::QuickSort	(	int *	index,
		const T *	values,
		int	start,
		int	end
	)

在文件 common_functions.h 第 290 行定义.

                                                                {
  if (start >= end - 1) {
    return;
  }
 
  const T& pivot = values[index[(start + end - 1) / 2]];
  // first, split into two parts: less than the pivot
  // and greater-or-equal
  int lo = start;
  int hi = end;
 
  for (;;) {
    while (lo < hi && values[index[lo]] < pivot) {
      lo++;
    }
    while (lo < hi && values[index[hi - 1]] >= pivot) {
      hi--;
    }
    if (lo == hi || lo == hi - 1) {
      break;
    }
    QSwap_(&(index[lo]), &(index[hi - 1]));
    lo++;
    hi--;
  }
 
  int split1 = lo;
  // now split into two parts: equal to the pivot
  // and strictly greater.
  hi = end;
  for (;;) {
    while (lo < hi && values[index[lo]] == pivot) {
      lo++;
    }
    while (lo < hi && values[index[hi - 1]] > pivot) {
      hi--;
    }
    if (lo == hi || lo == hi - 1) {
      break;
    }
    QSwap_(&(index[lo]), &(index[hi - 1]));
    lo++;
    hi--;
  }
  int split2 = lo;
  QuickSort(index, values, start, split1);
  QuickSort(index, values, split2, end);
}

RansacFitting()

template<typename Dtype >

bool apollo::perception::camera::RansacFitting	(	const EigenVector< Eigen::Matrix< Dtype, 2, 1 > > &	pos_vec,
		EigenVector< Eigen::Matrix< Dtype, 2, 1 > > *	selected_points,
		Eigen::Matrix< Dtype, 4, 1 > *	coeff,
		const int	max_iters = 100,
		const int	N = 5,
		const Dtype	inlier_thres = static_cast<Dtype>(0.1)
	)

在文件 common_functions.h 第 116 行定义.

                                                                       {
  if (coeff == nullptr) {
    AERROR << "The coefficient pointer is NULL.";
    return false;
  }
 
  selected_points->clear();
 
  int n = static_cast<int>(pos_vec.size());
  int q1 = static_cast<int>(n / 4);
  int q2 = static_cast<int>(n / 2);
  int q3 = static_cast<int>(n * 3 / 4);
  if (n < N) {
    AERROR << "The number of points should be larger than the order. #points = "
           << pos_vec.size();
    return false;
  }
 
  std::vector<int> index(3, 0);
  int max_inliers = 0;
  Dtype min_residual = std::numeric_limits<float>::max();
  Dtype early_stop_ratio = 0.95f;
  Dtype good_lane_ratio = 0.666f;
  for (int j = 0; j < max_iters; ++j) {
    index[0] = std::rand() % q2;
    index[1] = q2 + std::rand() % q1;
    index[2] = q3 + std::rand() % q1;
 
    Eigen::Matrix<Dtype, 3, 3> matA;
    matA << pos_vec[index[0]](0) * pos_vec[index[0]](0), pos_vec[index[0]](0),
        1, pos_vec[index[1]](0) * pos_vec[index[1]](0), pos_vec[index[1]](0), 1,
        pos_vec[index[2]](0) * pos_vec[index[2]](0), pos_vec[index[2]](0), 1;
 
    Eigen::FullPivLU<Eigen::Matrix<Dtype, 3, 3>> mat(matA);
    mat.setThreshold(1e-5f);
    if (mat.rank() < 3) {
      ADEBUG << "matA: " << matA;
      ADEBUG << "Matrix is not full rank (3). The rank is: " << mat.rank();
      continue;
    }
 
    // Since Eigen::solver was crashing, simple inverse of 3x3 matrix is used
    // Note that Eigen::inverse of 3x3 and 4x4 is a closed form solution
    Eigen::Matrix<Dtype, 3, 1> matB;
    matB << pos_vec[index[0]](1), pos_vec[index[1]](1), pos_vec[index[2]](1);
    Eigen::Vector3f c =
        static_cast<Eigen::Matrix<Dtype, 3, 1>>(matA.inverse() * matB);
    if (!(matA * c).isApprox(matB)) {
      ADEBUG << "No solution.";
      continue;
    }
 
    int num_inliers = 0;
    Dtype residual = 0;
    Dtype y = 0;
    for (int i = 0; i < n; ++i) {
      y = pos_vec[i](0) * pos_vec[i](0) * c(0) + pos_vec[i](0) * c(1) + c(2);
      if (std::abs(y - pos_vec[i](1)) <= inlier_thres) ++num_inliers;
      residual += std::abs(y - pos_vec[i](1));
    }
 
    if (num_inliers > max_inliers ||
        (num_inliers == max_inliers && residual < min_residual)) {
      (*coeff)(3) = 0;
      (*coeff)(2) = c(0);
      (*coeff)(1) = c(1);
      (*coeff)(0) = c(2);
      max_inliers = num_inliers;
      min_residual = residual;
    }
 
    if (max_inliers > early_stop_ratio * n) break;
  }
 
  if (static_cast<Dtype>(max_inliers) / n < good_lane_ratio) return false;
 
  // EigenVector<Eigen::Matrix<Dtype, 2, 1>> tmp = *pos_vec;
  // pos_vec.clear();
  for (int i = 0; i < n; ++i) {
    Dtype y = pos_vec[i](0) * pos_vec[i](0) * (*coeff)(2) +
              pos_vec[i](0) * (*coeff)(1) + (*coeff)(0);
    if (std::abs(y - pos_vec[i](1)) <= inlier_thres) {
      selected_points->push_back(pos_vec[i]);
    }
  }
  return true;
}

recover_bbox()

void apollo::perception::camera::recover_bbox	(	int	roi_w,
		int	roi_h,
		int	offset_y,
		std::vector< base::ObjectPtr > *	objects
	)

recover detect bbox result to raw image

参数

roi_w	roi width
roi_h	roi height
offset_y	offset y
objects	detection result

在文件 postprocess.cc 第 267 行定义.

                                                     {
  for (auto &obj : *objects) {
    float xmin = obj->camera_supplement.box.xmin;
    float ymin = obj->camera_supplement.box.ymin;
    float xmax = obj->camera_supplement.box.xmax;
    float ymax = obj->camera_supplement.box.ymax;
    int x = static_cast<int>(xmin * static_cast<float>(roi_w));
    int w = static_cast<int>((xmax - xmin) * static_cast<float>(roi_w));
    int y = static_cast<int>(ymin * static_cast<float>(roi_h)) + offset_y;
    int h = static_cast<int>((ymax - ymin) * static_cast<float>(roi_h));
    base::RectF rect_det(static_cast<float>(x), static_cast<float>(y),
                         static_cast<float>(w), static_cast<float>(h));
    base::RectF rect_img(0, 0, static_cast<float>(roi_w),
                         static_cast<float>(roi_h + offset_y));
    base::RectF rect = rect_det & rect_img;
    obj->camera_supplement.box = rect;
 
    double eps = 1e-2;
 
    // Truncation assignment based on bbox positions
    if ((ymin < eps) || (ymax >= 1.0 - eps)) {
      obj->camera_supplement.truncated_vertical = 0.5;
    } else {
      obj->camera_supplement.truncated_vertical = 0.0;
    }
    if ((xmin < eps) || (xmax >= 1.0 - eps)) {
      obj->camera_supplement.truncated_horizontal = 0.5;
    } else {
      obj->camera_supplement.truncated_horizontal = 0.0;
    }
 
    obj->camera_supplement.front_box.xmin *= static_cast<float>(roi_w);
    obj->camera_supplement.front_box.ymin *= static_cast<float>(roi_h);
    obj->camera_supplement.front_box.xmax *= static_cast<float>(roi_w);
    obj->camera_supplement.front_box.ymax *= static_cast<float>(roi_h);
 
    obj->camera_supplement.back_box.xmin *= static_cast<float>(roi_w);
    obj->camera_supplement.back_box.ymin *= static_cast<float>(roi_h);
    obj->camera_supplement.back_box.xmax *= static_cast<float>(roi_w);
    obj->camera_supplement.back_box.ymax *= static_cast<float>(roi_h);
 
    obj->camera_supplement.front_box.ymin += static_cast<float>(offset_y);
    obj->camera_supplement.front_box.ymax += static_cast<float>(offset_y);
    obj->camera_supplement.back_box.ymin += static_cast<float>(offset_y);
    obj->camera_supplement.back_box.ymax += static_cast<float>(offset_y);
  }
}

RecoverBBox()

void apollo::perception::camera::RecoverBBox	(	int	roi_w,
		int	roi_h,
		int	offset_y,
		std::vector< base::ObjectPtr > *	objects
	)

在文件 postprocess.cc 第 48 行定义.

                                                    {
  for (auto &obj : *objects) {
    float xmin = obj->camera_supplement.box.xmin;
    float ymin = obj->camera_supplement.box.ymin;
    float xmax = obj->camera_supplement.box.xmax;
    float ymax = obj->camera_supplement.box.ymax;
 
    float x = xmin * roi_w;
    float w = (xmax - xmin) * roi_w;
    float y = ymin * roi_h + offset_y;
    float h = (ymax - ymin) * roi_h;
    base::RectF rect_det(x, y, w, h);
    base::RectF rect_img(0, 0, roi_w, roi_h + offset_y);
    obj->camera_supplement.box = rect_det & rect_img;
 
    constexpr double eps = 1e-2;
    // Truncation assignment based on bbox positions
    if ((ymin < eps) || (ymax >= (1.0 - eps))) {
      obj->camera_supplement.truncated_vertical = 0.5;
    } else {
      obj->camera_supplement.truncated_vertical = 0.0;
    }
 
    if ((xmin < eps) || (xmax >= (1.0 - eps))) {
      obj->camera_supplement.truncated_horizontal = 0.5;
    } else {
      obj->camera_supplement.truncated_horizontal = 0.0;
    }
  }
}

RecoveryImage()

bool apollo::perception::camera::RecoveryImage	(	onboard::CameraFrame *	frame,
		cv::Mat *	cv_img
	)

Recovery cv image from frame->data_provider

参数

frame	onboard::CameraFrame
cv_img	cv image

返回

true

false

在文件 util.cc 第 46 行定义.

                                                             {
  DataProvider::ImageOptions image_options;
  image_options.target_color = base::Color::BGR;
  image_options.do_crop = false;
  base::Image8U image(frame->data_provider->src_height(),
                      frame->data_provider->src_width(), base::Color::RGB);
  frame->data_provider->GetImage(image_options, &image);
 
  memcpy(cv_img->data, image.cpu_data(), image.total() * sizeof(uint8_t));
  return true;
}

RefineBox() [1/2]

template<typename T >

void apollo::perception::camera::RefineBox	(	const base::BBox2D< T > &	box_in,
		const T	width,
		const T	height,
		base::BBox2D< T > *	box_out
	)

在文件 util.h 第 128 行定义.

                                       {
  if (!box_out) {
    return;
  }
  base::Rect<T> rect;
  RefineBox(base::Rect<T>(box_in), width, height, &rect);
  *box_out = base::BBox2D<T>(rect);
}

RefineBox() [2/2]

template<typename T >

void apollo::perception::camera::RefineBox	(	const base::Rect< T > &	box_in,
		const T	width,
		const T	height,
		base::Rect< T > *	box_out
	)

在文件 util.h 第 92 行定义.

                                     {
  if (!box_out) {
    return;
  }
  *box_out = box_in;
  if (box_out->x < 0) {
    box_out->width += box_out->x;
    box_out->x = 0;
  }
  if (box_out->y < 0) {
    box_out->height += box_out->y;
    box_out->y = 0;
  }
  if (box_out->x >= width) {
    box_out->x = 0;
    box_out->width = 0;
  }
  if (box_out->y >= height) {
    box_out->y = 0;
    box_out->height = 0;
  }
  box_out->width = (box_out->x + box_out->width <= width) ? box_out->width
                                                          : width - box_out->x;
  box_out->height = (box_out->y + box_out->height <= height)
                        ? box_out->height
                        : height - box_out->y;
  if (box_out->width < 0) {
    box_out->width = 0;
  }
  if (box_out->height < 0) {
    box_out->height = 0;
  }
}

REGISTER_CALIBRATION_SERVICE()

apollo::perception::camera::REGISTER_CALIBRATION_SERVICE

(

OnlineCalibrationService

)

REGISTER_CALIBRATOR()

apollo::perception::camera::REGISTER_CALIBRATOR

(

LaneLineCalibrator

)

REGISTER_FEATURE_EXTRACTOR() [1/3]

apollo::perception::camera::REGISTER_FEATURE_EXTRACTOR

(

ExternalFeatureExtractor

)

REGISTER_FEATURE_EXTRACTOR() [2/3]

apollo::perception::camera::REGISTER_FEATURE_EXTRACTOR

(

ProjectFeature

)

REGISTER_FEATURE_EXTRACTOR() [3/3]

apollo::perception::camera::REGISTER_FEATURE_EXTRACTOR

(

TrackingFeatureExtractor

)

REGISTER_LANE_DETECTOR() [1/2]

apollo::perception::camera::REGISTER_LANE_DETECTOR

(

DarkSCNNLaneDetector

)

REGISTER_LANE_DETECTOR() [2/2]

apollo::perception::camera::REGISTER_LANE_DETECTOR

(

DenselineLaneDetector

)

REGISTER_LANE_POSTPROCESSOR() [1/2]

apollo::perception::camera::REGISTER_LANE_POSTPROCESSOR

(

DarkSCNNLanePostprocessor

)

REGISTER_LANE_POSTPROCESSOR() [2/2]

apollo::perception::camera::REGISTER_LANE_POSTPROCESSOR

(

DenselineLanePostprocessor

)

REGISTER_OBSTACLE_DETECTOR() [1/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

BEVFORMERObstacleDetector

)

REGISTER_OBSTACLE_DETECTOR() [2/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

BEVObstacleDetector

)

REGISTER_OBSTACLE_DETECTOR() [3/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

CaddnObstacleDetector

)

REGISTER_OBSTACLE_DETECTOR() [4/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

SmokeObstacleDetector

)

REGISTER_OBSTACLE_DETECTOR() [5/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

YoloObstacleDetector

)

REGISTER_OBSTACLE_DETECTOR() [6/6]

apollo::perception::camera::REGISTER_OBSTACLE_DETECTOR

(

Yolox3DObstacleDetector

)

REGISTER_OBSTACLE_POSTPROCESSOR()

apollo::perception::camera::REGISTER_OBSTACLE_POSTPROCESSOR

(

LocationRefinerPostprocessor

)

REGISTER_OBSTACLE_TRACKER()

apollo::perception::camera::REGISTER_OBSTACLE_TRACKER

(

OMTObstacleTracker

)

REGISTER_OBSTACLE_TRANSFORMER() [1/2]

apollo::perception::camera::REGISTER_OBSTACLE_TRANSFORMER

(

MultiCueTransformer

)

REGISTER_OBSTACLE_TRANSFORMER() [2/2]

apollo::perception::camera::REGISTER_OBSTACLE_TRANSFORMER

(

SingleStageTransformer

)

remap_pkd3_kernel()

__global__ void apollo::perception::camera::remap_pkd3_kernel	(	const uchar3 *	src,
		size_t	src_width_step,
		uchar3 *	dst,
		size_t	dst_width_step,
		const float *	mapx,
		const float *	mapy,
		int	width,
		int	height
	)

在文件 image_data_operations_rpp.h 第 228 行定义.

                                                         {
  const size_t i = hipBlockDim_x * hipBlockIdx_x + hipThreadIdx_x;
  const size_t j = hipBlockDim_y * hipBlockIdx_y + hipThreadIdx_y;
 
  image2D<uchar3> src_img{src, src_width_step};
  image2D<uchar3> dst_img{dst, dst_width_step};
 
  if (i < width && j < height) {
    float x_coor = mapx[j * width + i];
    float y_coor = mapy[j * width + i];
 
    int X = trunc(x_coor);
    int Y = trunc(y_coor);
    float x_frac = x_coor - X;
    float y_frac = y_coor - Y;
 
    if (0 <= X && X < width && 0 <= Y && Y < height) {
      // uchar3 p[2][2];
      int X1 = (X < width - 1) ? X + 1 : X;
      int Y1 = (Y < height - 1) ? Y + 1 : Y;
 
      uchar3 pixel00 = src_img(X, Y);
      uchar3 pixel01 = src_img(X1, Y);
      uchar3 pixel10 = src_img(X, Y1);
      uchar3 pixel11 = src_img(X1, Y1);
      // bilinear interpolation
      uchar3 interpolated;
      interpolated.x =
          (pixel00.x * (1 - x_frac) + pixel01.x * x_frac) * (1 - y_frac) +
          (pixel10.x * (1 - x_frac) + pixel11.x * x_frac) * y_frac;
      interpolated.y =
          (pixel00.y * (1 - x_frac) + pixel01.y * x_frac) * (1 - y_frac) +
          (pixel10.y * (1 - x_frac) + pixel11.y * x_frac) * y_frac;
      interpolated.z =
          (pixel00.z * (1 - x_frac) + pixel01.z * x_frac) * (1 - y_frac) +
          (pixel10.z * (1 - x_frac) + pixel11.z * x_frac) * y_frac;
 
      dst_img(i, j) = interpolated;
    }
  }
}

remap_pln1_kernel()

__global__ void apollo::perception::camera::remap_pln1_kernel	(	const unsigned char *	src,
		size_t	src_width_step,
		unsigned char *	dst,
		size_t	dst_width_step,
		const float *	mapx,
		const float *	mapy,
		int	width,
		int	height
	)

在文件 image_data_operations_rpp.h 第 193 行定义.

                                                                            {
  const size_t i = hipBlockDim_x * hipBlockIdx_x + hipThreadIdx_x;
  const size_t j = hipBlockDim_y * hipBlockIdx_y + hipThreadIdx_y;
  image2D<unsigned char> src_img{src, src_width_step};
  image2D<unsigned char> dst_img{dst, dst_width_step};
  if (i < width && j < height) {
    float x_coor = mapx[j * width + i];
    float y_coor = mapy[j * width + i];
 
    int X = trunc(x_coor);
    int Y = trunc(y_coor);
    float x_frac = x_coor - X;
    float y_frac = y_coor - Y;
 
    if (0 <= X && X < width && 0 <= Y && Y < height) {
      // uchar p[2][2];
      int X1 = (X < width - 1) ? X + 1 : X;
      int Y1 = (Y < height - 1) ? Y + 1 : Y;
 
      unsigned char pixel00 = src_img(X, Y);
      unsigned char pixel01 = src_img(X1, Y);
      unsigned char pixel10 = src_img(X, Y1);
      unsigned char pixel11 = src_img(X1, Y1);
      // bilinear interpolation
      unsigned char interpolated =
          (pixel00 * (1 - x_frac) + pixel01 * x_frac) * (1 - y_frac) +
          (pixel10 * (1 - x_frac) + pixel11 * x_frac) * y_frac;
      dst_img(i, j) = interpolated;
    }
  }
}

Resize() [1/3]

void apollo::perception::camera::Resize	(	const cv::Mat &	input_img,
		cv::Mat *	out_img,
		cv::Size	size,
		double	fx = 0,
		double	fy = 0,
		int	interpolation = cv::INTER_LINEAR
	)

Resize() [2/3]

void apollo::perception::camera::Resize	(	const cv::Mat &	input_img,
		cv::Mat *	out_img,
		int	width,
		int	height,
		double	fx,
		double	fy,
		int	interpolation
	)

在文件 camera_preprocess_general_util.cc 第 40 行定义.

                                                     {
  ACHECK(nullptr != out_img);
  cv::resize(input_img, *out_img, cv::Size(width, height), fx, fy,
             interpolation);
}

Resize() [3/3]

void apollo::perception::camera::Resize	(	cv::Mat *	img,
		cv::Mat *	img_n,
		int	width,
		int	height
	)

Image resize function

参数

img	The image to be resized.
width	The width of the image.
height	The height of the image.

在文件 preprocess.cc 第 24 行定义.

                                                             {
  cv::resize(*img, *img_n, cv::Size(width, height));
}

ResizeCPU()

bool apollo::perception::camera::ResizeCPU	(	const base::Blob< uint8_t > &	src_blob,
		std::shared_ptr< base::Blob< float > >	dst_blob,
		int	stepwidth,
		int	start_axis
	)

在文件 util.cc 第 87 行定义.

                               {
  int width = dst_blob->shape(2);
  int height = dst_blob->shape(1);
  int channel = dst_blob->shape(3);
  int origin_channel = src_blob.shape(3);
  int origin_height = src_blob.shape(1);
  int origin_width = src_blob.shape(2);
  if (origin_channel != dst_blob->shape(3)) {
    AERROR << "channel should be the same after resize.";
    return false;
  }
  float fx = static_cast<float>(origin_width) / static_cast<float>(width);
  float fy = static_cast<float>(origin_height) / static_cast<float>(height);
  auto src = src_blob.cpu_data();
  auto dst = dst_blob->mutable_cpu_data();
  for (int dst_y = 0; dst_y < height; dst_y++) {
    for (int dst_x = 0; dst_x < width; dst_x++) {
      float src_x = (static_cast<float>(dst_x) + 0.5f) * fx - 0.5f;
      float src_y = (static_cast<float>(dst_y) + 0.5f) * fy - 0.5f;
      const int x1 = static_cast<int>(src_x + 0.5);
      const int y1 = static_cast<int>(src_y + 0.5);
      const int x1_read = std::max(x1, 0);
      const int y1_read = std::max(y1, 0);
      const int x2 = x1 + 1;
      const int y2 = y1 + 1;
      const int x2_read = std::min(x2, width - 1);
      const int y2_read = std::min(y2, height - 1);
      int src_reg = 0;
      for (int c = 0; c < channel; c++) {
        float out = 0.0f;
 
        int idx11 = (y1_read * stepwidth + x1_read) * channel;
        src_reg = src[idx11 + c];
        out = out + (static_cast<float>(x2) - src_x) *
                        (static_cast<float>(y2) - src_y) *
                        static_cast<float>(src_reg);
        int idx12 = (y1_read * stepwidth + x2_read) * channel;
        src_reg = src[idx12 + c];
        out = out + static_cast<float>(src_reg) *
                        (src_x - static_cast<float>(x1)) *
                        (static_cast<float>(y2) - src_y);
 
        int idx21 = (y2_read * stepwidth + x1_read) * channel;
        src_reg = src[idx21 + c];
        out = out + static_cast<float>(src_reg) *
                        (static_cast<float>(x2) - src_x) *
                        (src_y - static_cast<float>(y1));
 
        int idx22 = (y2_read * stepwidth + x2_read) * channel;
        src_reg = src[idx22 + c];
        out = out + static_cast<float>(src_reg) *
                        (src_x - static_cast<float>(x1)) *
                        (src_y - static_cast<float>(y1));
        if (out < 0) {
          out = 0;
        }
        if (out > 255) {
          out = 255;
        }
        int dst_idx = (dst_y * width + dst_x) * channel + c;
        //   printf("%f %d %d %d %d\n",out,x1,y1,x2,y2);
        dst[dst_idx] = out;
      }
    }
  }
  return true;
}

resizeKeepAspectRatioYolox()

cv::Mat apollo::perception::camera::resizeKeepAspectRatioYolox	(	const cv::Mat &	input,
		const cv::Size &	dstSize,
		const cv::Scalar &	bgcolor
	)

在文件 yolox3d_obstacle_detector.cc 第 120 行定义.

                                                            {
  cv::Mat output;
 
  double h1 = dstSize.width * (input.rows / static_cast<double>(input.cols));
  double w2 = dstSize.height * (input.cols / static_cast<double>(input.rows));
  if (h1 <= dstSize.height) {
    cv::resize(input, output, cv::Size(dstSize.width, h1));
  } else {
    cv::resize(input, output, cv::Size(w2, dstSize.height));
  }
 
  int top = (dstSize.height - output.rows) / 2;
  int down = (dstSize.height - output.rows + 1) / 2;
  int left = (dstSize.width - output.cols) / 2;
  int right = (dstSize.width - output.cols + 1) / 2;
 
  cv::copyMakeBorder(output, output, top, down, left, right,
                     cv::BORDER_CONSTANT, bgcolor);
 
  return output;
}

rppDupImageChannels()

bool apollo::perception::camera::rppDupImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height
	)

在文件 image_data_operations_rpp.h 第 176 行定义.

                                                                    {
  dim3 threadsPerBlock(THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y);
  dim3 blocks((src_width + threadsPerBlock.x - 1) / threadsPerBlock.x,
              (src_height + threadsPerBlock.y - 1) / threadsPerBlock.y);
 
  hipLaunchKernelGGL(duplicate_kernel, blocks, threadsPerBlock, 0, 0,
                     src->gpu_data(), src->width_step(),
                     reinterpret_cast<uchar3 *>(dst->mutable_gpu_data()),
                     dst->width_step(), src_width, src_height);
 
  if (hipSuccess != hipGetLastError())
    return false;
  return true;
}

rppImageRemap()

bool apollo::perception::camera::rppImageRemap	(	const base::Image8U &	src_img,
		base::Image8U *	dst_img,
		const int	src_width,
		const int	src_height,
		const base::Blob< float > &	map_x,
		const base::Blob< float > &	map_y
	)

在文件 image_data_operations_rpp.h 第 273 行定义.

                                                 {
  dim3 threadsPerBlock(THREADS_PER_BLOCK_X, THREADS_PER_BLOCK_Y);
  dim3 blocks((src_width + threadsPerBlock.x - 1) / threadsPerBlock.x,
              (src_height + threadsPerBlock.y - 1) / threadsPerBlock.y);
 
  switch (src_img.channels()) {
    case 1:
      hipLaunchKernelGGL(remap_pln1_kernel, blocks, threadsPerBlock, 0, 0,
                         src_img.gpu_data(), src_img.width_step(),
                         dst_img->mutable_gpu_data(), dst_img->width_step(),
                         map_x.gpu_data(), map_y.gpu_data(), src_width,
                         src_height);
      break;
    case 3:
      hipLaunchKernelGGL(
          remap_pkd3_kernel, blocks, threadsPerBlock, 0, 0,
          reinterpret_cast<const uchar3 *>(src_img.gpu_data()),
          src_img.width_step(),
          reinterpret_cast<uchar3 *>(dst_img->mutable_gpu_data()),
          dst_img->width_step(), map_x.gpu_data(), map_y.gpu_data(), src_width,
          src_height);
      break;
    default:
      AERROR << "Invalid number of channels: " << src_img.channels()
             << "; only 1 and 3 are supported.";
      return false;
  }
  if (hipSuccess != hipGetLastError())
    return false;
  return true;
}

rppImageToBlob()

bool apollo::perception::camera::rppImageToBlob	(	const base::Image8U &	image,
		base::Blob< uint8_t > *	blob
	)

在文件 image_data_operations_rpp.h 第 74 行定义.

                                                                       {
  RpptDesc srcDesc, dstDesc;
  RpptDescPtr srcDescPtr = &srcDesc, dstDescPtr = &dstDesc;
 
  blob->Reshape({1, image.rows(), image.cols(), image.channels()});
 
  if (!rppInitDescriptor(srcDescPtr, image.cols(), image.rows(),
                         image.channels(), image.width_step()))
    return false;
  if (!rppInitDescriptor(dstDescPtr, image.cols(), image.rows(), image.channels(),
                         blob->count(2) * static_cast<int>(sizeof(uint8_t))))
    return false;
 
  rppHandle_t handle;
  rppCreateWithBatchSize(&handle, 1);
  RppStatus status =
    rppt_copy_gpu((const_cast<base::Image8U &>(image)).mutable_gpu_data(),
                  srcDescPtr, blob->mutable_gpu_data(), dstDescPtr, handle);
  if (status != RPP_SUCCESS)
    return false;
  return true;
}

rppImageToGray()

bool apollo::perception::camera::rppImageToGray	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const float	coeffs[3]
	)

在文件 image_data_operations_rpp.h 第 97 行定义.

                                           {
  RppStatus status = RPP_SUCCESS;
  RpptDesc srcDesc, dstDesc;
  RpptDescPtr srcDescPtr = &srcDesc, dstDescPtr = &dstDesc;
 
  if (!rppInitDescriptor(srcDescPtr, src_width, src_height, 3,
                         src->width_step()))
    return false;
  if (!rppInitDescriptor(dstDescPtr, src_width, src_height, 1,
                         dst->width_step()))
    return false;
 
  rppHandle_t handle;
  rppCreateWithBatchSize(&handle, 1);
  assert((coeffs[1] == 0.587f) &&
         ((coeffs[0] == 0.114f && coeffs[2] == 0.299f) ||
          (coeffs[0] == 0.299f && coeffs[2] == 0.114f)) &&
         "coefficients in rppt_color_to_greyscale_gpu are hardcoded");
  // BGR: float coeffs[] = {0.114f, 0.587f, 0.299f};
  if (coeffs[0] == 0.114f && coeffs[1] == 0.587f && coeffs[2] == 0.299f) {
    status = rppt_color_to_greyscale_gpu(src->mutable_gpu_data(), srcDescPtr,
                                         dst->mutable_gpu_data(), dstDescPtr,
                                         RpptSubpixelLayout::BGRtype, handle);
  }
  // RGB: float coeffs[] = {0.299f, 0.587f, 0.114f};
  if (coeffs[0] == 0.299f && coeffs[1] == 0.587f && coeffs[2] == 0.114f) {
    status = rppt_color_to_greyscale_gpu(src->mutable_gpu_data(), srcDescPtr,
                                         dst->mutable_gpu_data(), dstDescPtr,
                                         RpptSubpixelLayout::RGBtype, handle);
  }
  if (status != RPP_SUCCESS)
    return false;
  return true;
}

rppInitDescriptor()

bool apollo::perception::camera::rppInitDescriptor	(	RpptDescPtr &	descPtr,
		int	width,
		int	height,
		int	channels,
		int	width_step
	)

在文件 image_data_operations_rpp.h 第 41 行定义.

                                                     {
  descPtr->dataType = RpptDataType::U8;
  descPtr->numDims = 4;
  descPtr->offsetInBytes = 0;
  descPtr->n = 1;
  descPtr->h = height;
  descPtr->w = width;
  descPtr->c = channels;
  switch (channels) {
    case 1:
      descPtr->layout = RpptLayout::NCHW;
      descPtr->strides.wStride = 1;
      descPtr->strides.hStride = width_step;
      descPtr->strides.cStride = descPtr->strides.hStride * descPtr->h;
      descPtr->strides.nStride =
          descPtr->strides.hStride * descPtr->h * descPtr->c;
      break;
    case 3:
      descPtr->layout = RpptLayout::NHWC;
      descPtr->strides.cStride = 1;
      descPtr->strides.wStride = descPtr->c;
      descPtr->strides.hStride = width_step;
      descPtr->strides.nStride = descPtr->strides.hStride * descPtr->h;
      break;
    default:
      AERROR << "Invalid number of channels: " << channels
             << "; only 1 and 3 are supported.";
      return false;
  }
  return true;
}

rppSwapImageChannels()

bool apollo::perception::camera::rppSwapImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const int	order[3]
	)

在文件 image_data_operations_rpp.h 第 134 行定义.

                                              {
  RpptDesc srcDesc, dstDesc;
  RpptDescPtr srcDescPtr = &srcDesc, dstDescPtr = &dstDesc;
 
  if (!rppInitDescriptor(srcDescPtr, src_width, src_height, 3,
                         src->width_step()))
    return false;
  if (!rppInitDescriptor(dstDescPtr, src_width, src_height, 3,
                         dst->width_step()))
    return false;
 
  rppHandle_t handle;
  rppCreateWithBatchSize(&handle, 1);
  assert(order[0] == 2 && order[1] == 1 && order[2] == 0 &&
         "The order in rppt_swap_channels is hardcoded");
  RppStatus status =
      rppt_swap_channels_gpu(src->mutable_gpu_data(), srcDescPtr,
                             dst->mutable_gpu_data(), dstDescPtr, handle);
  if (status != RPP_SUCCESS)
    return false;
  return true;
}

SaveCameraDetectionResult()

bool apollo::perception::camera::SaveCameraDetectionResult	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

Save detection result to file_name

参数

frame	onboard::CameraFrame
file_name	result file

返回

true

false

在文件 util.cc 第 84 行定义.

                                                           {
  FILE* fp = fopen(file_name.c_str(), "w");
  if (fp == nullptr) {
    AERROR << "Failed to open result file: " << file_name;
    return false;
  }
 
  for (auto obj : frame->detected_objects) {
    auto& supp = obj->camera_supplement;
    fprintf(fp,
            "%s 0 0 %6.3f %8.2f %8.2f %8.2f %8.2f %6.3f %6.3f %6.3f "
            "%6.3f %6.3f %6.3f %6.3f %6.3f "
            "%4d %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f\n",
            base::kSubType2NameMap.at(obj->sub_type).c_str(), supp.alpha,
            supp.box.xmin, supp.box.ymin, supp.box.xmax, supp.box.ymax,
            obj->size[2], obj->size[1], obj->size[0], obj->center[0],
            obj->center[1] + obj->size[2] * .5, obj->center[2],
            supp.alpha + atan2(obj->center[0], obj->center[2]),
            obj->type_probs[static_cast<int>(obj->type)], supp.area_id,
            supp.visible_ratios[0], supp.visible_ratios[1],
            supp.visible_ratios[2], supp.visible_ratios[3],
            supp.cut_off_ratios[0], supp.cut_off_ratios[1],
            supp.cut_off_ratios[2], supp.cut_off_ratios[3]);
  }
 
  fclose(fp);
  return true;
}

SaveLaneDetectionResult()

bool apollo::perception::camera::SaveLaneDetectionResult	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

在文件 util.cc 第 119 行定义.

                                                         {
  return true;
}

SaveTfDetectionResult()

bool apollo::perception::camera::SaveTfDetectionResult	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

在文件 util.cc 第 114 行定义.

                                                       {
  return true;
}

SetSceneFlowLabel()

void apollo::perception::camera::SetSceneFlowLabel ( PointSemanticLabel  label, uint8_t *  value  )

inline

在文件 utils.h 第 42 行定义.

                                                                        {
  *value &= 15;  // 15: 00001111
  *value = (static_cast<uint8_t>(label) << 4) | (*value);
}

SetSemanticLabel()

void apollo::perception::camera::SetSemanticLabel ( PointSemanticLabel  label, uint8_t *  value  )

inline

在文件 utils.h 第 28 行定义.

                                                                       {
  *value &= 240;  // 240: 11110000
  *value |= static_cast<uint8_t>(label);
}

sigmoid()

template<typename Dtype >

Dtype apollo::perception::camera::sigmoid ( Dtype  x )

inline

在文件 math_functions.h 第 25 行定义.

                              {
  return static_cast<Dtype>(1.0) /
         static_cast<Dtype>(1.0 + exp(static_cast<double>(-x)));
}

sigmoid_gpu()

__host__ __device__ float apollo::perception::camera::sigmoid_gpu

(

float

x

)

sort_score_pair_descend()

template<typename T >

bool apollo::perception::camera::sort_score_pair_descend	(	const std::pair< float, T > &	pair1,
		const std::pair< float, T > &	pair2
	)

在文件 postprocess.h 第 135 行定义.

                                                             {
  return pair1.first > pair2.first;
}

spatialLUT()

std::vector< base::LaneLinePositionType > apollo::perception::camera::spatialLUT

(

{base::LaneLinePositionType::UNKNOWN, base::LaneLinePositionType::FOURTH_LEFT, base::LaneLinePositionType::THIRD_LEFT, base::LaneLinePositionType::ADJACENT_LEFT, base::LaneLinePositionType::EGO_LEFT, base::LaneLinePositionType::EGO_CENTER, base::LaneLinePositionType::EGO_RIGHT, base::LaneLinePositionType::ADJACENT_RIGHT, base::LaneLinePositionType::THIRD_RIGHT, base::LaneLinePositionType::FOURTH_RIGHT, base::LaneLinePositionType::OTHER, base::LaneLinePositionType::CURB_LEFT, base::LaneLinePositionType::CURB_RIGHT}

)

sqr()

template<typename Dtype >

Dtype apollo::perception::camera::sqr

(

Dtype

x

)

在文件 math_functions.h 第 35 行定义.

                   {
  return x * x;
}

swapImageChannels()

bool apollo::perception::camera::swapImageChannels	(	const base::Image8UPtr &	src,
		const base::Image8UPtr &	dst,
		const int	src_width,
		const int	src_height,
		const int	order[3]
	)

在文件 image_data_operations.cc 第 49 行定义.

                                           {
  return nppSwapImageChannels(src, dst, src_width, src_height, order);
}

TestDetection()

bool apollo::perception::camera::TestDetection

(

)

在文件 offline_camera_detection.cc 第 64 行定义.

                     {
  // Init frame
  onboard::CameraFrame camera_frame;
  camera_frame.data_provider.reset(new DataProvider());
  camera_frame.feature_blob.reset(new base::Blob<float>());
 
  // Init data
  ACHECK(InitDataProvider(&camera_frame));
 
  ObstacleDetectorInitOptions init_options;
  // Init conf file
  init_options.config_path = FLAGS_config_path;
  init_options.config_file = FLAGS_config_file;
  init_options.gpu_id = FLAGS_gpu_id;
 
  // Init camera params
  std::string camera_name = FLAGS_camera_name;
  base::BaseCameraModelPtr model =
      algorithm::SensorManager::Instance()->GetUndistortCameraModel(
          camera_name);
  ACHECK(model) << "Can't find " << camera_name
                << " in data/conf/sensor_meta.pb.txt";
  auto pinhole = static_cast<base::PinholeCameraModel*>(model.get());
  init_options.intrinsic = pinhole->get_intrinsic_params();
  camera_frame.camera_k_matrix = pinhole->get_intrinsic_params();
  init_options.image_height = model->get_height();
  init_options.image_width = model->get_width();
  // Init detection pipeline
  std::shared_ptr<BaseObstacleDetector> detector;
  detector.reset(
      BaseObstacleDetectorRegisterer::GetInstanceByName(FLAGS_detector_name));
  detector->Init(init_options);
 
  // Load image list
  std::string images_path = FLAGS_root_dir + "/images/";
  std::vector<std::string> img_file_names;
  if (!algorithm::GetFileList(images_path, ".jpg", &img_file_names)) {
    AERROR << "images_path: " << images_path << " get file list error.";
    return false;
  }
 
  std::sort(img_file_names.begin(), img_file_names.end(),
            [](const std::string& lhs, const std::string& rhs) {
              if (lhs.length() != rhs.length()) {
                return lhs.length() < rhs.length();
              }
              return lhs <= rhs;
            });
 
  // Main process
  for (const auto& img_file : img_file_names) {
    AINFO << "img_file: " << img_file;
 
    std::string image_name = cyber::common::GetFileName(img_file, true);
 
    if (FLAGS_kitti_dir != "") {
      std::string kitti_path = FLAGS_kitti_dir + "/" + image_name + ".txt";
 
      if (!LoadKittiLabel(&camera_frame, kitti_path, FLAGS_dist_type)) {
        AERROR << "Loading kitti result failed: " << kitti_path;
        continue;
      }
    } else {
      ACHECK(FillImage(&camera_frame, img_file));
      ACHECK(detector->Detect(&camera_frame));
    }
 
    // Results visualization
    if (!cyber::common::EnsureDirectory(FLAGS_dest_dir)) {
      AERROR << "Failed to create: " << FLAGS_dest_dir;
      return false;
    }
 
    std::string result_path = FLAGS_dest_dir + "/" + image_name + ".txt";
    ACHECK(SaveCameraDetectionResult(&camera_frame, result_path));
 
    result_path = FLAGS_dest_dir + "/" + image_name + ".jpg";
    ACHECK(CameraVisualization(&camera_frame, result_path));
  }
 
  return true;
}

TfVisualization()

bool apollo::perception::camera::TfVisualization	(	onboard::CameraFrame *	frame,
		const std::string &	file_name
	)

在文件 visualizer.cc 第 114 行定义.

                                                 {
  return true;
}

UpdateOffsetZ()

template<typename T >

void apollo::perception::camera::UpdateOffsetZ	(	T	x_start,
		T	z_start,
		T	x_end,
		T	z_end,
		const std::pair< T, T > &	range,
		T *	z_offset
	)

在文件 twod_threed_util.h 第 252 行定义.

                                                            {
  ACHECK(range.first < range.second);
  if (x_start > x_end) {
    std::swap(x_start, x_end);
    std::swap(z_start, z_end);
  }
 
  T x_check_l = std::max(x_start, range.first);
  T x_check_r = std::min(x_end, range.second);
  T overlap_x = x_check_r - x_check_l;
  if (overlap_x < 1e-6) {
    return;
  }
 
  T dz_divide_dx = (z_end - z_start) * algorithm::IRec(x_end - x_start);
  T z_check_l = z_start + (x_check_l - x_start) * dz_divide_dx;
  T z_check_r = z_start + (x_check_r - x_start) * dz_divide_dx;
  T z_nearest = std::min(z_check_l, z_check_r);
  if (z_nearest < *z_offset) {
    *z_offset = z_nearest;
  }
}

WriteCalibrationOutput()

int apollo::perception::camera::WriteCalibrationOutput	(	bool	enabled,
		const std::string &	out_path,
		const CameraFrame *	frame
	)

在文件 debug_info.cc 第 106 行定义.

                                                     {
  if (!enabled) {
    return -1;
  }
  float pitch_angle = 0.f;
  float camera_ground_height = 0.f;
  if (!frame->calibration_service->QueryCameraToGroundHeightAndPitchAngle(
          &camera_ground_height, &pitch_angle)) {
    AERROR << "Failed to query camera to ground height and pitch.";
    return -1;
  }
 
  FILE *file_save = fopen(out_path.data(), "wt");
  if (file_save == nullptr) {
    AERROR << "Failed to open output path: " << out_path.data();
    return -1;
  }
  fprintf(file_save, "camera_ground_height:\t%f\n", camera_ground_height);
  fprintf(file_save, "pitch_angle:\t%f\n", pitch_angle);
  fclose(file_save);
  return 0;
}

WriteLanelines()

int apollo::perception::camera::WriteLanelines	(	const bool	enabled,
		const std::string &	save_path,
		const std::vector< base::LaneLine > &	lane_objects
	)

在文件 debug_info.cc 第 28 行定义.

                                                                {
  if (!enabled) {
    return -1;
  }
  FILE *file_save = fopen(save_path.data(), "wt");
  if (file_save == nullptr) {
    AERROR << "Failed to open lane save path: " << save_path;
    return -1;
  }
  int lane_line_size = static_cast<int>(lane_objects.size());
  AINFO << "Lane line num: " << lane_line_size;
  fprintf(file_save, "[\n");
  for (int j = 0; j < lane_line_size; ++j) {
    const base::LaneLineCubicCurve &curve_camera =
        lane_objects[j].curve_camera_coord;
    const base::LaneLineCubicCurve &curve_img =
        lane_objects[j].curve_image_coord;
    const std::vector<base::Point3DF> &camera_point_set =
        lane_objects[j].curve_camera_point_set;
    const std::vector<base::Point2DF> &image_point_set =
        lane_objects[j].curve_image_point_set;
    fprintf(file_save, "{\n");
    fprintf(file_save, "\"type\":%d,\n", lane_objects[j].type);
    fprintf(file_save, "\"pos_type\":%d,\n", lane_objects[j].pos_type);
    // Camera curve
    fprintf(file_save, "\"camera_curve\":\n");
    fprintf(file_save, "{\"a\":%.10f,\"b\":%.10f,\"c\":%.10f,\"d\":%.10f,",
            curve_camera.a, curve_camera.b, curve_camera.c, curve_camera.d);
    fprintf(file_save, "\"x0\":%.10f,\"x1\":%.10f},\n", curve_camera.x_start,
            curve_camera.x_end);
    // Camera image point set
    fprintf(file_save, "\"camera_point_set\":\n");
    fprintf(file_save, "[");
    for (size_t k = 0; k < camera_point_set.size(); k++) {
      if (k < camera_point_set.size() - 1) {
        fprintf(file_save, "{\"x\":%.4f,\"y\":%.4f,\"z\":%.4f},",
                camera_point_set[k].x, camera_point_set[k].y,
                camera_point_set[k].z);
      } else {
        fprintf(file_save, "{\"x\":%.4f,\"y\":%.4f,\"z\":%.4f}",
                camera_point_set[k].x, camera_point_set[k].y,
                camera_point_set[k].z);
      }
    }
    fprintf(file_save, "],");
    fprintf(file_save, "\n");
    // Image curve
    fprintf(file_save, "\"image_curve\":\n");
    fprintf(file_save, "{\"a\":%.10f,\"b\":%.10f,\"c\":%.10f,\"d\":%.10f,",
            curve_img.a, curve_img.b, curve_img.c, curve_img.d);
    fprintf(file_save, "\"x0\":%.10f,\"x1\":%.10f},\n", curve_img.x_start,
            curve_img.x_end);
    // Curve image point set
    fprintf(file_save, "\"image_point_set\":\n");
    fprintf(file_save, "[");
    for (size_t k = 0; k < image_point_set.size(); ++k) {
      if (k < image_point_set.size() - 1) {
        fprintf(file_save, "{\"x\":%.4f,\"y\":%.4f},", image_point_set[k].x,
                image_point_set[k].y);
      } else {
        fprintf(file_save, "{\"x\":%.4f,\"y\":%.4f}", image_point_set[k].x,
                image_point_set[k].y);
      }
    }
    fprintf(file_save, "]");
    fprintf(file_save, "\n");
    if (j < lane_line_size - 1) {
      fprintf(file_save, "},\n");
    } else {
      fprintf(file_save, "}\n");
    }
  }
  fprintf(file_save, "]\n");
  fclose(file_save);
  return 0;
}

YoloxBboxIOU()

float apollo::perception::camera::YoloxBboxIOU	(	const std::vector< float > &	box1,
		const std::vector< float > &	box2
	)

Computes IoU between bboxes.

参数

box1	object label
box2	object label

返回

Returns the IoU of two bboxes

在文件 postprocess.cc 第 359 行定义.

                                                 {
  const int center_x_index = 0;
  const int center_y_index = 1;
  const int width_index = 2;
  const int height_index = 3;
 
  int b1_x1 = static_cast<int>(box1[center_x_index]) -
              std::floor(box1[width_index] / 2.0);
  int b1_y1 = static_cast<int>(box1[center_y_index]) -
              std::floor(box1[height_index] / 2.0);
  int b1_x2 = static_cast<int>(box1[center_x_index]) +
              std::floor(box1[width_index] / 2.0);
  int b1_y2 = static_cast<int>(box1[center_y_index]) +
              std::floor(box1[height_index] / 2.0);
 
  int b2_x1 = static_cast<int>(box2[center_x_index]) -
              std::floor(box2[width_index] / 2.0);
  int b2_y1 = static_cast<int>(box2[center_y_index]) -
              std::floor(box2[height_index] / 2.0);
  int b2_x2 = static_cast<int>(box2[center_x_index]) +
              std::floor(box2[width_index] / 2.0);
  int b2_y2 = static_cast<int>(box2[center_y_index]) +
              std::floor(box2[height_index] / 2.0);
 
  // get the corrdinates of the intersection rectangle
  int inter_rect_x1 = std::max(b1_x1, b2_x1);
  int inter_rect_y1 = std::max(b1_y1, b2_y1);
  int inter_rect_x2 = std::min(b1_x2, b2_x2);
  int inter_rect_y2 = std::min(b1_y2, b2_y2);
 
  // Intersection area
  float inter_area = static_cast<float>(
      Yoloxclamp(inter_rect_x2 - inter_rect_x1 + 1, 0, INT_MAX) *
      Yoloxclamp(inter_rect_y2 - inter_rect_y1 + 1, 0, INT_MAX));
  // Union Area
  float b1_area = (b1_x2 - b1_x1 + 1) * (b1_y2 - b1_y1 + 1);
  float b2_area = (b2_x2 - b2_x1 + 1) * (b2_y2 - b2_y1 + 1);
 
  float iou = inter_area / (b1_area + b2_area - inter_area + 1e-3);
  return iou;
}

Yoloxclamp()

template<typename T >

constexpr T apollo::perception::camera::Yoloxclamp ( const T &  val, const T &  low, const T &  high  )

constexpr

Clamp target value between low and high tools for iou

参数

val	target value
low	min value
high	max value

返回

Returns clamped value

在文件 postprocess.h 第 114 行定义.

                                                                  {
  return val < low ? low : (high < val ? high : val);
}

YoloxFillBase()

void apollo::perception::camera::YoloxFillBase	(	const std::vector< float > &	detect,
		const int	width,
		const int	height,
		const int	image_width,
		const int	image_height,
		base::ObjectPtr	obj
	)

Get 2dbbox for objects

参数

detect	pointer to the detect blob
width	640 resized image width
height	640 resized image height
image_width	1920 image width
image_height	1080 image height
obj	pointer to the object

在文件 postprocess.cc 第 303 行定义.

                                                              {
  // yolo image size is (416, 416), raw image is (1080, 1920)
  obj->camera_supplement.box.xmin = detect[0];
  obj->camera_supplement.box.ymin = detect[1];
  obj->camera_supplement.box.xmax = detect[0] + detect[2];
  obj->camera_supplement.box.ymax = detect[1] + detect[3];
}

YoloxFillBbox3d()

void apollo::perception::camera::YoloxFillBbox3d	(	const yolox3d::ModelParam &	model_param,
		const std::vector< float > &	detect,
		base::ObjectPtr	obj
	)

Add 3d bbox values for objects

参数

model_param	The parameters of model
detect	output of network
obj	pointer to the object

在文件 postprocess.cc 第 313 行定义.

                                                                        {
  auto obj_l = 0.0;
  auto obj_w = 0.0;
  auto obj_h = 0.0;
 
  if (model_param.with_box3d()) {
    if (base ::ObjectType ::VEHICLE ==
        base::kSubType2TypeMap.at(obj->sub_type)) {
      obj_l = model_param.car_template().l();
      obj_w = model_param.car_template().w();
      obj_h = model_param.car_template().h();
      if ("TRUCK" == base::kSubType2NameMap.at(obj->sub_type)) {
        obj_l = model_param.car_template().l() * 1.5;
        obj_w = model_param.car_template().w() * 1.5;
        obj_h = model_param.car_template().h() * 1.5;
      } else if ("BUS" == base::kSubType2NameMap.at(obj->sub_type)) {
        obj_l = model_param.car_template().l() * 3;
        obj_w = model_param.car_template().w() * 1.5;
        obj_h = model_param.car_template().h() * 2.0;
      }
    } else if (base ::ObjectType ::PEDESTRIAN ==
               base::kSubType2TypeMap.at(obj->sub_type)) {
      obj_l = model_param.ped_template().l();
      obj_w = model_param.ped_template().w();
      obj_h = model_param.ped_template().h();
    } else if (base ::ObjectType ::BICYCLE ==
               base::kSubType2TypeMap.at(obj->sub_type)) {
      obj_l = model_param.cyclist_template().l();
      obj_w = model_param.cyclist_template().w();
      obj_h = model_param.cyclist_template().h();
    } else if (base ::ObjectType ::UNKNOWN_UNMOVABLE ==
               base::kSubType2TypeMap.at(obj->sub_type)) {
      obj_l = model_param.trafficcone_template().l();
      obj_w = model_param.trafficcone_template().w();
      obj_h = model_param.trafficcone_template().h();
    }
 
    // length, width, height
    obj->size[0] = obj_l;
    obj->size[1] = obj_w;
    obj->size[2] = obj_h;
    obj->camera_supplement.alpha = detect[8];
  }
}

YoloxGetAllObjects()

void apollo::perception::camera::YoloxGetAllObjects	(	const float *	data,
		const yolox3d::ModelParam &	model_param,
		const float	scale,
		std::vector< std::vector< float > > *	objects_out
	)

Get all objects accoring to confidence

参数

data	the output blob data
model_param	The parameters of model
objects	pointer to the object

在文件 postprocess.cc 第 238 行定义.

                                                                  {
  objects_out->clear();
 
  std::vector<Object> objects;
  std::vector<Object> proposals;
  std::vector<int> strides = {8, 16, 32};
  std::vector<GridAndStride> grid_strides;
  generate_grids_and_stride(strides, grid_strides);
  generate_yolox3d_proposals(grid_strides, data,
                             model_param.confidence_threshold(), proposals);
  AINFO << "Yolox proposals size is " << proposals.size();
 
  qsort_descent_inplace(proposals);
  AINFO << "Yolox proposals after sort size is " << proposals.size();
 
  std::vector<int> picked;
  nms_sorted_bboxes(proposals, picked, model_param.nms_param().threshold());
  AINFO << "Yolox objects after nms is " << picked.size();
 
  int count = picked.size();
  objects.resize(count);
  for (int i = 0; i < count; i++) {
    objects[i] = proposals[picked[i]];
 
    // adjust offset to original unpadded
    float x0 = (objects[i].rect.x) / scale;
    float y0 = (objects[i].rect.y) / scale;
    float x1 = (objects[i].rect.x + objects[i].rect.width) / scale;
    float y1 = (objects[i].rect.y + objects[i].rect.height) / scale;
 
    // clip
    x0 = std::max(std::min(x0, static_cast<float>(1920 - 1)), 0.f);
    y0 = std::max(std::min(y0, static_cast<float>(1920 - 1)), 0.f);
    x1 = std::max(std::min(x1, static_cast<float>(1920 - 1)), 0.f);
    y1 = std::max(std::min(y1, static_cast<float>(1920 - 1)), 0.f);
 
    objects[i].rect.x = x0;
    objects[i].rect.y = y0;
    objects[i].rect.width = x1 - x0;
    objects[i].rect.height = y1 - y0;
 
    std::vector<float> object_temp;
    object_temp.push_back(x0);       // left x
    object_temp.push_back(y0);       // left y
    object_temp.push_back(x1 - x0);  // w
    object_temp.push_back(y1 - y0);  // h
 
    object_temp.push_back(objects[i].prob);   // score
    object_temp.push_back(objects[i].label);  // class label
 
    objects_out->push_back(object_temp);
  }
}

YoloxGetObjectsCpu()

void apollo::perception::camera::YoloxGetObjectsCpu	(	const std::shared_ptr< base::Blob< float > > &	objects_blob,
		const yolox3d::ModelParam &	model_param,
		const yolox3d::NMSParam &	nms_param,
		const int	width,
		const int	height,
		const int	image_width,
		const int	image_height,
		std::vector< base::ObjectPtr > *	objects
	)

Return Yolox Objects

参数

objects_blob	the object blob output from network
model_param	The parameters of model
nms_param	The parameters of NMS
width	640 resized image width
height	640 resized image height
image_width	image width
image_height	the image width and height
objects	pointer to the object

在文件 postprocess.cc 第 431 行定义.

                                                           {
  ACHECK(objects_blob != nullptr);
  ACHECK(objects != nullptr);
 
  const float *detect_data = objects_blob->cpu_data();
  ACHECK(detect_data != nullptr);
 
  float scale = std::min(model_param.resize().width() / (image_width * 1.0),
                         model_param.resize().height() / (image_height * 1.0));
 
  std::vector<std::vector<float>> detect_objects;
  YoloxGetAllObjects(detect_data, model_param, scale, &detect_objects);
 
  // center_x, center_y, width, height, class_score, class_label
  objects->clear();
  for (const std::vector<float> &detect : detect_objects) {
    const int label = detect[kLabelIndex];
    // ignore unknown
    if (7 <= label) {
      continue;
    }
 
    base::ObjectPtr obj = nullptr;
    obj.reset(new base::Object);
 
    obj->sub_type = kYoloSubTypeYolox[label];
    obj->type = base::kSubType2TypeMap.at(obj->sub_type);
    obj->confidence = detect[kScoreIndex];
 
    obj->type_probs.assign(static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE),
                           0);
    obj->sub_type_probs.assign(
        static_cast<int>(base::ObjectSubType::MAX_OBJECT_TYPE), 0);
    obj->type_probs[static_cast<int>(obj->type)] = detect[kLabelIndex];
    obj->sub_type_probs[static_cast<int>(obj->sub_type)] = detect[kLabelIndex];
 
    YoloxFillBase(detect, width, height, image_width, image_height, obj);
 
    YoloxFillBbox3d(model_param, detect, obj);
 
    // TODO(lordon): add ignore truncated bool param
    YoloxTruncated(obj, image_width, image_height);
 
    objects->push_back(obj);
  }
}

YoloxTruncated()

void apollo::perception::camera::YoloxTruncated	(	base::ObjectPtr	obj,
		const int	image_width,
		const int	image_height
	)

object is truncated or not

参数

obj	pointer to the object
image_width	1920 image width
image_height	1080 image height

返回

true

false

在文件 postprocess.cc 第 402 行定义.

                                            {
  const float boundary_len = 20.0;  // TODO(lordon): 20 piexl move it to conf
  float min_x = static_cast<float>(boundary_len);
  float min_y = static_cast<float>(boundary_len);
  float max_x = static_cast<float>(image_width - boundary_len);
  float max_y = static_cast<float>(image_height - boundary_len);
  double eps = 1e-2;
 
  if (obj->camera_supplement.box.xmin <= min_x ||
      obj->camera_supplement.box.xmax >= max_x ||
      obj->camera_supplement.box.ymin <= min_y ||
      obj->camera_supplement.box.ymax >= max_y) {
    // Truncation assignment based on bbox positions
    if ((obj->camera_supplement.box.ymin < eps) ||
        (obj->camera_supplement.box.ymax >= 1.0 - eps)) {
      obj->camera_supplement.truncated_vertical = 0.5;
    } else {
      obj->camera_supplement.truncated_vertical = 0.0;
    }
    if ((obj->camera_supplement.box.xmin < eps) ||
        (obj->camera_supplement.box.xmax >= 1.0 - eps)) {
      obj->camera_supplement.truncated_horizontal = 0.5;
    } else {
      obj->camera_supplement.truncated_horizontal = 0.0;
    }
  }
}

变量说明

anchorSizeFactor

constexpr int apollo::perception::camera::anchorSizeFactor = 2

constexpr

在文件 postprocess.h 第 125 行定义.

colorlistobj

std::vector<cv::Scalar> apollo::perception::camera::colorlistobj

初始值:

= {magenta_color,  
                                        purple_color,   
                                        teal_color,     
                                        violet_color,   
                                        pink_color,     
                                        beige_color,    
                                        ivory_color,    
                                        olive_color,    
                                        maroon_color,   
                                        lime_color}

在文件 visualizer.cc 第 34 行定义.

                                   {magenta_color,  // last digit 0
                                        purple_color,   // last digit 1
                                        teal_color,     // last digit 2
                                        violet_color,   // last digit 3
                                        pink_color,     // last digit 4
                                        beige_color,    // last digit 5
                                        ivory_color,    // last digit 6
                                        olive_color,    // last digit 7
                                        maroon_color,   // last digit 8
                                        lime_color};    // last digit 9

colormapline

std::map<base::LaneLinePositionType, cv::Scalar> apollo::perception::camera::colormapline

初始值:

= {
    {base::LaneLinePositionType::UNKNOWN, black_color},
    {base::LaneLinePositionType::FOURTH_LEFT, sky_blue_color},
    {base::LaneLinePositionType::THIRD_LEFT, dodger_blue_color},
    {base::LaneLinePositionType::ADJACENT_LEFT, blue_color},
    {base::LaneLinePositionType::EGO_LEFT, dark_blue_color},
    {base::LaneLinePositionType::EGO_CENTER, light_green_color},
    {base::LaneLinePositionType::EGO_RIGHT, red_color},
    {base::LaneLinePositionType::ADJACENT_RIGHT, coral_color},
    {base::LaneLinePositionType::THIRD_RIGHT, salmon_color},
    {base::LaneLinePositionType::FOURTH_RIGHT, orange_color},
    {base::LaneLinePositionType::OTHER, white_color},
    {base::LaneLinePositionType::CURB_LEFT, cyan_color},
    {base::LaneLinePositionType::CURB_RIGHT, yellow_color}}

在文件 visualizer.cc 第 45 行定义.

                                                          {
    {base::LaneLinePositionType::UNKNOWN, black_color},
    {base::LaneLinePositionType::FOURTH_LEFT, sky_blue_color},
    {base::LaneLinePositionType::THIRD_LEFT, dodger_blue_color},
    {base::LaneLinePositionType::ADJACENT_LEFT, blue_color},
    {base::LaneLinePositionType::EGO_LEFT, dark_blue_color},
    {base::LaneLinePositionType::EGO_CENTER, light_green_color},
    {base::LaneLinePositionType::EGO_RIGHT, red_color},
    {base::LaneLinePositionType::ADJACENT_RIGHT, coral_color},
    {base::LaneLinePositionType::THIRD_RIGHT, salmon_color},
    {base::LaneLinePositionType::FOURTH_RIGHT, orange_color},
    {base::LaneLinePositionType::OTHER, white_color},
    {base::LaneLinePositionType::CURB_LEFT, cyan_color},
    {base::LaneLinePositionType::CURB_RIGHT, yellow_color}};

[struct]

struct { ... } apollo::perception::camera::customLess

EIGEN_ALIGN16

struct apollo::perception::camera::CameraFrame apollo::perception::camera::EIGEN_ALIGN16

kApolloName2SubTypeMap

const std::map<std::string, base::ObjectSubType> apollo::perception::camera::kApolloName2SubTypeMap

初始值:

= {
    {"smallMot", base::ObjectSubType::CAR},
    {"bigMot", base::ObjectSubType::CAR},
    {"nonMot", base::ObjectSubType::CYCLIST},
    {"pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"TrainedOthers", base::ObjectSubType::TRAFFICCONE},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
}

在文件 bevformer_obstacle_detector.cc 第 73 行定义.

                                                                    {
    {"smallMot", base::ObjectSubType::CAR},
    {"bigMot", base::ObjectSubType::CAR},
    {"nonMot", base::ObjectSubType::CYCLIST},
    {"pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"TrainedOthers", base::ObjectSubType::TRAFFICCONE},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
};

kClassOfObstacles

constexpr int apollo::perception::camera::kClassOfObstacles = 8

constexpr

在文件 postprocess.cc 第 30 行定义.

kDropsHistorySize

const std::size_t apollo::perception::camera::kDropsHistorySize = 20

在文件 cipv_camera.h 第 44 行定义.

kIndex2ApolloName

const std::map<int, std::string> apollo::perception::camera::kIndex2ApolloName

初始值:

= {{0, "smallMot"},
                                                      {1, "bigMot"},
                                                      {2, "nonMot"},
                                                      {3, "pedestrian"},
                                                      {4, "TrainedOthers"}}

在文件 bevformer_obstacle_detector.cc 第 82 行定义.

                                                 {{0, "smallMot"},
                                                      {1, "bigMot"},
                                                      {2, "nonMot"},
                                                      {3, "pedestrian"},
                                                      {4, "TrainedOthers"}};

kIndex2NuScenesName

const std::map<int, std::string> apollo::perception::camera::kIndex2NuScenesName

初始值:

= {
    {0, "car"},          {1, "truck"},   {2, "construction_vehicle"},
    {3, "bus"},          {4, "trailer"}, {5, "barrier"},
    {6, "motorcycle"},   {7, "bicycle"}, {8, "pedestrian"},
    {9, "traffic_cone"},
}

在文件 bevformer_obstacle_detector.cc 第 66 行定义.

                                                   {
    {0, "car"},          {1, "truck"},   {2, "construction_vehicle"},
    {3, "bus"},          {4, "trailer"}, {5, "barrier"},
    {6, "motorcycle"},   {7, "bicycle"}, {8, "pedestrian"},
    {9, "traffic_cone"},
};

kKITTIName2SubTypeMap

const std::map<std::string, base::ObjectSubType> apollo::perception::camera::kKITTIName2SubTypeMap

初始值:

= {
    {"Car", base::ObjectSubType::CAR},
    {"Pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"Cyclist", base::ObjectSubType::CYCLIST},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
}

在文件 caddn_obstacle_detector.cc 第 33 行定义.

                                                                   {
    {"Car", base::ObjectSubType::CAR},
    {"Pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"Cyclist", base::ObjectSubType::CYCLIST},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
};

kLabelIndex

constexpr int apollo::perception::camera::kLabelIndex = 5

constexpr

在文件 postprocess.cc 第 33 行定义.

kMaxAllowedSkipObject

const std::size_t apollo::perception::camera::kMaxAllowedSkipObject = 10

在文件 cipv_camera.h 第 46 行定义.

kMaxDistObjectToLaneInMeter

constexpr float apollo::perception::camera::kMaxDistObjectToLaneInMeter = 70.0f

constexpr

在文件 cipv_camera.h 第 41 行定义.

kMaxDistObjectToLaneInPixel

constexpr float apollo::perception::camera::kMaxDistObjectToLaneInPixel = 10.0f

constexpr

在文件 cipv_camera.h 第 43 行定义.

kMaxDistObjectToVirtualLaneInMeter

constexpr float apollo::perception::camera::kMaxDistObjectToVirtualLaneInMeter = 10.0f

constexpr

在文件 cipv_camera.h 第 42 行定义.

kMaxObjectNum

const std::size_t apollo::perception::camera::kMaxObjectNum = 100

在文件 cipv_camera.h 第 45 行定义.

kMinVelocity

constexpr float apollo::perception::camera::kMinVelocity = 10.0f

constexpr

在文件 cipv_camera.h 第 40 行定义.

kNuScenesName2SubTypeMap

const std::map< std::string, base::ObjectSubType > apollo::perception::camera::kNuScenesName2SubTypeMap

初始值:

= {
    {"car", base::ObjectSubType::CAR},
    {"truck", base::ObjectSubType::TRUCK},
    {"construction_vehicle", base::ObjectSubType::CAR},
    {"bus", base::ObjectSubType::BUS},
    {"trailer", base::ObjectSubType::CAR},
    {"barrier", base::ObjectSubType::UNKNOWN_UNMOVABLE},
    {"motorcycle", base::ObjectSubType::MOTORCYCLIST},
    {"bicycle", base::ObjectSubType::CYCLIST},
    {"pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"traffic_cone", base::ObjectSubType::TRAFFICCONE},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
}

在文件 bev_obstacle_detector.cc 第 31 行定义.

                                                                      {
    {"car", base::ObjectSubType::CAR},
    {"truck", base::ObjectSubType::TRUCK},
    {"construction_vehicle", base::ObjectSubType::CAR},
    {"bus", base::ObjectSubType::BUS},
    {"trailer", base::ObjectSubType::CAR},
    {"barrier", base::ObjectSubType::UNKNOWN_UNMOVABLE},
    {"motorcycle", base::ObjectSubType::MOTORCYCLIST},
    {"bicycle", base::ObjectSubType::CYCLIST},
    {"pedestrian", base::ObjectSubType::PEDESTRIAN},
    {"traffic_cone", base::ObjectSubType::TRAFFICCONE},
    {"MAX_OBJECT_TYPE", base::ObjectSubType::MAX_OBJECT_TYPE},
};

kScoreIndex

constexpr int apollo::perception::camera::kScoreIndex = 4

constexpr

在文件 postprocess.cc 第 32 行定义.

kTimeDiffDefault

const float apollo::perception::camera::kTimeDiffDefault = 0.067f

在文件 lane_based_calibrator.h 第 31 行定义.

kTypeCanBeRef

std::vector<base::ObjectSubType> apollo::perception::camera::kTypeCanBeRef

初始值:

= {base::ObjectSubType::CAR,
                                                  base::ObjectSubType::VAN}

在文件 object_template_manager.cc 第 36 行定义.

                                             {base::ObjectSubType::CAR,
                                                  base::ObjectSubType::VAN};

kTypeRefinedByRef

std::vector<base::ObjectSubType> apollo::perception::camera::kTypeRefinedByRef

初始值:

= {
    base::ObjectSubType::BUS,        base::ObjectSubType::TRUCK,
    base::ObjectSubType::PEDESTRIAN, base::ObjectSubType::TRAFFICCONE,
    base::ObjectSubType::CYCLIST,    base::ObjectSubType::MOTORCYCLIST,
    base::ObjectSubType::TRICYCLIST}

在文件 object_template_manager.cc 第 46 行定义.

                                                 {
    base::ObjectSubType::BUS,        base::ObjectSubType::TRUCK,
    base::ObjectSubType::PEDESTRIAN, base::ObjectSubType::TRAFFICCONE,
    base::ObjectSubType::CYCLIST,    base::ObjectSubType::MOTORCYCLIST,
    base::ObjectSubType::TRICYCLIST};

kTypeRefinedByTemplate

std::vector<base::ObjectSubType> apollo::perception::camera::kTypeRefinedByTemplate

初始值:

= {
    base::ObjectSubType::CAR,        base::ObjectSubType::VAN,
    base::ObjectSubType::BUS,        base::ObjectSubType::TRUCK,
    base::ObjectSubType::PEDESTRIAN, base::ObjectSubType::TRAFFICCONE,
    base::ObjectSubType::CYCLIST,    base::ObjectSubType::MOTORCYCLIST,
}

在文件 object_template_manager.cc 第 39 行定义.

                                                      {
    base::ObjectSubType::CAR,        base::ObjectSubType::VAN,
    base::ObjectSubType::BUS,        base::ObjectSubType::TRUCK,
    base::ObjectSubType::PEDESTRIAN, base::ObjectSubType::TRAFFICCONE,
    base::ObjectSubType::CYCLIST,    base::ObjectSubType::MOTORCYCLIST,
};

kVelocityDefault

const float apollo::perception::camera::kVelocityDefault = 8.333f

在文件 lane_based_calibrator.h 第 30 行定义.

kYawRateDefault

const float apollo::perception::camera::kYawRateDefault = 0.0f

在文件 lane_based_calibrator.h 第 29 行定义.

kYoloSubTypeYolox

const base::ObjectSubType apollo::perception::camera::kYoloSubTypeYolox[]

初始值:

= {
    base::ObjectSubType::CAR,         base::ObjectSubType::TRUCK,
    base::ObjectSubType::VAN,         base::ObjectSubType::BUS,
    base::ObjectSubType::PEDESTRIAN,  base::ObjectSubType::CYCLIST,
    base::ObjectSubType::TRAFFICCONE, base::ObjectSubType::UNKNOWN,
}

在文件 postprocess.cc 第 35 行定义.

                                              {
    base::ObjectSubType::CAR,         base::ObjectSubType::TRUCK,
    base::ObjectSubType::VAN,         base::ObjectSubType::BUS,
    base::ObjectSubType::PEDESTRIAN,  base::ObjectSubType::CYCLIST,
    base::ObjectSubType::TRAFFICCONE, base::ObjectSubType::UNKNOWN,
};

MAX_CAMERA_IDX

const int apollo::perception::camera::MAX_CAMERA_IDX = 2147483647

在文件 camera_track.cc 第 27 行定义.

maxExpPower

constexpr float apollo::perception::camera::maxExpPower = 5.0f

constexpr

在文件 postprocess.h 第 124 行定义.

minExpPower

constexpr float apollo::perception::camera::minExpPower = -10.0f

constexpr

在文件 postprocess.h 第 123 行定义.

numScales

constexpr int apollo::perception::camera::numScales = 3

constexpr

在文件 postprocess.h 第 126 行定义.

object_subtype_map

const std::map<std::string, base::ObjectSubType> apollo::perception::camera::object_subtype_map

初始值:

= {
  {"car", base::ObjectSubType::CAR},
  {"van", base::ObjectSubType::VAN},
  {"bus", base::ObjectSubType::BUS},
  {"truck", base::ObjectSubType::TRUCK},
  {"cyclist", base::ObjectSubType::CYCLIST},
  {"motorcyclist", base::ObjectSubType::MOTORCYCLIST},
  {"tricyclelist", base::ObjectSubType::TRICYCLIST},
  {"pedestrian", base::ObjectSubType::PEDESTRIAN},
  {"trafficcone", base::ObjectSubType::TRAFFICCONE},
}

在文件 ground_truth.cc 第 31 行定义.

                                                                {
  {"car", base::ObjectSubType::CAR},
  {"van", base::ObjectSubType::VAN},
  {"bus", base::ObjectSubType::BUS},
  {"truck", base::ObjectSubType::TRUCK},
  {"cyclist", base::ObjectSubType::CYCLIST},
  {"motorcyclist", base::ObjectSubType::MOTORCYCLIST},
  {"tricyclelist", base::ObjectSubType::TRICYCLIST},
  {"pedestrian", base::ObjectSubType::PEDESTRIAN},
  {"trafficcone", base::ObjectSubType::TRAFFICCONE},
};

spatialLUTind

std::map<base::LaneLinePositionType, int> apollo::perception::camera::spatialLUTind

初始值:

= {
    {base::LaneLinePositionType::UNKNOWN, 0},
    {base::LaneLinePositionType::FOURTH_LEFT, 1},
    {base::LaneLinePositionType::THIRD_LEFT, 2},
    {base::LaneLinePositionType::ADJACENT_LEFT, 3},
    {base::LaneLinePositionType::EGO_LEFT, 4},
    {base::LaneLinePositionType::EGO_CENTER, 5},
    {base::LaneLinePositionType::EGO_RIGHT, 6},
    {base::LaneLinePositionType::ADJACENT_RIGHT, 7},
    {base::LaneLinePositionType::THIRD_RIGHT, 8},
    {base::LaneLinePositionType::FOURTH_RIGHT, 9},
    {base::LaneLinePositionType::OTHER, 10},
    {base::LaneLinePositionType::CURB_LEFT, 11},
    {base::LaneLinePositionType::CURB_RIGHT, 12}}

在文件 darkSCNN_lane_postprocessor.cc 第 49 行定义.

                                                      {
    {base::LaneLinePositionType::UNKNOWN, 0},
    {base::LaneLinePositionType::FOURTH_LEFT, 1},
    {base::LaneLinePositionType::THIRD_LEFT, 2},
    {base::LaneLinePositionType::ADJACENT_LEFT, 3},
    {base::LaneLinePositionType::EGO_LEFT, 4},
    {base::LaneLinePositionType::EGO_CENTER, 5},
    {base::LaneLinePositionType::EGO_RIGHT, 6},
    {base::LaneLinePositionType::ADJACENT_RIGHT, 7},
    {base::LaneLinePositionType::THIRD_RIGHT, 8},
    {base::LaneLinePositionType::FOURTH_RIGHT, 9},
    {base::LaneLinePositionType::OTHER, 10},
    {base::LaneLinePositionType::CURB_LEFT, 11},
    {base::LaneLinePositionType::CURB_RIGHT, 12}};

THREADS_PER_BLOCK_X

const uint32_t apollo::perception::camera::THREADS_PER_BLOCK_X = 32

在文件 image_data_operations_rpp.h 第 22 行定义.

THREADS_PER_BLOCK_Y

const uint32_t apollo::perception::camera::THREADS_PER_BLOCK_Y = 32

在文件 image_data_operations_rpp.h 第 23 行定义.