Classes
class	AttributePointCloud

class	BaseCameraDistortionModel

class	BaseCameraModel

class	BaseObjectPool

struct	BBox2D

class	Blob
	A wrapper around SyncedMemory holders serving as the basic computational unit for images, feature maps, etc. More...

struct	BoundingCube

class	BrownCameraDistortionModel

struct	CameraFrameSupplement

struct	CameraObjectSupplement

struct	CarLight

class	ConcurrentObjectPool

struct	CPUDevice

class	CPUDeviceTest

class	DummyObjectPool

struct	EndPoints

struct	Frame

struct	FrameInitializer

struct	FusionObjectSupplement

struct	HdmapStruct

class	Image8U
	A wrapper around Blob holders serving as the basic computational unit for images. More...

struct	ImpendingCollisionEdge

struct	ImpendingCollisionEdges

struct	Landmark

struct	LaneBoundary

struct	LaneLine

struct	LaneLineCubicCurve

struct	LidarFrameSupplement

struct	LidarObjectSupplement

class	LightObjectPool

struct	LightRegion

struct	LightStatus

class	MultiDeviceTest

struct	Object

struct	ObjectInitializer

struct	ObjectPoolDefaultInitializer

class	OmnidirectionalCameraDistortionModel

class	PinholeCameraModel

struct	Point

struct	Point2D

struct	Point3D

class	PointCloud

struct	PointCloudInitializer

struct	PointIndices

struct	PointXYZIT

struct	PointXYZITH

struct	PointXYZITHB

struct	PointXYZITHBL

class	Polynomial

struct	RadarFrameSupplement

struct	RadarObjectSupplement

struct	Rect

struct	RoadBoundary

struct	SensorInfo

struct	SensorObjectMeasurement

class	SyncedMemory
	Manages memory allocation and synchronization between the host (CPU) and device (GPU). More...

struct	TrafficLight

struct	UltrasonicFrameSupplement

struct	Vehicle3DStatus

struct	VehicleStatus

Typedefs
template<typename Dtype >
using	BlobPtr = std::shared_ptr< Blob< Dtype > >

template<typename Dtype >
using	BlobConstPtr = std::shared_ptr< const Blob< Dtype > >

typedef Rect< int >	RectI

typedef Rect< float >	RectF

typedef Rect< double >	RectD

typedef BBox2D< int >	BBox2DI

typedef BBox2D< float >	BBox2DF

typedef BBox2D< double >	BBox2DD

typedef std::shared_ptr< BaseCameraModel >	BaseCameraModelPtr

typedef std::shared_ptr< const BaseCameraModel >	BaseCameraModelConstPtr

typedef std::shared_ptr< PinholeCameraModel >	PinholeCameraModelPtr

typedef std::shared_ptr< const PinholeCameraModel >	PinholeCameraModelConstPtr

using	BrownCameraDistortionModelPtr = std::shared_ptr< BrownCameraDistortionModel >

using	BrownCameraDistortionModelConstPtr = std::shared_ptr< const BrownCameraDistortionModel >

typedef std::shared_ptr< Frame >	FramePtr

typedef std::shared_ptr< const Frame >	FrameConstPtr

typedef std::shared_ptr< LidarFrameSupplement >	LidarFrameSupplementPtr

typedef std::shared_ptr< const LidarFrameSupplement >	LidarFrameSupplementConstPtr

typedef std::shared_ptr< RadarFrameSupplement >	RadarFrameSupplementPtr

typedef std::shared_ptr< const RadarFrameSupplement >	RadarFrameSupplementConstPtr

typedef std::shared_ptr< CameraFrameSupplement >	CameraFrameSupplementPtr

typedef std::shared_ptr< const CameraFrameSupplement >	CameraFrameSupplementConstPtr

typedef std::shared_ptr< UltrasonicFrameSupplement >	UltrasonicFrameSupplementPtr

typedef std::shared_ptr< const UltrasonicFrameSupplement >	UltrasonicFrameSupplementConstPtr

using	HdmapStructPtr = std::shared_ptr< HdmapStruct >

using	HdmapStructConstPtr = std::shared_ptr< const HdmapStruct >

typedef std::shared_ptr< Image8U >	Image8UPtr

typedef std::shared_ptr< const Image8U >	Image8UConstPtr

using	ObjectPtr = std::shared_ptr< Object >

using	ObjectConstPtr = std::shared_ptr< const Object >

using	ObjectPool = ConcurrentObjectPool< Object, kObjectPoolSize, ObjectInitializer >

using	PointFCloudPool = ConcurrentObjectPool< AttributePointCloud< PointF >, kPointCloudPoolSize, PointCloudInitializer< float > >

using	PointDCloudPool = ConcurrentObjectPool< AttributePointCloud< PointD >, kPointCloudPoolSize, PointCloudInitializer< double > >

using	FramePool = ConcurrentObjectPool< Frame, kFramePoolSize, FrameInitializer >

typedef std::shared_ptr< LidarObjectSupplement >	LidarObjectSupplementPtr

typedef std::shared_ptr< const LidarObjectSupplement >	LidarObjectSupplementConstPtr

typedef std::shared_ptr< RadarObjectSupplement >	RadarObjectSupplementPtr

typedef std::shared_ptr< const RadarObjectSupplement >	RadarObjectSupplementConstPtr

typedef std::shared_ptr< CameraObjectSupplement >	CameraObjectSupplementPtr

typedef std::shared_ptr< const CameraObjectSupplement >	CameraObjectSupplementConstPtr

typedef Eigen::Matrix4f	MotionType

typedef boost::circular_buffer< VehicleStatus >	MotionBuffer

typedef std::shared_ptr< MotionBuffer >	MotionBufferPtr

typedef std::shared_ptr< const MotionBuffer >	MotionBufferConstPtr

typedef boost::circular_buffer< Vehicle3DStatus >	Motion3DBuffer

typedef std::shared_ptr< Motion3DBuffer >	Motion3DBufferPtr

typedef std::shared_ptr< const Motion3DBuffer >	Motion3DBufferConstPtr

using	PointF = Point< float >

using	PointD = Point< double >

using	PointXYZIF = Point< float >

using	PointXYZID = Point< double >

using	PointXYZITF = PointXYZIT< float >

using	PointXYZITD = PointXYZIT< double >

using	PointXYZITHF = PointXYZITH< float >

using	PointXYZITHD = PointXYZITH< double >

using	PointXYZITHBF = PointXYZITHB< float >

using	PointXYZITHBD = PointXYZITHB< double >

using	PointXYZITHBLF = PointXYZITHBL< float >

using	PointXYZITHBLD = PointXYZITHBL< double >

using	Point2DF = Point2D< float >

using	Point2DI = Point2D< int >

using	Point2DD = Point2D< double >

using	Point3DF = Point3D< float >

using	Point3DI = Point3D< int >

using	Point3DD = Point3D< double >

typedef std::shared_ptr< PointIndices >	PointIndicesPtr

typedef std::shared_ptr< const PointIndices >	PointIndicesConstPtr

typedef AttributePointCloud< PointF >	PointFCloud

typedef AttributePointCloud< PointD >	PointDCloud

typedef std::shared_ptr< PointFCloud >	PointFCloudPtr

typedef std::shared_ptr< const PointFCloud >	PointFCloudConstPtr

typedef std::shared_ptr< PointDCloud >	PointDCloudPtr

typedef std::shared_ptr< const PointDCloud >	PointDCloudConstPtr

typedef PointCloud< PointF >	PolygonFType

typedef PointCloud< PointD >	PolygonDType

typedef std::shared_ptr< PolygonFType >	PolygonFTypePtr

typedef std::shared_ptr< const PolygonFType >	PolygonFTypeConstPtr

typedef std::shared_ptr< PolygonDType >	PolygonDTypePtr

typedef std::shared_ptr< const PolygonDType >	PolygonDTypeConstPtr

typedef ::testing::Types< float, double >	TestDtypes

typedef ::testing::Types< CPUDevice< float >, CPUDevice< double > >	TestDtypesAndDevices

typedef std::shared_ptr< TrafficLight >	TrafficLightPtr

typedef std::vector< TrafficLightPtr >	TrafficLightPtrs

Enumerations
enum	Color { Color::NONE = 0x00, Color::GRAY = 0x01, Color::RGB = 0x02, Color::BGR = 0x03 }

enum	LaneLineType { LaneLineType::WHITE_DASHED = 0, LaneLineType::WHITE_SOLID, LaneLineType::YELLOW_DASHED, LaneLineType::YELLOW_SOLID }

enum	LaneLinePositionType { LaneLinePositionType::CURB_LEFT = -5, LaneLinePositionType::FOURTH_LEFT = -4, LaneLinePositionType::THIRD_LEFT = -3, LaneLinePositionType::ADJACENT_LEFT = -2, LaneLinePositionType::EGO_LEFT = -1, LaneLinePositionType::EGO_CENTER = 0, LaneLinePositionType::EGO_RIGHT = 1, LaneLinePositionType::ADJACENT_RIGHT = 2, LaneLinePositionType::THIRD_RIGHT = 3, LaneLinePositionType::FOURTH_RIGHT = 4, LaneLinePositionType::CURB_RIGHT = 5, LaneLinePositionType::OTHER = 6, LaneLinePositionType::UNKNOWN = 7 }
	Definition of the position of a lane marking in respect to the ego lane. More...

enum	LaneLineUseType { LaneLineUseType::REAL = 0, LaneLineUseType::VIRTUAL }

enum	ObjectType { ObjectType::UNKNOWN = 0, ObjectType::UNKNOWN_MOVABLE = 1, ObjectType::UNKNOWN_UNMOVABLE = 2, ObjectType::PEDESTRIAN = 3, ObjectType::BICYCLE = 4, ObjectType::VEHICLE = 5, ObjectType::MAX_OBJECT_TYPE = 6 }

enum	InternalObjectType { InternalObjectType::INT_BACKGROUND = 0, InternalObjectType::INT_SMALLMOT = 1, InternalObjectType::INT_PEDESTRIAN = 2, InternalObjectType::INT_NONMOT = 3, InternalObjectType::INT_BIGMOT = 4, InternalObjectType::INT_UNKNOWN = 5, InternalObjectType::INT_MAX_OBJECT_TYPE = 6 }

enum	VisualObjectType { VisualObjectType::CAR, VisualObjectType::VAN, VisualObjectType::BUS, VisualObjectType::TRUCK, VisualObjectType::BICYCLE, VisualObjectType::TRICYCLE, VisualObjectType::PEDESTRIAN, VisualObjectType::TRAFFICCONE, VisualObjectType::UNKNOWN_MOVABLE, VisualObjectType::UNKNOWN_UNMOVABLE, VisualObjectType::MAX_OBJECT_TYPE }

enum	ObjectSubType { ObjectSubType::UNKNOWN = 0, ObjectSubType::UNKNOWN_MOVABLE = 1, ObjectSubType::UNKNOWN_UNMOVABLE = 2, ObjectSubType::CAR = 3, ObjectSubType::VAN = 4, ObjectSubType::TRUCK = 5, ObjectSubType::BUS = 6, ObjectSubType::CYCLIST = 7, ObjectSubType::MOTORCYCLIST = 8, ObjectSubType::TRICYCLIST = 9, ObjectSubType::PEDESTRIAN = 10, ObjectSubType::TRAFFICCONE = 11, ObjectSubType::MAX_OBJECT_TYPE = 12 }

enum	MotionState { MotionState::UNKNOWN = 0, MotionState::MOVING = 1, MotionState::STATIONARY = 2 }

enum	VisualLandmarkType { VisualLandmarkType::RoadArrow, VisualLandmarkType::RoadText, VisualLandmarkType::TrafficSign, VisualLandmarkType::TrafficLight, VisualLandmarkType::MAX_LANDMARK_TYPE }

enum	SensorType { SensorType::UNKNOWN_SENSOR_TYPE = -1, SensorType::VELODYNE_64 = 0, SensorType::VELODYNE_32 = 1, SensorType::VELODYNE_16 = 2, SensorType::LDLIDAR_4 = 3, SensorType::LDLIDAR_1 = 4, SensorType::SHORT_RANGE_RADAR = 5, SensorType::LONG_RANGE_RADAR = 6, SensorType::MONOCULAR_CAMERA = 7, SensorType::STEREO_CAMERA = 8, SensorType::ULTRASONIC = 9, SensorType::VELODYNE_128 = 10, SensorType::SENSOR_TYPE_NUM }
	Sensor types are set in the order of lidar, radar, camera, ultrasonic Please make sure SensorType has same id with SensorMeta, which defined in the proto of sensor_manager. More...

enum	SensorOrientation { SensorOrientation::FRONT = 0, SensorOrientation::LEFT_FORWARD = 1, SensorOrientation::LEFT = 2, SensorOrientation::LEFT_BACKWARD = 3, SensorOrientation::REAR = 4, SensorOrientation::RIGHT_BACKWARD = 5, SensorOrientation::RIGHT = 6, SensorOrientation::RIGHT_FORWARD = 7, SensorOrientation::PANORAMIC = 8 }

enum	TLColor { TLColor::TL_UNKNOWN_COLOR = 0, TLColor::TL_RED = 1, TLColor::TL_YELLOW = 2, TLColor::TL_GREEN = 3, TLColor::TL_BLACK = 4, TLColor::TL_TOTAL_COLOR_NUM = 5 }

enum	TLDetectionClass { TLDetectionClass::TL_UNKNOWN_CLASS = -1, TLDetectionClass::TL_VERTICAL_CLASS = 0, TLDetectionClass::TL_QUADRATE_CLASS = 1, TLDetectionClass::TL_HORIZONTAL_CLASS = 2 }

Functions
template<typename T >
std::enable_if< std::is_integral< T >::value, bool >::type	Equal (const T &lhs, const T &rhs)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, bool >::type	Equal (const T &lhs, const T &rhs)

bool	DownSamplePointCloudBeams (base::PointFCloudPtr cloud_ptr, base::PointFCloudPtr out_cloud_ptr, int downsample_factor)

bool	GetPointCloudMinareaBbox (const base::PointFCloud &pc, BoundingCube *box, const int &min_num_points=5, const bool &verbose=false)

void	CloudDemean (base::PointFCloudPtr cloud)

void	GetPointCloudCentroid (base::PointFCloudConstPtr cloud, PointF *centroid)

double	OrientCloud (const PointFCloud &pc, PointFCloud *pc_out, bool demean)

std::ostream &	operator<< (std::ostream &o, const Polynomial &p)

void	PerceptionMallocHost (void **ptr, size_t size, bool use_cuda)

void	PerceptionFreeHost (void *ptr, bool use_cuda)

Variables
constexpr size_t	kMaxBlobAxes = 32

const std::map< Color, int >	kChannelsMap

struct apollo::perception::base::ImpendingCollisionEdges	EIGEN_ALIGN16

const std::map< VisualLandmarkType, std::string >	kVisualLandmarkType2NameMap

const std::map< std::string, base::VisualLandmarkType >	kVisualLandmarkName2TypeMap

const std::map< ObjectType, std::string >	kObjectType2NameMap

const std::map< std::string, ObjectType >	kObjectName2TypeMap

const std::map< VisualObjectType, ObjectType >	kVisualTypeMap

const std::map< VisualObjectType, std::string >	kVisualType2NameMap

const std::map< std::string, base::VisualObjectType >	kVisualName2TypeMap

const std::map< ObjectSubType, ObjectType >	kSubType2TypeMap

const std::map< ObjectSubType, std::string >	kSubType2NameMap

const std::map< std::string, ObjectSubType >	kName2SubTypeMap

const std::size_t	kDefaultReservePointNum = 50000

Typedef Documentation

◆ BaseCameraModelConstPtr

typedef std::shared_ptr<const BaseCameraModel> apollo::perception::base::BaseCameraModelConstPtr

◆ BaseCameraModelPtr

typedef std::shared_ptr<BaseCameraModel> apollo::perception::base::BaseCameraModelPtr

◆ BBox2DD

typedef BBox2D<double> apollo::perception::base::BBox2DD

◆ BBox2DF

typedef BBox2D<float> apollo::perception::base::BBox2DF

◆ BBox2DI

typedef BBox2D<int> apollo::perception::base::BBox2DI

◆ BlobConstPtr

template<typename Dtype >

using apollo::perception::base::BlobConstPtr = typedef std::shared_ptr<const Blob<Dtype> >

◆ BlobPtr

template<typename Dtype >

using apollo::perception::base::BlobPtr = typedef std::shared_ptr<Blob<Dtype> >

◆ BrownCameraDistortionModelConstPtr

using apollo::perception::base::BrownCameraDistortionModelConstPtr = typedef std::shared_ptr<const BrownCameraDistortionModel>

◆ BrownCameraDistortionModelPtr

using apollo::perception::base::BrownCameraDistortionModelPtr = typedef std::shared_ptr<BrownCameraDistortionModel>

◆ CameraFrameSupplementConstPtr

typedef std::shared_ptr<const CameraFrameSupplement> apollo::perception::base::CameraFrameSupplementConstPtr

◆ CameraFrameSupplementPtr

typedef std::shared_ptr<CameraFrameSupplement> apollo::perception::base::CameraFrameSupplementPtr

◆ CameraObjectSupplementConstPtr

typedef std::shared_ptr<const CameraObjectSupplement> apollo::perception::base::CameraObjectSupplementConstPtr

◆ CameraObjectSupplementPtr

typedef std::shared_ptr<CameraObjectSupplement> apollo::perception::base::CameraObjectSupplementPtr

◆ FrameConstPtr

typedef std::shared_ptr<const Frame> apollo::perception::base::FrameConstPtr

◆ FramePool

using apollo::perception::base::FramePool = typedef ConcurrentObjectPool<Frame, kFramePoolSize, FrameInitializer>

◆ FramePtr

typedef std::shared_ptr<Frame> apollo::perception::base::FramePtr

◆ HdmapStructConstPtr

using apollo::perception::base::HdmapStructConstPtr = typedef std::shared_ptr<const HdmapStruct>

◆ HdmapStructPtr

using apollo::perception::base::HdmapStructPtr = typedef std::shared_ptr<HdmapStruct>

◆ Image8UConstPtr

typedef std::shared_ptr<const Image8U> apollo::perception::base::Image8UConstPtr

◆ Image8UPtr

typedef std::shared_ptr<Image8U> apollo::perception::base::Image8UPtr

◆ LidarFrameSupplementConstPtr

typedef std::shared_ptr<const LidarFrameSupplement> apollo::perception::base::LidarFrameSupplementConstPtr

◆ LidarFrameSupplementPtr

typedef std::shared_ptr<LidarFrameSupplement> apollo::perception::base::LidarFrameSupplementPtr

◆ LidarObjectSupplementConstPtr

typedef std::shared_ptr<const LidarObjectSupplement> apollo::perception::base::LidarObjectSupplementConstPtr

◆ LidarObjectSupplementPtr

typedef std::shared_ptr<LidarObjectSupplement> apollo::perception::base::LidarObjectSupplementPtr

◆ Motion3DBuffer

typedef boost::circular_buffer<Vehicle3DStatus> apollo::perception::base::Motion3DBuffer

◆ Motion3DBufferConstPtr

typedef std::shared_ptr<const Motion3DBuffer> apollo::perception::base::Motion3DBufferConstPtr

◆ Motion3DBufferPtr

typedef std::shared_ptr<Motion3DBuffer> apollo::perception::base::Motion3DBufferPtr

◆ MotionBuffer

typedef boost::circular_buffer<VehicleStatus> apollo::perception::base::MotionBuffer

◆ MotionBufferConstPtr

typedef std::shared_ptr<const MotionBuffer> apollo::perception::base::MotionBufferConstPtr

◆ MotionBufferPtr

typedef std::shared_ptr<MotionBuffer> apollo::perception::base::MotionBufferPtr

◆ MotionType

typedef Eigen::Matrix4f apollo::perception::base::MotionType

◆ ObjectConstPtr

using apollo::perception::base::ObjectConstPtr = typedef std::shared_ptr<const Object>

◆ ObjectPool

using apollo::perception::base::ObjectPool = typedef ConcurrentObjectPool<Object, kObjectPoolSize, ObjectInitializer>

◆ ObjectPtr

using apollo::perception::base::ObjectPtr = typedef std::shared_ptr<Object>

◆ PinholeCameraModelConstPtr

typedef std::shared_ptr<const PinholeCameraModel> apollo::perception::base::PinholeCameraModelConstPtr

◆ PinholeCameraModelPtr

typedef std::shared_ptr<PinholeCameraModel> apollo::perception::base::PinholeCameraModelPtr

◆ Point2DD

using apollo::perception::base::Point2DD = typedef Point2D<double>

◆ Point2DF

using apollo::perception::base::Point2DF = typedef Point2D<float>

◆ Point2DI

using apollo::perception::base::Point2DI = typedef Point2D<int>

◆ Point3DD

using apollo::perception::base::Point3DD = typedef Point3D<double>

◆ Point3DF

using apollo::perception::base::Point3DF = typedef Point3D<float>

◆ Point3DI

using apollo::perception::base::Point3DI = typedef Point3D<int>

◆ PointD

using apollo::perception::base::PointD = typedef Point<double>

◆ PointDCloud

typedef AttributePointCloud<PointD> apollo::perception::base::PointDCloud

◆ PointDCloudConstPtr

typedef std::shared_ptr<const PointDCloud> apollo::perception::base::PointDCloudConstPtr

◆ PointDCloudPool

using apollo::perception::base::PointDCloudPool = typedef ConcurrentObjectPool<AttributePointCloud<PointD>, kPointCloudPoolSize, PointCloudInitializer<double> >

◆ PointDCloudPtr

typedef std::shared_ptr<PointDCloud> apollo::perception::base::PointDCloudPtr

◆ PointF

using apollo::perception::base::PointF = typedef Point<float>

◆ PointFCloud

typedef AttributePointCloud<PointF> apollo::perception::base::PointFCloud

◆ PointFCloudConstPtr

typedef std::shared_ptr<const PointFCloud> apollo::perception::base::PointFCloudConstPtr

◆ PointFCloudPool

using apollo::perception::base::PointFCloudPool = typedef ConcurrentObjectPool<AttributePointCloud<PointF>, kPointCloudPoolSize, PointCloudInitializer<float> >

◆ PointFCloudPtr

typedef std::shared_ptr<PointFCloud> apollo::perception::base::PointFCloudPtr

◆ PointIndicesConstPtr

typedef std::shared_ptr<const PointIndices> apollo::perception::base::PointIndicesConstPtr

◆ PointIndicesPtr

typedef std::shared_ptr<PointIndices> apollo::perception::base::PointIndicesPtr

◆ PointXYZID

using apollo::perception::base::PointXYZID = typedef Point<double>

◆ PointXYZIF

using apollo::perception::base::PointXYZIF = typedef Point<float>

◆ PointXYZITD

using apollo::perception::base::PointXYZITD = typedef PointXYZIT<double>

◆ PointXYZITF

using apollo::perception::base::PointXYZITF = typedef PointXYZIT<float>

◆ PointXYZITHBD

using apollo::perception::base::PointXYZITHBD = typedef PointXYZITHB<double>

◆ PointXYZITHBF

using apollo::perception::base::PointXYZITHBF = typedef PointXYZITHB<float>

◆ PointXYZITHBLD

using apollo::perception::base::PointXYZITHBLD = typedef PointXYZITHBL<double>

◆ PointXYZITHBLF

using apollo::perception::base::PointXYZITHBLF = typedef PointXYZITHBL<float>

◆ PointXYZITHD

using apollo::perception::base::PointXYZITHD = typedef PointXYZITH<double>

◆ PointXYZITHF

using apollo::perception::base::PointXYZITHF = typedef PointXYZITH<float>

◆ PolygonDType

typedef PointCloud<PointD> apollo::perception::base::PolygonDType

◆ PolygonDTypeConstPtr

typedef std::shared_ptr<const PolygonDType> apollo::perception::base::PolygonDTypeConstPtr

◆ PolygonDTypePtr

typedef std::shared_ptr<PolygonDType> apollo::perception::base::PolygonDTypePtr

◆ PolygonFType

typedef PointCloud<PointF> apollo::perception::base::PolygonFType

◆ PolygonFTypeConstPtr

typedef std::shared_ptr<const PolygonFType> apollo::perception::base::PolygonFTypeConstPtr

◆ PolygonFTypePtr

typedef std::shared_ptr<PolygonFType> apollo::perception::base::PolygonFTypePtr

◆ RadarFrameSupplementConstPtr

typedef std::shared_ptr<const RadarFrameSupplement> apollo::perception::base::RadarFrameSupplementConstPtr

◆ RadarFrameSupplementPtr

typedef std::shared_ptr<RadarFrameSupplement> apollo::perception::base::RadarFrameSupplementPtr

◆ RadarObjectSupplementConstPtr

typedef std::shared_ptr<const RadarObjectSupplement> apollo::perception::base::RadarObjectSupplementConstPtr

◆ RadarObjectSupplementPtr

typedef std::shared_ptr<RadarObjectSupplement> apollo::perception::base::RadarObjectSupplementPtr

◆ RectD

typedef Rect<double> apollo::perception::base::RectD

◆ RectF

typedef Rect<float> apollo::perception::base::RectF

◆ RectI

typedef Rect<int> apollo::perception::base::RectI

◆ TestDtypes

typedef ::testing::Types<float, double> apollo::perception::base::TestDtypes

◆ TestDtypesAndDevices

typedef ::testing::Types<CPUDevice<float>, CPUDevice<double> > apollo::perception::base::TestDtypesAndDevices

◆ TrafficLightPtr

typedef std::shared_ptr<TrafficLight> apollo::perception::base::TrafficLightPtr

◆ TrafficLightPtrs

typedef std::vector<TrafficLightPtr> apollo::perception::base::TrafficLightPtrs

◆ UltrasonicFrameSupplementConstPtr

typedef std::shared_ptr<const UltrasonicFrameSupplement> apollo::perception::base::UltrasonicFrameSupplementConstPtr

◆ UltrasonicFrameSupplementPtr

typedef std::shared_ptr<UltrasonicFrameSupplement> apollo::perception::base::UltrasonicFrameSupplementPtr

Enumeration Type Documentation

◆ Color

enum apollo::perception::base::Color

strong

Enumerator
NONE
GRAY
RGB
BGR

◆ InternalObjectType

enum apollo::perception::base::InternalObjectType

strong

Enumerator
INT_BACKGROUND
INT_SMALLMOT
INT_PEDESTRIAN
INT_NONMOT
INT_BIGMOT
INT_UNKNOWN
INT_MAX_OBJECT_TYPE

◆ LaneLinePositionType

enum apollo::perception::base::LaneLinePositionType

strong

Definition of the position of a lane marking in respect to the ego lane.

Enumerator
CURB_LEFT
FOURTH_LEFT
THIRD_LEFT
ADJACENT_LEFT	lane marking on the left side next to ego lane
EGO_LEFT	left lane marking of the ego lane
EGO_CENTER	center lane marking of the ego lane, changing lane
EGO_RIGHT	right lane marking of the ego lane
ADJACENT_RIGHT	lane marking on the right side next to ego lane
THIRD_RIGHT
FOURTH_RIGHT
CURB_RIGHT
OTHER	other types of lane
UNKNOWN	background

◆ LaneLineType

enum apollo::perception::base::LaneLineType

strong

Enumerator
WHITE_DASHED
WHITE_SOLID
YELLOW_DASHED
YELLOW_SOLID

◆ LaneLineUseType

enum apollo::perception::base::LaneLineUseType

strong

Enumerator
REAL
VIRTUAL

◆ MotionState

enum apollo::perception::base::MotionState

strong

Enumerator
UNKNOWN
MOVING
STATIONARY

◆ ObjectSubType

enum apollo::perception::base::ObjectSubType

strong

Enumerator
UNKNOWN
UNKNOWN_MOVABLE
UNKNOWN_UNMOVABLE
CAR
VAN
TRUCK
BUS
CYCLIST
MOTORCYCLIST
TRICYCLIST
PEDESTRIAN
TRAFFICCONE
MAX_OBJECT_TYPE

◆ ObjectType

enum apollo::perception::base::ObjectType

strong

Enumerator
UNKNOWN
UNKNOWN_MOVABLE
UNKNOWN_UNMOVABLE
PEDESTRIAN
BICYCLE
VEHICLE
MAX_OBJECT_TYPE

◆ SensorOrientation

enum apollo::perception::base::SensorOrientation

strong

Enumerator
FRONT
LEFT_FORWARD
LEFT
LEFT_BACKWARD
REAR
RIGHT_BACKWARD
RIGHT
RIGHT_FORWARD
PANORAMIC

◆ SensorType

enum apollo::perception::base::SensorType

strong

Sensor types are set in the order of lidar, radar, camera, ultrasonic Please make sure SensorType has same id with SensorMeta, which defined in the proto of sensor_manager.

Enumerator
UNKNOWN_SENSOR_TYPE
VELODYNE_64
VELODYNE_32
VELODYNE_16
LDLIDAR_4
LDLIDAR_1
SHORT_RANGE_RADAR
LONG_RANGE_RADAR
MONOCULAR_CAMERA
STEREO_CAMERA
ULTRASONIC
VELODYNE_128
SENSOR_TYPE_NUM

◆ TLColor

enum apollo::perception::base::TLColor

strong

Enumerator
TL_UNKNOWN_COLOR
TL_RED
TL_YELLOW
TL_GREEN
TL_BLACK
TL_TOTAL_COLOR_NUM

◆ TLDetectionClass

enum apollo::perception::base::TLDetectionClass

strong

Enumerator
TL_UNKNOWN_CLASS
TL_VERTICAL_CLASS
TL_QUADRATE_CLASS
TL_HORIZONTAL_CLASS

◆ VisualLandmarkType

enum apollo::perception::base::VisualLandmarkType

strong

Landmark types and mapping

Enumerator
RoadArrow
RoadText
TrafficSign
TrafficLight
MAX_LANDMARK_TYPE

◆ VisualObjectType

enum apollo::perception::base::VisualObjectType

strong

Enumerator
CAR
VAN
BUS
TRUCK
BICYCLE
TRICYCLE
PEDESTRIAN
TRAFFICCONE
UNKNOWN_MOVABLE
UNKNOWN_UNMOVABLE
MAX_OBJECT_TYPE

Function Documentation

◆ CloudDemean()

void apollo::perception::base::CloudDemean ( base::PointFCloudPtr cloud )

◆ DownSamplePointCloudBeams()

bool apollo::perception::base::DownSamplePointCloudBeams	(	base::PointFCloudPtr	cloud_ptr,
		base::PointFCloudPtr	out_cloud_ptr,
		int	downsample_factor
	)

◆ Equal() [1/2]

template<typename T >

std::enable_if<std::is_integral<T>::value, bool>::type apollo::perception::base::Equal	(	const T &	lhs,
		const T &	rhs
	)

◆ Equal() [2/2]

template<typename T >

std::enable_if<std::is_floating_point<T>::value, bool>::type apollo::perception::base::Equal	(	const T &	lhs,
		const T &	rhs
	)

◆ GetPointCloudCentroid()

void apollo::perception::base::GetPointCloudCentroid	(	base::PointFCloudConstPtr	cloud,
		PointF *	centroid
	)

◆ GetPointCloudMinareaBbox()

bool apollo::perception::base::GetPointCloudMinareaBbox	(	const base::PointFCloud &	pc,
		BoundingCube *	box,
		const int &	min_num_points = `5`,
		const bool &	verbose = `false`
	)

◆ operator<<()

std::ostream& apollo::perception::base::operator<<	(	std::ostream &	o,
		const Polynomial &	p
	)

◆ OrientCloud()

double apollo::perception::base::OrientCloud	(	const PointFCloud &	pc,
		PointFCloud *	pc_out,
		bool	demean
	)

◆ PerceptionFreeHost()

void apollo::perception::base::PerceptionFreeHost	(	void *	ptr,
		bool	use_cuda
	)

inline

◆ PerceptionMallocHost()

void apollo::perception::base::PerceptionMallocHost	(	void **	ptr,
		size_t	size,
		bool	use_cuda
	)

inline

Variable Documentation

◆ EIGEN_ALIGN16

struct apollo::perception::base::ImpendingCollisionEdges apollo::perception::base::EIGEN_ALIGN16

◆ kChannelsMap

const std::map<Color, int> apollo::perception::base::kChannelsMap

Initial value:

{

{Color::GRAY, 1}, {Color::RGB, 3}, {Color::BGR, 3}}

◆ kDefaultReservePointNum

const std::size_t apollo::perception::base::kDefaultReservePointNum = 50000

◆ kMaxBlobAxes

constexpr size_t apollo::perception::base::kMaxBlobAxes = 32

◆ kName2SubTypeMap

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

Initial value:

= {
    {"UNKNOWN", ObjectSubType::UNKNOWN},
    {"UNKNOWN_MOVABLE", ObjectSubType::UNKNOWN_MOVABLE},
    {"UNKNOWN_UNMOVABLE", ObjectSubType::UNKNOWN_UNMOVABLE},
    {"CAR", ObjectSubType::CAR},
    {"VAN", ObjectSubType::VAN},
    {"TRUCK", ObjectSubType::TRUCK},
    {"BUS", ObjectSubType::BUS},
    {"CYCLIST", ObjectSubType::CYCLIST},
    {"MOTORCYCLIST", ObjectSubType::MOTORCYCLIST},
    {"TRICYCLIST", ObjectSubType::TRICYCLIST},
    {"PEDESTRIAN", ObjectSubType::PEDESTRIAN},
    {"TRAFFICCONE", ObjectSubType::TRAFFICCONE},
    {"MAX_OBJECT_TYPE", ObjectSubType::MAX_OBJECT_TYPE},
}

◆ kObjectName2TypeMap

const std::map<std::string, ObjectType> apollo::perception::base::kObjectName2TypeMap

Initial value:

= {
    {"UNKNOWN", ObjectType::UNKNOWN},
    {"UNKNOWN_MOVABLE", ObjectType::UNKNOWN_MOVABLE},
    {"UNKNOWN_UNMOVABLE", ObjectType::UNKNOWN_UNMOVABLE},
    {"PEDESTRIAN", ObjectType::PEDESTRIAN},
    {"BICYCLE", ObjectType::BICYCLE},
    {"VEHICLE", ObjectType::VEHICLE},
    {"MAX_OBJECT_TYPE", ObjectType::MAX_OBJECT_TYPE}}

◆ kObjectType2NameMap

const std::map<ObjectType, std::string> apollo::perception::base::kObjectType2NameMap

Initial value:

= {
    {ObjectType::UNKNOWN, "UNKNOWN"},
    {ObjectType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
    {ObjectType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
    {ObjectType::PEDESTRIAN, "PEDESTRIAN"},
    {ObjectType::BICYCLE, "BICYCLE"},
    {ObjectType::VEHICLE, "VEHICLE"},
    {ObjectType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"}}

ObjectType mapping

◆ kSubType2NameMap

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

Initial value:

= {
    {ObjectSubType::UNKNOWN, "UNKNOWN"},
    {ObjectSubType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
    {ObjectSubType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
    {ObjectSubType::CAR, "CAR"},
    {ObjectSubType::VAN, "VAN"},
    {ObjectSubType::TRUCK, "TRUCK"},
    {ObjectSubType::BUS, "BUS"},
    {ObjectSubType::CYCLIST, "CYCLIST"},
    {ObjectSubType::MOTORCYCLIST, "MOTORCYCLIST"},
    {ObjectSubType::TRICYCLIST, "TRICYCLIST"},
    {ObjectSubType::PEDESTRIAN, "PEDESTRIAN"},
    {ObjectSubType::TRAFFICCONE, "TRAFFICCONE"},
    {ObjectSubType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"},
}

◆ kSubType2TypeMap

const std::map<ObjectSubType, ObjectType> apollo::perception::base::kSubType2TypeMap

Initial value:

= {
    {ObjectSubType::UNKNOWN, ObjectType::UNKNOWN},
    {ObjectSubType::UNKNOWN_MOVABLE, ObjectType::UNKNOWN_MOVABLE},
    {ObjectSubType::UNKNOWN_UNMOVABLE, ObjectType::UNKNOWN_UNMOVABLE},
    {ObjectSubType::CAR, ObjectType::VEHICLE},
    {ObjectSubType::VAN, ObjectType::VEHICLE},
    {ObjectSubType::TRUCK, ObjectType::VEHICLE},
    {ObjectSubType::BUS, ObjectType::VEHICLE},
    {ObjectSubType::CYCLIST, ObjectType::BICYCLE},
    {ObjectSubType::MOTORCYCLIST, ObjectType::BICYCLE},
    {ObjectSubType::TRICYCLIST, ObjectType::BICYCLE},
    {ObjectSubType::PEDESTRIAN, ObjectType::PEDESTRIAN},
    {ObjectSubType::TRAFFICCONE, ObjectType::UNKNOWN_UNMOVABLE},
    {ObjectSubType::MAX_OBJECT_TYPE, ObjectType::MAX_OBJECT_TYPE},
}

ObjectSubType mapping

◆ kVisualLandmarkName2TypeMap

const std::map<std::string, base::VisualLandmarkType> apollo::perception::base::kVisualLandmarkName2TypeMap

Initial value:

= {
        {"RoadArrow", VisualLandmarkType::RoadArrow},
        {"RoadText", VisualLandmarkType::RoadText},
        {"TrafficSign", VisualLandmarkType::TrafficSign},
        {"TrafficLight", VisualLandmarkType::TrafficLight},
}

◆ kVisualLandmarkType2NameMap

const std::map<VisualLandmarkType, std::string> apollo::perception::base::kVisualLandmarkType2NameMap

Initial value:

= {
    {VisualLandmarkType::RoadArrow, "RoadArrow"},
    {VisualLandmarkType::RoadText, "RoadText"},
    {VisualLandmarkType::TrafficSign, "TrafficSign"},
    {VisualLandmarkType::TrafficLight, "TrafficLight"},
}

◆ kVisualName2TypeMap

const std::map<std::string, base::VisualObjectType> apollo::perception::base::kVisualName2TypeMap

Initial value:

= {
    {"CAR", VisualObjectType::CAR},
    {"VAN", VisualObjectType::VAN},
    {"BUS", VisualObjectType::BUS},
    {"TRUCK", VisualObjectType::TRUCK},
    {"BICYCLE", VisualObjectType::BICYCLE},
    {"TRICYCLE", VisualObjectType::TRICYCLE},
    {"PEDESTRIAN", VisualObjectType::PEDESTRIAN},
    {"TRAFFICCONE", VisualObjectType::TRAFFICCONE},
    {"UNKNOWN_MOVABLE", VisualObjectType::UNKNOWN_MOVABLE},
    {"UNKNOWN_UNMOVABLE", VisualObjectType::UNKNOWN_UNMOVABLE},
    {"MAX_OBJECT_TYPE", VisualObjectType::MAX_OBJECT_TYPE},
}

◆ kVisualType2NameMap

const std::map<VisualObjectType, std::string> apollo::perception::base::kVisualType2NameMap

Initial value:

= {
    {VisualObjectType::CAR, "CAR"},
    {VisualObjectType::VAN, "VAN"},
    {VisualObjectType::BUS, "BUS"},
    {VisualObjectType::TRUCK, "TRUCK"},
    {VisualObjectType::BICYCLE, "BICYCLE"},
    {VisualObjectType::TRICYCLE, "TRICYCLE"},
    {VisualObjectType::PEDESTRIAN, "PEDESTRIAN"},
    {VisualObjectType::TRAFFICCONE, "TRAFFICCONE"},
    {VisualObjectType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
    {VisualObjectType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
    {VisualObjectType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"},
}

◆ kVisualTypeMap

const std::map<VisualObjectType, ObjectType> apollo::perception::base::kVisualTypeMap

Initial value:

= {
    {VisualObjectType::CAR, ObjectType::VEHICLE},
    {VisualObjectType::VAN, ObjectType::VEHICLE},
    {VisualObjectType::BUS, ObjectType::VEHICLE},
    {VisualObjectType::TRUCK, ObjectType::VEHICLE},
    {VisualObjectType::BICYCLE, ObjectType::BICYCLE},
    {VisualObjectType::TRICYCLE, ObjectType::BICYCLE},
    {VisualObjectType::PEDESTRIAN, ObjectType::PEDESTRIAN},
    {VisualObjectType::TRAFFICCONE, ObjectType::UNKNOWN_UNMOVABLE},
    {VisualObjectType::UNKNOWN_MOVABLE, ObjectType::UNKNOWN_MOVABLE},
    {VisualObjectType::UNKNOWN_UNMOVABLE, ObjectType::UNKNOWN_UNMOVABLE},
    {VisualObjectType::MAX_OBJECT_TYPE, ObjectType::MAX_OBJECT_TYPE},
}

VisualObjectType mapping

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BaseCameraModelConstPtr

◆ BaseCameraModelPtr

◆ BBox2DD

◆ BBox2DF

◆ BBox2DI

◆ BlobConstPtr

◆ BlobPtr

◆ BrownCameraDistortionModelConstPtr

◆ BrownCameraDistortionModelPtr

◆ CameraFrameSupplementConstPtr

◆ CameraFrameSupplementPtr

◆ CameraObjectSupplementConstPtr

◆ CameraObjectSupplementPtr

◆ FrameConstPtr

◆ FramePool

◆ FramePtr

◆ HdmapStructConstPtr

◆ HdmapStructPtr

◆ Image8UConstPtr

◆ Image8UPtr

◆ LidarFrameSupplementConstPtr

◆ LidarFrameSupplementPtr

◆ LidarObjectSupplementConstPtr

◆ LidarObjectSupplementPtr

◆ Motion3DBuffer

◆ Motion3DBufferConstPtr

◆ Motion3DBufferPtr

◆ MotionBuffer

◆ MotionBufferConstPtr

◆ MotionBufferPtr

◆ MotionType

◆ ObjectConstPtr

◆ ObjectPool

◆ ObjectPtr

◆ PinholeCameraModelConstPtr

◆ PinholeCameraModelPtr

◆ Point2DD

◆ Point2DF

◆ Point2DI

◆ Point3DD

◆ Point3DF

◆ Point3DI

◆ PointD

◆ PointDCloud

◆ PointDCloudConstPtr

◆ PointDCloudPool

◆ PointDCloudPtr

◆ PointF

◆ PointFCloud

◆ PointFCloudConstPtr

◆ PointFCloudPool

◆ PointFCloudPtr

◆ PointIndicesConstPtr

◆ PointIndicesPtr

◆ PointXYZID

◆ PointXYZIF

◆ PointXYZITD

◆ PointXYZITF

◆ PointXYZITHBD

◆ PointXYZITHBF

◆ PointXYZITHBLD

◆ PointXYZITHBLF

◆ PointXYZITHD

◆ PointXYZITHF

◆ PolygonDType

◆ PolygonDTypeConstPtr

◆ PolygonDTypePtr

◆ PolygonFType

◆ PolygonFTypeConstPtr

◆ PolygonFTypePtr

◆ RadarFrameSupplementConstPtr

◆ RadarFrameSupplementPtr

◆ RadarObjectSupplementConstPtr

◆ RadarObjectSupplementPtr