Classes
struct	AnchorBox

class	BaseCalibrationService

class	BaseCalibrator

class	BaseCameraPerception

class	BaseCipv

class	BaseFeatureExtractor

class	BaseInferenceEngine

struct	BaseInitOptions

class	BaseLandmarkDetector

class	BaseLaneDetector

class	BaseLanePostprocessor

class	BaseLaneTracker

class	BaseObstacleDetector

class	BaseObstaclePostprocessor

class	BaseObstacleTracker

class	BaseObstacleTransformer

class	BaseSceneParser

class	BaseSimilar

class	BaseTLPreprocessor

class	BaseTrafficLightDetector

class	BaseTrafficLightTracker

struct	BBox3D

struct	CalibrationServiceInitOptions

struct	CalibrationServiceOptions

struct	CalibratorInitOptions

struct	CalibratorOptions

struct	CalibratorParams

struct	CameraFrame

class	CameraGroundPlaneDetector

struct	CameraGroundPlaneParams

struct	CameraPerceptionInitOptions

struct	CameraPerceptionOptions

struct	CameraStatus

class	CarPose

class	Cipv

struct	CipvInitOptions

struct	CipvOptions

class	ClassifyBySimple

struct	CmpLanePointY

class	ConnectedComponent

class	CosineSimilar

class	CropBox

class	CropBoxWholeImage

class	DarkSCNNLaneDetector

class	DarkSCNNLanePostprocessor

class	DataProvider

class	DenselineLaneDetector

class	DenselineLanePostprocessor

class	DisjointSet

class	DummyCalibrationService

class	DummyCalibrator

class	DummyFeatureExtractor

class	DummyInferenceEngine

class	DummyLandmarkDetector

class	DummyLaneDetector

class	DummyLanePostprocessor

class	DummyLaneTracker

class	DummyObstacleDetector

class	DummyObstaclePostprocessor

class	DummyObstacleTracker

class	DummyObstacleTransformer

struct	EgoLane

class	ExtendedKalmanFilter

class	ExternalFeatureExtractor

struct	FeatureExtractorInitOptions

struct	FeatureExtractorLayer

struct	FeatureExtractorOptions

class	FirstOrderRCLowPassFilter

class	FrameList

struct	GlobalConfig

class	GPUSimilar

class	GroundPlaneTracker

class	HalfCircleAngle

class	HistogramEstimator

struct	HistogramEstimatorParams

struct	Hypothesis

struct	HystereticWindow

class	IGetBox

class	ImageGpuPreprocessHandler

struct	InferenceEngineInitOptions

struct	InferenceEngineOptions

class	KalmanFilterConstState

class	KalmanFilterConstVelocity

struct	LandmarkDetectorInitOptions

struct	LandmarkDetectorOptions

class	LaneBasedCalibrator

class	LaneCameraPerception

struct	LaneDetectorInitOptions

struct	LaneDetectorOptions

struct	LaneLine

class	LaneLineCalibrator

struct	LanePointInfo

struct	LanePostprocessorInitOptions

struct	LanePostprocessorOptions

struct	LaneTrackerInitOptions

struct	LaneTrackerOptions

struct	LineSegment2D

struct	LocalCalibratorInitOptions

class	LocationRefinerObstaclePostprocessor

class	MaxNMeanFilter

class	MeanFilter

struct	MinDims

class	MotionService

struct	MultiCamerasInitOption

class	MultiCamerasProjection

class	MultiCueObstacleTransformer

struct	NMSParam

struct	NormalizedBBox

class	ObjectMaintainer

class	ObjectTemplateManager

struct	ObjectTemplateManagerInitOptions

class	ObjMapper

struct	ObjMapperOptions

struct	ObjMapperParams

class	ObjPostProcessor

struct	ObjPostProcessorOptions

struct	ObjPostProcessorParams

class	ObstacleCameraPerception

class	ObstacleDetectionCamera

struct	ObstacleDetectorInitOptions

struct	ObstacleDetectorOptions

struct	ObstaclePostprocessorInitOptions

struct	ObstaclePostprocessorOptions

class	ObstacleReference

struct	ObstacleTrackerInitOptions

struct	ObstacleTrackerOptions

struct	ObstacleTransformerInitOptions

struct	ObstacleTransformerOptions

class	OMTObstacleTracker

class	OnlineCalibrationService

struct	PatchIndicator

class	PlaneMotion

class	ProjectFeature

struct	ProjectOption

struct	Reference

struct	SceneParserInitOptions

struct	SceneParserOptions

class	Select

class	SemanticReviser

struct	SemanticTable

struct	SimilarMap

class	SingleStageObstacleTransformer

struct	SmokeAnchorBox

struct	SmokeBBox3D

struct	SmokeBlobs

struct	SmokeMinDims

struct	SmokeNMSParam

struct	SmokeNormalizedBBox

class	SmokeObjectMaintainer

class	SmokeObstacleDetector

struct	Target

class	Timer

class	TLPreprocessor

struct	TLPreprocessorOption

class	TrackingFeatureExtractor

struct	TrackObject

class	TrafficLightCameraPerception

class	TrafficLightDetection

struct	TrafficLightDetectorInitOptions

struct	TrafficLightDetectorOptions

struct	TrafficLightPreprocessorInitOptions

class	TrafficLightRecognition

struct	TrafficLightTrackerInitOptions

struct	TrafficLightTrackerOptions

struct	Transform

struct	TransformerParams

class	TransformServer

class	UndistortionHandler

struct	VanishingPoint

class	Visualizer

struct	YoloBlobs

class	YoloObstacleDetector

class	Yolov4ObstacleDetector

Typedefs
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

typedef std::shared_ptr< TrackObject >	TrackObjectPtr

typedef std::vector< TrackObjectPtr >	TrackObjectPtrs

Enumerations
enum	TemplateIndex { TemplateIndex::CAR_MIN_VOLUME_INDEX, TemplateIndex::VAN_MIN_VOLUME_INDEX, TemplateIndex::TRUCK_MIN_VOLUME_INDEX, TemplateIndex::BUS_MIN_VOLUME_INDEX }

enum	LaneType { LaneType::UNKNOWN_LANE = -1, LaneType::EGO_LANE = 0, LaneType::ADJACENT_LEFT_LANE = 1, LaneType::ADJACENT_RIGHT_LANE = 2 }

Functions
void	WriteCamera2World (std::ofstream &fout, int frame_num, const Eigen::Affine3d &pose)

void	WriteTracking (std::ofstream &fout, int frame_num, const std::vector< base::ObjectPtr > &tracked_object)

int	WriteDetections (const bool enable, const std::string &out_path, const std::vector< base::ObjectPtr > &objects)

int	WriteDetections (const bool enable, const std::string &out_path, CameraFrame *frame)

int	WriteLanelines (const bool enable, const std::string &save_path, const std::vector< base::LaneLine > &lane_objects)

int	WriteCalibrationOutput (bool enable, const std::string &out_path, const CameraFrame *frame)

void	WriteFusionTracking (std::ofstream &fout, int frame_num, const std::string &camera_name, const std::vector< base::ObjectPtr > &tracked_object)

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)

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)

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 (float x, float target, float eps=1e-6f)

bool	Equal (double x, double target, double eps=1e-6)

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)

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_gpu, std::shared_ptr< base::Blob< float >> dst, int stepwidth, int start_axis)

std::string	GetCyberWorkRoot ()

void	FillObjectPolygonFromBBox3D (base::Object *object_ptr)

template<typename T >
void	CalculateMeanAndVariance (const std::vector< T > &data, T mean, T variance)

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)

	PERCEPTION_REGISTER_REGISTERER (BaseCalibrationService)

	PERCEPTION_REGISTER_REGISTERER (BaseCalibrator)

	PERCEPTION_REGISTER_REGISTERER (BaseCameraPerception)

	PERCEPTION_REGISTER_REGISTERER (BaseCipv)

	PERCEPTION_REGISTER_REGISTERER (BaseFeatureExtractor)

	PERCEPTION_REGISTER_REGISTERER (BaseInferenceEngine)

	PERCEPTION_REGISTER_REGISTERER (BaseLandmarkDetector)

	PERCEPTION_REGISTER_REGISTERER (BaseLaneDetector)

	PERCEPTION_REGISTER_REGISTERER (BaseLanePostprocessor)

	PERCEPTION_REGISTER_REGISTERER (BaseLaneTracker)

	PERCEPTION_REGISTER_REGISTERER (BaseObstacleDetector)

	PERCEPTION_REGISTER_REGISTERER (BaseObstaclePostprocessor)

	PERCEPTION_REGISTER_REGISTERER (BaseObstacleTracker)

	PERCEPTION_REGISTER_REGISTERER (BaseObstacleTransformer)

	PERCEPTION_REGISTER_REGISTERER (BaseSceneParser)

	PERCEPTION_REGISTER_REGISTERER (BaseTLPreprocessor)

	PERCEPTION_REGISTER_REGISTERER (BaseTrafficLightDetector)

	PERCEPTION_REGISTER_REGISTERER (BaseTrafficLightTracker)

template<typename Dtype >
bool	PolyFit (const std::vector< 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 std::vector< Eigen::Matrix< Dtype, 2, 1 >> &pos_vec, std::vector< 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))

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)

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)

bool	FindKSmallValue (const float distance, int dim, int k, int index)

bool	FindKLargeValue (const float distance, int dim, int k, int index)

	CYBER_REGISTER_COMPONENT (MotionService)

int	get_smoke_objects_gpu ()

void	get_smoke_objects_cpu (const SmokeBlobs &smoke_blobs, const std::vector< base::ObjectSubType > &types, const smoke::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, int width, int height)

void	recover_smoke_bbox (int roi_w, int roi_h, int offset_y, std::vector< base::ObjectPtr > *objects)

void	filter_bbox (const SmokeMinDims &min_dims, std::vector< base::ObjectPtr > *objects)

void	fill_smoke_base (base::ObjectPtr obj, const float *bbox, int width, int height)

void	fill_smoke_bbox3d (bool with_bbox3d, base::ObjectPtr obj, const float *bbox)

base::ObjectSubType	get_smoke_object_subtype (int cls)

__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	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)

float	get_bbox_size (const NormalizedBBox &bbox)

void	get_intersect_bbox (const NormalizedBBox &bbox1, const NormalizedBBox &bbox2, NormalizedBBox *intersect_bbox)

float	get_jaccard_overlap (const NormalizedBBox &bbox1, const NormalizedBBox &bbox2)

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

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

int	get_area_id (float visible_ratios[4])

void	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, std::vector< base::ObjectPtr > *objects)

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

void	save_image (const std::string &path, base::Image8U *image)

void	save_blob (const std::string &path, base::Blob< uint8_t > *blob)

bool	draw_vanishing_row_on_image (const cv::Scalar &color, int vanishing_row, cv::Mat *image)

void	draw_lane_pts (const std::vector< Eigen::Vector2f > &lane_pts, const cv::Scalar &color, cv::Mat *image)

bool	ParseOneLaneLine (const std::string &s, LaneLine *lane_line)

bool	LoadLaneDet (const std::string &filename, EgoLane *ego_lane)

std::vector< std::string >	Split (const std::string &s, const std::string &separator)

bool	LoadCamera2WorldTfs (const std::string &filename, std::vector< std::string > frame_list, std::vector< double > time_stamps, std::vector< Eigen::Matrix4d > *camera2world)

void	show_detect_point_set (const cv::Mat &image, const std::vector< std::vector< LanePointInfo >> &detect_laneline_point_set, const std::string &save_path)

void	show_all_infer_point_set (const cv::Mat &image, const std::vector< LanePointInfo > &infer_point_set, const std::string &save_path)

void	show_lane_lines (const cv::Mat &image, const std::vector< base::LaneLine > &lane_marks, const std::string &save_path)

void	show_lane_ccs (const std::vector< unsigned char > &lane_map, const int lane_map_width, const int lane_map_height, const std::vector< ConnectedComponent > &lane_ccs, const std::vector< ConnectedComponent > &select_lane_ccs, const std::string &save_path)

void	output_laneline_to_json (const std::vector< base::LaneLine > &lane_objects, const std::string &save_path)

void	output_laneline_to_txt (const std::vector< base::LaneLine > &lane_objects, const std::string &save_path)

Variables
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

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

const float	kYawRateDefault = 0.0f

const float	kVelocityDefault = 8.333f

const float	kTimeDiffDefault = 0.067f

constexpr float	minExpPower = -10.0f

constexpr float	maxExpPower = 5.0f

constexpr int	anchorSizeFactor = 2

constexpr int	numScales = 3

Typedef Documentation

◆ ImageMsgType

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

◆ LocalizationMsgType

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

◆ Point2DSet

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

◆ Point3DSet

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

◆ TemplateMap

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

◆ TrackObjectPtr

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

◆ TrackObjectPtrs

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

Enumeration Type Documentation

◆ LaneType

enum apollo::perception::camera::LaneType

strong

Enumerator
UNKNOWN_LANE
EGO_LANE
ADJACENT_LEFT_LANE
ADJACENT_RIGHT_LANE

◆ TemplateIndex

enum apollo::perception::camera::TemplateIndex

strong

Enumerator
CAR_MIN_VOLUME_INDEX
VAN_MIN_VOLUME_INDEX
TRUCK_MIN_VOLUME_INDEX
BUS_MIN_VOLUME_INDEX

Function Documentation

◆ 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
	)

◆ apply_nms()

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

◆ 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
	)

◆ 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
	)

◆ 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
	)

◆ bbox_size_gpu()

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

◆ CalAngleDiff()

template<typename T >

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

◆ CalculateMeanAndVariance()

template<typename T >

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

◆ CameraPoint2Image()

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

◆ CheckXY()

template<typename T >

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

◆ ComparePoint2DY()

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

◆ 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
	)

◆ Contain()

template<typename T >

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

◆ ConvertGround3ToGround4()

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

◆ ConvertGround4ToGround3()

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

◆ CYBER_REGISTER_COMPONENT()

apollo::perception::camera::CYBER_REGISTER_COMPONENT ( MotionService )

◆ draw_lane_pts()

void apollo::perception::camera::draw_lane_pts	(	const std::vector< Eigen::Vector2f > &	lane_pts,
		const cv::Scalar &	color,
		cv::Mat *	image
	)

◆ draw_vanishing_row_on_image()

bool apollo::perception::camera::draw_vanishing_row_on_image	(	const cv::Scalar &	color,
		int	vanishing_row,
		cv::Mat *	image
	)

◆ Equal() [1/2]

bool apollo::perception::camera::Equal	(	float	x,
		float	target,
		float	eps = `1e-6f`
	)

◆ Equal() [2/2]

bool apollo::perception::camera::Equal	(	double	x,
		double	target,
		double	eps = `1e-6`
	)

◆ fill_area_id()

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

◆ fill_base()

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

◆ fill_bbox3d()

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

◆ fill_frbox()

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

◆ fill_lights()

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

◆ fill_ratios()

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

◆ fill_smoke_base()

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

◆ fill_smoke_bbox3d()

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

◆ FillObjectPolygonFromBBox3D()

void apollo::perception::camera::FillObjectPolygonFromBBox3D ( base::Object * object_ptr )

◆ filter_bbox() [1/2]

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

◆ filter_bbox() [2/2]

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

◆ FindCC()

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

◆ FindKLargeValue()

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

◆ FindKSmallValue()

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

◆ gaussian()

template<typename Dtype >

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

inline

◆ GenCorners()

template<typename T >

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

◆ GenRotMatrix()

template<typename T >

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

◆ get_area_id()

int apollo::perception::camera::get_area_id ( float visible_ratios[4] )

◆ get_bbox_size()

float apollo::perception::camera::get_bbox_size ( const NormalizedBBox & bbox )

◆ get_gpu_data()

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

◆ get_intersect_bbox()

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

◆ get_jaccard_overlap()

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

◆ 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_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_objects_gpu() [1/2]

void 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,
		std::vector< base::ObjectPtr > *	objects
	)

◆ get_objects_gpu() [2/2]

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_smoke_object_subtype()

base::ObjectSubType apollo::perception::camera::get_smoke_object_subtype ( int cls )

◆ get_smoke_objects_cpu()

void apollo::perception::camera::get_smoke_objects_cpu	(	const SmokeBlobs &	smoke_blobs,
		const std::vector< base::ObjectSubType > &	types,
		const smoke::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,
		int	width,
		int	height
	)

◆ get_smoke_objects_gpu()

int apollo::perception::camera::get_smoke_objects_gpu ( )

◆ GetBboxFromPts()

template<typename T >

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

◆ GetCyberWorkRoot()

std::string apollo::perception::camera::GetCyberWorkRoot ( )

◆ 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`
	)

◆ 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
	)

◆ 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
	)

◆ 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
	)

◆ GetMinIndexVec()

template<typename T >

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

◆ 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`
	)

◆ GetSharpAngle()

template<typename T >

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

inline

◆ 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
	)

◆ 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
	)

◆ GroundHypoGenFunc()

template<typename T >

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

◆ 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
	)

◆ IsCovered()

template<typename T >

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

◆ IsCoveredHorizon()

template<typename T >

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

◆ IsCoveredVertical()

template<typename T >

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

◆ jaccard_overlap_gpu()

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

◆ LoadAnchors()

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

◆ LoadCamera2WorldTfs()

bool apollo::perception::camera::LoadCamera2WorldTfs	(	const std::string &	filename,
		std::vector< std::string > *	frame_list,
		std::vector< double > *	time_stamps,
		std::vector< Eigen::Matrix4d > *	camera2world
	)

◆ LoadExpand()

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

◆ LoadLaneDet()

bool apollo::perception::camera::LoadLaneDet	(	const std::string &	filename,
		EgoLane *	ego_lane
	)

◆ LoadTypes()

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

◆ Occlude()

template<typename T >

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

◆ operator<<()

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

◆ 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`
	)

◆ 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`
	)

◆ output_laneline_to_json()

void apollo::perception::camera::output_laneline_to_json	(	const std::vector< base::LaneLine > &	lane_objects,
		const std::string &	save_path
	)

◆ output_laneline_to_txt()

void apollo::perception::camera::output_laneline_to_txt	(	const std::vector< base::LaneLine > &	lane_objects,
		const std::string &	save_path
	)

◆ ParseOneLaneLine()

bool apollo::perception::camera::ParseOneLaneLine	(	const std::string &	s,
		LaneLine *	lane_line
	)

◆ PERCEPTION_REGISTER_REGISTERER() [1/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseCameraPerception )

◆ PERCEPTION_REGISTER_REGISTERER() [2/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseInferenceEngine )

◆ PERCEPTION_REGISTER_REGISTERER() [3/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseLaneTracker )

◆ PERCEPTION_REGISTER_REGISTERER() [4/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseSceneParser )

◆ PERCEPTION_REGISTER_REGISTERER() [5/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseLandmarkDetector )

◆ PERCEPTION_REGISTER_REGISTERER() [6/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseTrafficLightTracker )

◆ PERCEPTION_REGISTER_REGISTERER() [7/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseTrafficLightDetector )

◆ PERCEPTION_REGISTER_REGISTERER() [8/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseObstaclePostprocessor )

◆ PERCEPTION_REGISTER_REGISTERER() [9/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseObstacleTransformer )

◆ PERCEPTION_REGISTER_REGISTERER() [10/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseLaneDetector )

◆ PERCEPTION_REGISTER_REGISTERER() [11/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseObstacleDetector )

◆ PERCEPTION_REGISTER_REGISTERER() [12/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseLanePostprocessor )

◆ PERCEPTION_REGISTER_REGISTERER() [13/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseCalibrator )

◆ PERCEPTION_REGISTER_REGISTERER() [14/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseCipv )

◆ PERCEPTION_REGISTER_REGISTERER() [15/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseTLPreprocessor )

◆ PERCEPTION_REGISTER_REGISTERER() [16/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseObstacleTracker )

◆ PERCEPTION_REGISTER_REGISTERER() [17/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseFeatureExtractor )

◆ PERCEPTION_REGISTER_REGISTERER() [18/18]

apollo::perception::camera::PERCEPTION_REGISTER_REGISTERER ( BaseCalibrationService )

◆ 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
	)

◆ PolyFit()

template<typename Dtype >

bool apollo::perception::camera::PolyFit	(	const std::vector< 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`
	)

◆ QSwap_()

template<class T >

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

◆ QuickSort() [1/2]

template<class T >

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

◆ QuickSort() [2/2]

template<class T >

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

◆ RansacFitting()

template<typename Dtype >

bool apollo::perception::camera::RansacFitting	(	const std::vector< Eigen::Matrix< Dtype, 2, 1 >> &	pos_vec,
		std::vector< 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)`
	)

◆ recover_bbox()

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

◆ recover_smoke_bbox()

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

◆ RefineBox() [1/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
	)

◆ RefineBox() [2/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
	)

◆ ResizeCPU()

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

◆ save_blob()

void apollo::perception::camera::save_blob	(	const std::string &	path,
		base::Blob< uint8_t > *	blob
	)

inline

◆ save_image()

void apollo::perception::camera::save_image	(	const std::string &	path,
		base::Image8U *	image
	)

inline

◆ show_all_infer_point_set()

void apollo::perception::camera::show_all_infer_point_set	(	const cv::Mat &	image,
		const std::vector< LanePointInfo > &	infer_point_set,
		const std::string &	save_path
	)

◆ show_detect_point_set()

void apollo::perception::camera::show_detect_point_set	(	const cv::Mat &	image,
		const std::vector< std::vector< LanePointInfo >> &	detect_laneline_point_set,
		const std::string &	save_path
	)

◆ show_lane_ccs()

void apollo::perception::camera::show_lane_ccs	(	const std::vector< unsigned char > &	lane_map,
		const int	lane_map_width,
		const int	lane_map_height,
		const std::vector< ConnectedComponent > &	lane_ccs,
		const std::vector< ConnectedComponent > &	select_lane_ccs,
		const std::string &	save_path
	)

◆ show_lane_lines()

void apollo::perception::camera::show_lane_lines	(	const cv::Mat &	image,
		const std::vector< base::LaneLine > &	lane_marks,
		const std::string &	save_path
	)

◆ sigmoid()

template<typename Dtype >

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

inline

◆ 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
	)

◆ Split()

std::vector<std::string> apollo::perception::camera::Split	(	const std::string &	s,
		const std::string &	separator
	)

◆ sqr()

template<typename Dtype >

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

◆ 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
	)

◆ WriteCalibrationOutput()

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

◆ WriteCamera2World()

void apollo::perception::camera::WriteCamera2World	(	std::ofstream &	fout,
		int	frame_num,
		const Eigen::Affine3d &	pose
	)

◆ WriteDetections() [1/2]

int apollo::perception::camera::WriteDetections	(	const bool	enable,
		const std::string &	out_path,
		const std::vector< base::ObjectPtr > &	objects
	)

◆ WriteDetections() [2/2]

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

◆ WriteFusionTracking()

void apollo::perception::camera::WriteFusionTracking	(	std::ofstream &	fout,
		int	frame_num,
		const std::string &	camera_name,
		const std::vector< base::ObjectPtr > &	tracked_object
	)

◆ WriteLanelines()

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

◆ WriteTracking()

void apollo::perception::camera::WriteTracking	(	std::ofstream &	fout,
		int	frame_num,
		const std::vector< base::ObjectPtr > &	tracked_object
	)

Variable Documentation

◆ anchorSizeFactor

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

◆ EIGEN_ALIGN16

apollo::perception::camera::ObstacleDetectorInitOptions apollo::perception::camera::EIGEN_ALIGN16

◆ kDropsHistorySize

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

◆ kMaxAllowedSkipObject

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

◆ kMaxDistObjectToLaneInMeter

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

◆ kMaxDistObjectToLaneInPixel

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

◆ kMaxDistObjectToVirtualLaneInMeter

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

◆ kMaxObjectNum

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

◆ kMinVelocity

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

◆ kTimeDiffDefault

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

◆ kVelocityDefault

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

◆ kYawRateDefault

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

◆ maxExpPower

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

◆ minExpPower

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

◆ numScales

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

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ImageMsgType

◆ LocalizationMsgType

◆ Point2DSet

◆ Point3DSet

◆ TemplateMap

◆ TrackObjectPtr

◆ TrackObjectPtrs

Enumeration Type Documentation

◆ LaneType

◆ TemplateIndex

Function Documentation

◆ apply_boxvoting_fast()

◆ apply_nms()

◆ apply_nms_fast()

◆ apply_nms_gpu()

◆ apply_softnms_fast()

◆ bbox_size_gpu()

◆ CalAngleDiff()

◆ CalculateMeanAndVariance()

◆ CameraPoint2Image()

◆ CheckXY()

◆ ComparePoint2DY()

◆ compute_overlapped_by_idx_gpu()

◆ Contain()

◆ ConvertGround3ToGround4()

◆ ConvertGround4ToGround3()

◆ CYBER_REGISTER_COMPONENT()

◆ draw_lane_pts()

◆ draw_vanishing_row_on_image()

◆ Equal() [1/2]

◆ Equal() [2/2]

◆ fill_area_id()

◆ fill_base()

◆ fill_bbox3d()

◆ fill_frbox()

◆ fill_lights()

◆ fill_ratios()

◆ fill_smoke_base()

◆ fill_smoke_bbox3d()

◆ FillObjectPolygonFromBBox3D()

◆ filter_bbox() [1/2]

◆ filter_bbox() [2/2]

◆ FindCC()

◆ FindKLargeValue()

◆ FindKSmallValue()

◆ gaussian()

◆ GenCorners()

◆ GenRotMatrix()

◆ get_area_id()

◆ get_bbox_size()

◆ get_gpu_data()

◆ get_intersect_bbox()

◆ get_jaccard_overlap()

◆ get_max_score_index()

◆ get_objects_cpu()

◆ get_objects_gpu() [1/2]

◆ get_objects_gpu() [2/2]

◆ get_smoke_object_subtype()

◆ get_smoke_objects_cpu()

◆ get_smoke_objects_gpu()

◆ GetBboxFromPts()

◆ GetCyberWorkRoot()

◆ GetDxDzForCenterFromGroundLineSeg()

◆ GetGround3FromPitchHeight()

◆ GetGroundPlanePitchHeight()

◆ GetJaccardIndex()

◆ GetMinIndexVec()

◆ GetScoreViaRotDimensionCenter()

◆ GetSharpAngle()

◆ GetYawVelocityInfo()

◆ GroundFittingCostFunc()

◆ GroundHypoGenFunc()

◆ ImagePoint2Camera()

◆ IsCovered()