Apollo 10.0
自动驾驶开放平台
类 | 类型定义 | 枚举 | 函数 | 变量
apollo::perception::base 命名空间参考

类

class  AttributePointCloud
 
class  AttributeRadarPointCloud
 
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. 更多...
 
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. 更多...
 
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  Radar4dObjectSupplement
 
struct  RadarFrameSupplement
 
struct  RadarObjectSupplement
 
struct  RadarPoint
 
class  RadarPointCloud
 
struct  RadarPointCloudInitializer
 
struct  Rect
 
struct  RoadBoundary
 
struct  SensorInfo
 
struct  SensorObjectMeasurement
 
class  SyncedMemory
 Manages memory allocation and synchronization between the host (CPU) and device (GPU). 更多...
 
struct  TrafficLight
 
struct  UltrasonicFrameSupplement
 
struct  Vehicle3DStatus
 
struct  VehicleStatus
 

类型定义

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 RadarPointFCloudPool = ConcurrentObjectPool< AttributeRadarPointCloud< RadarPointF >, kPointCloudPoolSize, RadarPointCloudInitializer< double > >
 
using RadarPointDCloudPool = ConcurrentObjectPool< AttributeRadarPointCloud< RadarPointD >, kPointCloudPoolSize, RadarPointCloudInitializer< double > >
 
using FramePool = ConcurrentObjectPool< Frame, kFramePoolSize, FrameInitializer >
 
typedef std::shared_ptr< LidarObjectSupplement > LidarObjectSupplementPtr
 
typedef std::shared_ptr< const LidarObjectSupplement > LidarObjectSupplementConstPtr
 
typedef std::shared_ptr< Radar4dObjectSupplement > Radar4dObjectSupplementPtr
 
typedef std::shared_ptr< const Radar4dObjectSupplement > Radar4dObjectSupplementConstPtr
 
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 >
 
using RadarPointF = RadarPoint< float >
 
using RadarPointD = RadarPoint< double >
 
using RadarPointXYZVRF = RadarPoint< float >
 
using RadarPointXYZVRD = RadarPoint< 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 AttributeRadarPointCloud< RadarPointF > RadarPointFCloud
 
typedef AttributeRadarPointCloud< RadarPointD > RadarPointDCloud
 
typedef std::shared_ptr< RadarPointFCloud > RadarPointFCloudPtr
 
typedef std::shared_ptr< const RadarPointFCloud > RadarPointFCloudConstPtr
 
typedef std::shared_ptr< RadarPointDCloud > RadarPointDCloudPtr
 
typedef std::shared_ptr< const RadarPointDCloud > RadarPointDCloudConstPtr
 
typedef RadarPointCloud< PointF > RadarPolygonFType
 
typedef RadarPointCloud< PointD > RadarPolygonDType
 
typedef std::shared_ptr< RadarPolygonFType > RadarPolygonFTypePtr
 
typedef std::shared_ptr< const RadarPolygonFType > RadarPolygonFTypeConstPtr
 
typedef std::shared_ptr< RadarPolygonDType > RadarPolygonDTypePtr
 
typedef std::shared_ptr< const RadarPolygonDType > RadarPolygonDTypeConstPtr
 
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
 

枚举

enum class  Color { NONE = 0x00 , GRAY = 0x01 , RGB = 0x02 , BGR = 0x03 }
 
enum class  LaneLineType { WHITE_DASHED = 0 , WHITE_SOLID , YELLOW_DASHED , YELLOW_SOLID }
 
enum class  LaneLinePositionType {
  CURB_LEFT = -5 , FOURTH_LEFT = -4 , THIRD_LEFT = -3 , ADJACENT_LEFT = -2 ,
  EGO_LEFT = -1 , EGO_CENTER = 0 , EGO_RIGHT = 1 , ADJACENT_RIGHT = 2 ,
  THIRD_RIGHT = 3 , FOURTH_RIGHT = 4 , CURB_RIGHT = 5 , OTHER = 6 ,
  UNKNOWN = 7
}
 Definition of the position of a lane marking in respect to the ego lane. 更多...
 
enum class  LaneLineUseType { REAL = 0 , VIRTUAL }
 
enum class  ObjectType {
  UNKNOWN = 0 , UNKNOWN_MOVABLE = 1 , UNKNOWN_UNMOVABLE = 2 , PEDESTRIAN = 3 ,
  BICYCLE = 4 , VEHICLE = 5 , MAX_OBJECT_TYPE = 6
}
 
enum class  ObjectSemanticType {
  UNKNOWN = 0 , IGNORE = 1 , GROUND = 2 , OBJECT = 3 ,
  CURB = 4 , VEGETATION = 5 , FENCE = 6 , NOISE = 7 ,
  WALL = 8 , MAX_OBJECT_SEMANTIC_LABEL = 9
}
 
enum class  InternalObjectType {
  INT_BACKGROUND = 0 , INT_SMALLMOT = 1 , INT_PEDESTRIAN = 2 , INT_NONMOT = 3 ,
  INT_BIGMOT = 4 , INT_UNKNOWN = 5 , INT_MAX_OBJECT_TYPE = 6
}
 
enum class  VisualObjectType {
  CAR , VAN , BUS , TRUCK ,
  BICYCLE , TRICYCLE , PEDESTRIAN , TRAFFICCONE ,
  UNKNOWN_MOVABLE , UNKNOWN_UNMOVABLE , MAX_OBJECT_TYPE
}
 
enum class  ObjectSubType {
  UNKNOWN = 0 , UNKNOWN_MOVABLE = 1 , UNKNOWN_UNMOVABLE = 2 , CAR = 3 ,
  VAN = 4 , TRUCK = 5 , BUS = 6 , CYCLIST = 7 ,
  MOTORCYCLIST = 8 , TRICYCLIST = 9 , PEDESTRIAN = 10 , TRAFFICCONE = 11 ,
  SMALLMOT = 12 , BIGMOT = 13 , NONMOT = 14 , MAX_OBJECT_TYPE = 15
}
 
enum class  MotionState { UNKNOWN = 0 , MOVING = 1 , STATIONARY = 2 , MAX_MOTION_STATE }
 
enum class  VisualLandmarkType {
  RoadArrow , RoadText , TrafficSign , TrafficLight ,
  MAX_LANDMARK_TYPE
}
 Landmark types and mapping 更多...
 
enum class  SensorType {
  UNKNOWN_SENSOR_TYPE = -1 , VELODYNE_128 = 0 , VELODYNE_64 = 1 , VELODYNE_32 = 2 ,
  VELODYNE_16 = 3 , LDLIDAR_4 = 4 , LDLIDAR_1 = 5 , SHORT_RANGE_RADAR = 6 ,
  LONG_RANGE_RADAR = 7 , MONOCULAR_CAMERA = 8 , STEREO_CAMERA = 9 , ULTRASONIC = 10 ,
  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 更多...
 
enum class  SensorOrientation {
  FRONT = 0 , LEFT_FORWARD = 1 , LEFT = 2 , LEFT_BACKWARD = 3 ,
  REAR = 4 , RIGHT_BACKWARD = 5 , RIGHT = 6 , RIGHT_FORWARD = 7 ,
  PANORAMIC = 8
}
 
enum class  TLColor {
  TL_UNKNOWN_COLOR = 0 , TL_RED = 1 , TL_YELLOW = 2 , TL_GREEN = 3 ,
  TL_BLACK = 4 , TL_TOTAL_COLOR_NUM = 5
}
 
enum class  TLDetectionClass { TL_UNKNOWN_CLASS = -1 , TL_VERTICAL_CLASS = 0 , TL_QUADRATE_CLASS = 1 , TL_HORIZONTAL_CLASS = 2 }
 

函数

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)
 
void GetMaxScoreIndex (const std::vector< float > &scores, const float threshold, const int top_k, std::vector< std::pair< float, int > > *score_index_vec)
 
template<typename BoxType >
void Nms (const std::vector< BoxType > &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, float(*ComputeOverlap)(const BoxType &, const BoxType &), int limit=std::numeric_limits< int >::max)
 
 __attribute__ ((constructor)) void PoolInitialize()
 
bool DownSamplePointCloudBeams (base::PointFCloudPtr cloud_ptr, base::PointFCloudPtr out_cloud_ptr, int downsample_factor)
 
void GetPointCloudCentroid (const PointFCloud &cloud, PointF *centroid)
 
void CloudDemean (PointFCloud *pc)
 
double OrientCloud (const PointFCloud &pc, PointFCloud *pc_out, bool demean)
 
bool GetPointCloudMinareaBbox (const PointFCloud &pc, BoundingCube *box, const int &min_num_points, const bool &verbose)
 
void CloudDemean (base::PointFCloudPtr cloud)
 
void GetPointCloudCentroid (base::PointFCloudConstPtr cloud, PointF *centroid)
 
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)
 

变量

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
 ObjectType mapping
 
const std::map< std::string, ObjectType > kObjectName2TypeMap
 
const std::map< ObjectSemanticType, std::string > kObjectSemanticType2NameMap
 ObjectSemanticType mapping
 
const std::map< std::string, ObjectSemanticType > kName2ObjectSemanticTypeMap
 
const std::map< VisualObjectType, ObjectType > kVisualTypeMap
 VisualObjectType mapping
 
const std::map< VisualObjectType, std::string > kVisualType2NameMap
 
const std::map< std::string, base::VisualObjectType > kVisualName2TypeMap
 
const std::map< ObjectSubType, ObjectType > kSubType2TypeMap
 ObjectSubType mapping
 
const std::map< ObjectSubType, std::string > kSubType2NameMap
 
const std::map< std::string, ObjectSubType > kName2SubTypeMap
 
const std::size_t kDefaultReservePointNum = 50000
 

类型定义说明

◆ BaseCameraModelConstPtr

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

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

◆ BaseCameraModelPtr

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

在文件 camera.h 第 75 行定义.

◆ BBox2DD

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

在文件 box.h 第 165 行定义.

◆ BBox2DF

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

在文件 box.h 第 164 行定义.

◆ BBox2DI

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

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

◆ BlobConstPtr

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

在文件 blob.h 第 315 行定义.

◆ BlobPtr

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

在文件 blob.h 第 313 行定义.

◆ BrownCameraDistortionModelConstPtr

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

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

◆ BrownCameraDistortionModelPtr

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

在文件 distortion_model.h 第 88 行定义.

◆ CameraFrameSupplementConstPtr

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

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

◆ CameraFrameSupplementPtr

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

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

◆ CameraObjectSupplementConstPtr

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

在文件 object_supplement.h 第 251 行定义.

◆ CameraObjectSupplementPtr

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

在文件 object_supplement.h 第 249 行定义.

◆ FrameConstPtr

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

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

◆ FramePool

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

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

◆ FramePtr

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

在文件 frame.h 第 60 行定义.

◆ HdmapStructConstPtr

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

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

◆ HdmapStructPtr

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

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

◆ Image8UConstPtr

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

在文件 image_8u.h 第 149 行定义.

◆ Image8UPtr

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

在文件 image_8u.h 第 148 行定义.

◆ LidarFrameSupplementConstPtr

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

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

◆ LidarFrameSupplementPtr

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

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

◆ LidarObjectSupplementConstPtr

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

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

◆ LidarObjectSupplementPtr

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

在文件 object_supplement.h 第 89 行定义.

◆ Motion3DBuffer

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

在文件 object_supplement.h 第 287 行定义.

◆ Motion3DBufferConstPtr

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

在文件 object_supplement.h 第 289 行定义.

◆ Motion3DBufferPtr

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

在文件 object_supplement.h 第 288 行定义.

◆ MotionBuffer

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

在文件 object_supplement.h 第 269 行定义.

◆ MotionBufferConstPtr

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

在文件 object_supplement.h 第 271 行定义.

◆ MotionBufferPtr

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

在文件 object_supplement.h 第 270 行定义.

◆ MotionType

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

在文件 object_supplement.h 第 253 行定义.

◆ ObjectConstPtr

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

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

◆ ObjectPool

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

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

◆ ObjectPtr

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

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

◆ PinholeCameraModelConstPtr

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

在文件 camera.h 第 78 行定义.

◆ PinholeCameraModelPtr

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

在文件 camera.h 第 77 行定义.

◆ Point2DD

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

在文件 point.h 第 89 行定义.

◆ Point2DF

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

在文件 point.h 第 87 行定义.

◆ Point2DI

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

在文件 point.h 第 88 行定义.

◆ Point3DD

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

在文件 point.h 第 100 行定义.

◆ Point3DF

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

在文件 point.h 第 98 行定义.

◆ Point3DI

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

在文件 point.h 第 99 行定义.

◆ PointD

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

在文件 point.h 第 57 行定义.

◆ PointDCloud

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

在文件 point_cloud.h 第 515 行定义.

◆ PointDCloudConstPtr

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

在文件 point_cloud.h 第 521 行定义.

◆ PointDCloudPool

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

在文件 object_pool_types.h 第 60 行定义.

◆ PointDCloudPtr

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

在文件 point_cloud.h 第 520 行定义.

◆ PointF

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

在文件 point.h 第 56 行定义.

◆ PointFCloud

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

在文件 point_cloud.h 第 514 行定义.

◆ PointFCloudConstPtr

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

在文件 point_cloud.h 第 518 行定义.

◆ PointFCloudPool

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

在文件 object_pool_types.h 第 56 行定义.

◆ PointFCloudPtr

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

在文件 point_cloud.h 第 517 行定义.

◆ PointIndicesConstPtr

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

在文件 point_cloud.h 第 511 行定义.

◆ PointIndicesPtr

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

在文件 point_cloud.h 第 510 行定义.

◆ PointXYZID

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

在文件 point.h 第 60 行定义.

◆ PointXYZIF

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

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

◆ PointXYZITD

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

在文件 point.h 第 62 行定义.

◆ PointXYZITF

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

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

◆ PointXYZITHBD

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

在文件 point.h 第 66 行定义.

◆ PointXYZITHBF

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

在文件 point.h 第 65 行定义.

◆ PointXYZITHBLD

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

在文件 point.h 第 68 行定义.

◆ PointXYZITHBLF

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

在文件 point.h 第 67 行定义.

◆ PointXYZITHD

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

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

◆ PointXYZITHF

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

在文件 point.h 第 63 行定义.

◆ PolygonDType

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

在文件 point_cloud.h 第 525 行定义.

◆ PolygonDTypeConstPtr

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

在文件 point_cloud.h 第 531 行定义.

◆ PolygonDTypePtr

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

在文件 point_cloud.h 第 530 行定义.

◆ PolygonFType

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

在文件 point_cloud.h 第 524 行定义.

◆ PolygonFTypeConstPtr

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

在文件 point_cloud.h 第 528 行定义.

◆ PolygonFTypePtr

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

在文件 point_cloud.h 第 527 行定义.

◆ Radar4dObjectSupplementConstPtr

typedef std::shared_ptr<const Radar4dObjectSupplement> apollo::perception::base::Radar4dObjectSupplementConstPtr

在文件 object_supplement.h 第 139 行定义.

◆ Radar4dObjectSupplementPtr

typedef std::shared_ptr<Radar4dObjectSupplement> apollo::perception::base::Radar4dObjectSupplementPtr

在文件 object_supplement.h 第 137 行定义.

◆ RadarFrameSupplementConstPtr

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

在文件 frame_supplement.h 第 53 行定义.

◆ RadarFrameSupplementPtr

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

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

◆ RadarObjectSupplementConstPtr

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

在文件 object_supplement.h 第 165 行定义.

◆ RadarObjectSupplementPtr

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

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

◆ RadarPointD

using apollo::perception::base::RadarPointD = typedef RadarPoint<double>

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

◆ RadarPointDCloud

typedef AttributeRadarPointCloud<RadarPointD> apollo::perception::base::RadarPointDCloud

在文件 radar_point_cloud.h 第 403 行定义.

◆ RadarPointDCloudConstPtr

typedef std::shared_ptr<const RadarPointDCloud> apollo::perception::base::RadarPointDCloudConstPtr

在文件 radar_point_cloud.h 第 409 行定义.

◆ RadarPointDCloudPool

using apollo::perception::base::RadarPointDCloudPool = typedef ConcurrentObjectPool<AttributeRadarPointCloud<RadarPointD>, kPointCloudPoolSize, RadarPointCloudInitializer<double> >

在文件 object_pool_types.h 第 68 行定义.

◆ RadarPointDCloudPtr

typedef std::shared_ptr<RadarPointDCloud> apollo::perception::base::RadarPointDCloudPtr

在文件 radar_point_cloud.h 第 408 行定义.

◆ RadarPointF

using apollo::perception::base::RadarPointF = typedef RadarPoint<float>

在文件 point.h 第 113 行定义.

◆ RadarPointFCloud

typedef AttributeRadarPointCloud<RadarPointF> apollo::perception::base::RadarPointFCloud

在文件 radar_point_cloud.h 第 402 行定义.

◆ RadarPointFCloudConstPtr

typedef std::shared_ptr<const RadarPointFCloud> apollo::perception::base::RadarPointFCloudConstPtr

在文件 radar_point_cloud.h 第 406 行定义.

◆ RadarPointFCloudPool

using apollo::perception::base::RadarPointFCloudPool = typedef ConcurrentObjectPool<AttributeRadarPointCloud<RadarPointF>, kPointCloudPoolSize, RadarPointCloudInitializer<double> >

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

◆ RadarPointFCloudPtr

typedef std::shared_ptr<RadarPointFCloud> apollo::perception::base::RadarPointFCloudPtr

在文件 radar_point_cloud.h 第 405 行定义.

◆ RadarPointXYZVRD

using apollo::perception::base::RadarPointXYZVRD = typedef RadarPoint<double>

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

◆ RadarPointXYZVRF

using apollo::perception::base::RadarPointXYZVRF = typedef RadarPoint<float>

在文件 point.h 第 115 行定义.

◆ RadarPolygonDType

typedef RadarPointCloud<PointD> apollo::perception::base::RadarPolygonDType

在文件 radar_point_cloud.h 第 413 行定义.

◆ RadarPolygonDTypeConstPtr

typedef std::shared_ptr<const RadarPolygonDType> apollo::perception::base::RadarPolygonDTypeConstPtr

在文件 radar_point_cloud.h 第 419 行定义.

◆ RadarPolygonDTypePtr

typedef std::shared_ptr<RadarPolygonDType> apollo::perception::base::RadarPolygonDTypePtr

在文件 radar_point_cloud.h 第 418 行定义.

◆ RadarPolygonFType

typedef RadarPointCloud<PointF> apollo::perception::base::RadarPolygonFType

在文件 radar_point_cloud.h 第 412 行定义.

◆ RadarPolygonFTypeConstPtr

typedef std::shared_ptr<const RadarPolygonFType> apollo::perception::base::RadarPolygonFTypeConstPtr

在文件 radar_point_cloud.h 第 416 行定义.

◆ RadarPolygonFTypePtr

typedef std::shared_ptr<RadarPolygonFType> apollo::perception::base::RadarPolygonFTypePtr

在文件 radar_point_cloud.h 第 415 行定义.

◆ RectD

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

在文件 box.h 第 161 行定义.

◆ RectF

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

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

◆ RectI

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

在文件 box.h 第 159 行定义.

◆ TestDtypes

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

在文件 test_helper.h 第 38 行定义.

◆ TestDtypesAndDevices

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

在文件 test_helper.h 第 52 行定义.

◆ TrafficLightPtr

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

在文件 traffic_light.h 第 88 行定义.

◆ TrafficLightPtrs

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

在文件 traffic_light.h 第 89 行定义.

◆ UltrasonicFrameSupplementConstPtr

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

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

◆ UltrasonicFrameSupplementPtr

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

在文件 frame_supplement.h 第 89 行定义.

枚举类型说明

◆ Color

enum class apollo::perception::base::Color
strong
枚举值
NONE 
GRAY 
RGB 
BGR 

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

28 {
29 NONE = 0x00,
30 GRAY = 0x01,
31 RGB = 0x02,
32 BGR = 0x03,
33};

◆ InternalObjectType

enum class apollo::perception::base::InternalObjectType
strong
枚举值
INT_BACKGROUND 
INT_SMALLMOT 
INT_PEDESTRIAN 
INT_NONMOT 
INT_BIGMOT 
INT_UNKNOWN 
INT_MAX_OBJECT_TYPE 

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

51 {
52 INT_BACKGROUND = 0,
53 INT_SMALLMOT = 1,
54 INT_PEDESTRIAN = 2,
55 INT_NONMOT = 3,
56 INT_BIGMOT = 4,
57 INT_UNKNOWN = 5,
58 INT_MAX_OBJECT_TYPE = 6,
59};

◆ LaneLinePositionType

enum class apollo::perception::base::LaneLinePositionType
strong

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

枚举值
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

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

34 {
35 CURB_LEFT = -5,
36 FOURTH_LEFT = -4,
37 THIRD_LEFT = -3,
38 ADJACENT_LEFT = -2,
39 EGO_LEFT = -1,
40 EGO_CENTER = 0,
41 EGO_RIGHT = 1,
42 ADJACENT_RIGHT = 2,
43 THIRD_RIGHT = 3,
44 FOURTH_RIGHT = 4,
45 CURB_RIGHT = 5,
46 OTHER = 6,
47 UNKNOWN = 7
48};
apollo::perception::base::LaneLinePositionType::ADJACENT_RIGHT
@ ADJACENT_RIGHT
lane marking on the right side next to ego lane
apollo::perception::base::LaneLinePositionType::ADJACENT_LEFT
@ ADJACENT_LEFT
lane marking on the left side next to ego lane
apollo::perception::base::LaneLinePositionType::EGO_LEFT
@ EGO_LEFT
left lane marking of the ego lane
apollo::perception::base::LaneLinePositionType::EGO_CENTER
@ EGO_CENTER
center lane marking of the ego lane, changing lane
apollo::perception::base::LaneLinePositionType::EGO_RIGHT
@ EGO_RIGHT
right lane marking of the ego lane

◆ LaneLineType

enum class apollo::perception::base::LaneLineType
strong
枚举值
WHITE_DASHED 
WHITE_SOLID 
YELLOW_DASHED 
YELLOW_SOLID 

在文件 lane_struct.h 第 26 行定义.

26 {
27 WHITE_DASHED = 0,
28 WHITE_SOLID,
29 YELLOW_DASHED,
30 YELLOW_SOLID
31};

◆ LaneLineUseType

enum class apollo::perception::base::LaneLineUseType
strong
枚举值
REAL 
VIRTUAL 

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

51{ REAL = 0, VIRTUAL };

◆ MotionState

enum class apollo::perception::base::MotionState
strong
枚举值
UNKNOWN 
MOVING 
STATIONARY 
MAX_MOTION_STATE 

在文件 object_types.h 第 99 行定义.

99 {
100 UNKNOWN = 0,
101 MOVING = 1,
102 STATIONARY = 2,
103 MAX_MOTION_STATE,
104};

◆ ObjectSemanticType

enum class apollo::perception::base::ObjectSemanticType
strong
枚举值
UNKNOWN 
IGNORE 
GROUND 
OBJECT 
CURB 
VEGETATION 
FENCE 
NOISE 
WALL 
MAX_OBJECT_SEMANTIC_LABEL 

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

37 {
38 UNKNOWN = 0,
39 IGNORE = 1,
40 GROUND = 2,
41 OBJECT = 3,
42 CURB = 4,
43 VEGETATION = 5,
44 FENCE = 6,
45 NOISE = 7,
46 WALL = 8,
47 MAX_OBJECT_SEMANTIC_LABEL = 9,
48};

◆ ObjectSubType

enum class apollo::perception::base::ObjectSubType
strong
枚举值
UNKNOWN 
UNKNOWN_MOVABLE 
UNKNOWN_UNMOVABLE 
CAR 
VAN 
TRUCK 
BUS 
CYCLIST 
MOTORCYCLIST 
TRICYCLIST 
PEDESTRIAN 
TRAFFICCONE 
SMALLMOT 
BIGMOT 
NONMOT 
MAX_OBJECT_TYPE 

在文件 object_types.h 第 77 行定义.

77 {
78 UNKNOWN = 0,
79 UNKNOWN_MOVABLE = 1,
80 UNKNOWN_UNMOVABLE = 2,
81 CAR = 3,
82 VAN = 4,
83 TRUCK = 5,
84 BUS = 6,
85 CYCLIST = 7,
86 MOTORCYCLIST = 8,
87 TRICYCLIST = 9,
88 PEDESTRIAN = 10,
89 TRAFFICCONE = 11,
90 SMALLMOT = 12,
91 BIGMOT = 13,
92 NONMOT = 14,
93 // Attention(lordon): matrix dimensions in type_change_cost file need to be
94 // the same
95 MAX_OBJECT_TYPE = 15,
96};

◆ ObjectType

enum class apollo::perception::base::ObjectType
strong
枚举值
UNKNOWN 
UNKNOWN_MOVABLE 
UNKNOWN_UNMOVABLE 
PEDESTRIAN 
BICYCLE 
VEHICLE 
MAX_OBJECT_TYPE 

在文件 object_types.h 第 26 行定义.

26 {
27 UNKNOWN = 0,
28 UNKNOWN_MOVABLE = 1,
29 UNKNOWN_UNMOVABLE = 2,
30 PEDESTRIAN = 3,
31 BICYCLE = 4,
32 VEHICLE = 5,
33 MAX_OBJECT_TYPE = 6,
34};

◆ SensorOrientation

enum class apollo::perception::base::SensorOrientation
strong
枚举值
FRONT 
LEFT_FORWARD 
LEFT 
LEFT_BACKWARD 
REAR 
RIGHT_BACKWARD 
RIGHT 
RIGHT_FORWARD 
PANORAMIC 

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

45 {
46 FRONT = 0,
47 LEFT_FORWARD = 1,
48 LEFT = 2,
49 LEFT_BACKWARD = 3,
50 REAR = 4,
51 RIGHT_BACKWARD = 5,
52 RIGHT = 6,
53 RIGHT_FORWARD = 7,
54 PANORAMIC = 8
55};

◆ SensorType

enum class 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

枚举值
UNKNOWN_SENSOR_TYPE 
VELODYNE_128 
VELODYNE_64 
VELODYNE_32 
VELODYNE_16 
LDLIDAR_4 
LDLIDAR_1 
SHORT_RANGE_RADAR 
LONG_RANGE_RADAR 
MONOCULAR_CAMERA 
STEREO_CAMERA 
ULTRASONIC 
SENSOR_TYPE_NUM 

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

29 {
30 UNKNOWN_SENSOR_TYPE = -1,
31 VELODYNE_128 = 0,
32 VELODYNE_64 = 1,
33 VELODYNE_32 = 2,
34 VELODYNE_16 = 3,
35 LDLIDAR_4 = 4,
36 LDLIDAR_1 = 5,
37 SHORT_RANGE_RADAR = 6,
38 LONG_RANGE_RADAR = 7,
39 MONOCULAR_CAMERA = 8,
40 STEREO_CAMERA = 9,
41 ULTRASONIC = 10,
42 SENSOR_TYPE_NUM
43};

◆ TLColor

enum class apollo::perception::base::TLColor
strong
枚举值
TL_UNKNOWN_COLOR 
TL_RED 
TL_YELLOW 
TL_GREEN 
TL_BLACK 
TL_TOTAL_COLOR_NUM 

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

28 {
29 TL_UNKNOWN_COLOR = 0,
30 TL_RED = 1,
31 TL_YELLOW = 2,
32 TL_GREEN = 3,
33 TL_BLACK = 4,
34 TL_TOTAL_COLOR_NUM = 5
35};

◆ TLDetectionClass

enum class apollo::perception::base::TLDetectionClass
strong
枚举值
TL_UNKNOWN_CLASS 
TL_VERTICAL_CLASS 
TL_QUADRATE_CLASS 
TL_HORIZONTAL_CLASS 

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

37 {
38 TL_UNKNOWN_CLASS = -1,
39 TL_VERTICAL_CLASS = 0,
40 TL_QUADRATE_CLASS = 1,
41 TL_HORIZONTAL_CLASS = 2
42};

◆ VisualLandmarkType

enum class apollo::perception::base::VisualLandmarkType
strong

Landmark types and mapping

枚举值
RoadArrow 
RoadText 
TrafficSign 
TrafficLight 
MAX_LANDMARK_TYPE 

在文件 object_types.h 第 109 行定义.

109 {
110 RoadArrow,
111 RoadText,
112 TrafficSign,
113 TrafficLight,
114 MAX_LANDMARK_TYPE,
115};

◆ VisualObjectType

enum class apollo::perception::base::VisualObjectType
strong
枚举值
CAR 
VAN 
BUS 
TRUCK 
BICYCLE 
TRICYCLE 
PEDESTRIAN 
TRAFFICCONE 
UNKNOWN_MOVABLE 
UNKNOWN_UNMOVABLE 
MAX_OBJECT_TYPE 

在文件 object_types.h 第 62 行定义.

62 {
63 CAR,
64 VAN,
65 BUS,
66 TRUCK,
67 BICYCLE,
68 TRICYCLE,
69 PEDESTRIAN,
70 TRAFFICCONE,
71 UNKNOWN_MOVABLE,
72 UNKNOWN_UNMOVABLE,
73 MAX_OBJECT_TYPE,
74};

函数说明

◆ __attribute__()

apollo::perception::base::__attribute__ ( (constructor)  )

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

25 {
26 ObjectPool::Instance();
27 PointFCloudPool::Instance();
28 PointDCloudPool::Instance();
29 FramePool::Instance();
30#ifndef PERCEPTION_BASE_DISABLE_POOL
31 AINFO << "Initialize base object pool (no-malloc).";
32#else
33 AINFO << "Initialize base object pool (malloc).";
34#endif
35}
AINFO
#define AINFO
Definition log.h:42

◆ CloudDemean() [1/2]

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

◆ CloudDemean() [2/2]

void apollo::perception::base::CloudDemean ( PointFCloud *  pc)

在文件 point_cloud_util.cc 第 59 行定义.

59 {
60 // Demean by using centroid.
61 PointF centroid;
62 GetPointCloudCentroid(*pc, &centroid);
63 for (size_t i = 0; i < pc->size(); ++i) {
64 (*pc)[i].x -= centroid.x;
65 (*pc)[i].y -= centroid.y;
66 (*pc)[i].z -= centroid.z;
67 }
68}
apollo::perception::base::GetPointCloudCentroid
void GetPointCloudCentroid(const PointFCloud &cloud, PointF *centroid)
Definition point_cloud_util.cc:48

◆ DownSamplePointCloudBeams()

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

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

31 {
32 if (downsample_factor <= 0) {
33 return false;
34 }
35 for (size_t i = 0; i < cloud_ptr->size(); ++i) {
36 int32_t beam_id = cloud_ptr->points_beam_id(i);
37 if (beam_id % downsample_factor == 0) {
38 base::PointF point = cloud_ptr->at(i);
39 double timestamp = cloud_ptr->points_timestamp(i);
40 float height = cloud_ptr->points_height(i);
41 uint8_t label = cloud_ptr->points_label(i);
42 out_cloud_ptr->push_back(point, timestamp, height, beam_id, label);
43 }
44 }
45 return true;
46}

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

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

29 {
30 return lhs == rhs;
31}

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

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

36 {
37 return std::fabs(lhs - rhs) < std::numeric_limits<T>::epsilon();
38}

◆ GetMaxScoreIndex()

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

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

32 {
33 ACHECK(score_index_vec != nullptr);
34
35 for (size_t i = 0; i < scores.size(); ++i) {
36 if (scores[i] > threshold) {
37 score_index_vec->emplace_back(scores[i], i);
38 }
39 }
40
41 std::sort(score_index_vec->begin(), score_index_vec->end(),
42 [](const std::pair<float, int> &a, const std::pair<float, int> &b) {
43 return a.first > b.first;
44 });
45
46 if (top_k > 0 && top_k < static_cast<int>(score_index_vec->size())) {
47 score_index_vec->resize(top_k);
48 }
49}
ACHECK
#define ACHECK(cond)
Definition log.h:80

◆ GetPointCloudCentroid() [1/2]

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

◆ GetPointCloudCentroid() [2/2]

void apollo::perception::base::GetPointCloudCentroid ( const PointFCloud &  cloud,
PointF *  centroid 
)

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

48 {
49 for (size_t i = 0; i < cloud.size(); ++i) {
50 centroid->x += cloud[i].x;
51 centroid->y += cloud[i].y;
52 centroid->z += cloud[i].z;
53 }
54 centroid->x /= static_cast<float>(cloud.size());
55 centroid->y /= static_cast<float>(cloud.size());
56 centroid->z /= static_cast<float>(cloud.size());
57}

◆ GetPointCloudMinareaBbox()

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

在文件 point_cloud_util.cc 第 93 行定义.

94 {
95 if (pc.size() <= static_cast<size_t>(min_num_points)) {
96 return false;
97 }
98 std::vector<cv::Point2f> pts;
99 float min_z = std::numeric_limits<float>::max();
100 float max_z = -std::numeric_limits<float>::max();
101 for (size_t i = 0; i < pc.size(); ++i) {
102 pts.push_back(cv::Point2f(pc[i].x, pc[i].y));
103 min_z = std::min(min_z, pc[i].z);
104 max_z = std::max(max_z, pc[i].z);
105 }
106 // compute MinAreaRect
107 cv::RotatedRect mar = cv::minAreaRect(pts);
108 // adjust angle
109 if (mar.size.width < mar.size.height) {
110 mar.angle -= 90;
111 float tmp = mar.size.width;
112 mar.size.width = mar.size.height;
113 mar.size.height = tmp;
114 }
115 if (verbose) {
116 AINFO << "center = " << mar.center.x << " " << mar.center.y << std::endl;
117 AINFO << "size = " << mar.size.height << " " << mar.size.width << std::endl;
118 AINFO << "yaw = " << mar.angle << std::endl;
119 AINFO << "height = " << max_z - min_z << std::endl;
120 }
121 box->x = mar.center.x;
122 box->y = mar.center.y;
123 box->z = static_cast<float>((min_z + max_z) / 2.0);
124 box->length = mar.size.width;
125 box->width = mar.size.height;
126 box->height = max_z - min_z;
127 box->yaw = static_cast<float>((M_PI * (mar.angle + 180)) / 180);
128 return true;
129}

◆ Nms()

template<typename BoxType >
void apollo::perception::base::Nms ( const std::vector< BoxType > &  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,
float(*)(const BoxType &, const BoxType &)  ComputeOverlap,
int  limit = std::numeric_limits<int>::max 
)

在文件 nms.h 第 52 行定义.

56 {
57 ACHECK(bboxes.size() == scores.size());
58 ACHECK(indices != nullptr);
59
60 std::vector<std::pair<float, int>> score_index_vec;
61 GetMaxScoreIndex(scores, score_threshold, top_k, &score_index_vec);
62
63 float adaptive_threshold = nms_threshold;
64 indices->clear();
65 for (const std::pair<float, int> &score_index : score_index_vec) {
66 const int idx = score_index.second;
67 bool keep = true;
68 for (const int &kept_idx : *indices) {
69 float overlap = ComputeOverlap(bboxes[idx], bboxes[kept_idx]);
70 if (overlap > adaptive_threshold) {
71 keep = false;
72 break;
73 }
74 }
75
76 if (keep) {
77 indices->push_back(idx);
78 if (static_cast<int>(indices->size()) >= limit) {
79 break;
80 }
81 }
82
83 if (keep && eta < 1 && adaptive_threshold > 0.5) {
84 adaptive_threshold *= eta;
85 }
86 }
87}
apollo::perception::base::GetMaxScoreIndex
void GetMaxScoreIndex(const std::vector< float > &scores, const float threshold, const int top_k, std::vector< std::pair< float, int > > *score_index_vec)
Definition nms.h:30

◆ operator<<()

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

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

71 {
72 const std::map<uint32_t, double>& coeff = p.getCoeff();
73 size_t i = 0;
74 const size_t coeff_num = coeff.size();
75 for (auto it = coeff.rbegin(); it != coeff.rend(); ++it) {
76 const uint32_t order = it->first;
77 const double c = it->second;
78
79 o << "(" << c << ")*(t^" << order << ")";
80 if (i < coeff_num - 1) {
81 o << " + ";
82 }
83 ++i;
84 }
85 return o;
86}
apollo::perception::base::Polynomial::getCoeff
const std::map< uint32_t, double > & getCoeff() const
Definition polynomial.cc:25

◆ OrientCloud()

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

在文件 point_cloud_util.cc 第 70 行定义.

70 {
71 // Approach#1:
72 // Find car dominant direction on XY plane.
73 /*Eigen::VectorXf coeff;
74 find_dominant_direction_xy(pc, coeff);
75 // This theta has ambiguity. To calculate the true heading,
76 // we need to consider both obstacle's velocity direction and
77 // robot's current velocity direction.
78 double theta = atan2(coeff[4], coeff[3]);*/
79 // Approach#2:
80 // Use Minimum Area Bounding Box
81 BoundingCube bbox;
82 GetPointCloudMinareaBbox(pc, &bbox);
83 float theta = static_cast<float>(bbox.yaw);
84 Eigen::Affine3f transform = Eigen::Affine3f::Identity();
85 transform.rotate(Eigen::AngleAxisf(-theta, Eigen::Vector3f(0, 0, 1)));
86 pc.TransformPointCloud(transform, pc_out, true);
87 if (demean) {
88 CloudDemean(pc_out);
89 }
90 return theta;
91}
apollo::perception::base::PointCloud::TransformPointCloud
void TransformPointCloud(bool check_nan=false)
Definition point_cloud.h:215
apollo::perception::base::CloudDemean
void CloudDemean(PointFCloud *pc)
Definition point_cloud_util.cc:59
apollo::perception::base::GetPointCloudMinareaBbox
bool GetPointCloudMinareaBbox(const PointFCloud &pc, BoundingCube *box, const int &min_num_points, const bool &verbose)
Definition point_cloud_util.cc:93

◆ PerceptionFreeHost()

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

在文件 syncedmem.h 第 83 行定义.

83 {
84#if USE_GPU == 1
85 if (use_cuda) {
86 BASE_GPU_CHECK(cudaFreeHost(ptr));
87 return;
88 }
89#endif
90 free(ptr);
91}

◆ PerceptionMallocHost()

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

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

72 {
73#if USE_GPU == 1
74 if (use_cuda) {
75 BASE_GPU_CHECK(cudaMallocHost(ptr, size));
76 return;
77 }
78#endif
79 *ptr = malloc(size);
80 ACHECK(*ptr) << "host allocation of size " << size << " failed";
81}

变量说明

◆ EIGEN_ALIGN16

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

◆ kChannelsMap

const std::map<Color, int> apollo::perception::base::kChannelsMap
初始值:
{
{Color::GRAY, 1}, {Color::RGB, 3}, {Color::BGR, 3}}

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

35 {
36 {Color::GRAY, 1}, {Color::RGB, 3}, {Color::BGR, 3}};

◆ kDefaultReservePointNum

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

在文件 point.h 第 70 行定义.

◆ kMaxBlobAxes

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

在文件 blob.h 第 79 行定义.

◆ kName2ObjectSemanticTypeMap

const std::map<std::string, ObjectSemanticType> apollo::perception::base::kName2ObjectSemanticTypeMap
初始值:
= {
{"UNKNOWN", ObjectSemanticType::UNKNOWN},
{"IGNORE", ObjectSemanticType::IGNORE},
{"GROUND", ObjectSemanticType::GROUND},
{"OBJECT", ObjectSemanticType::OBJECT},
{"CURB", ObjectSemanticType::CURB},
{"VEGETATION", ObjectSemanticType::VEGETATION},
{"FENCE", ObjectSemanticType::FENCE},
{"NOISE", ObjectSemanticType::NOISE},
{"WALL", ObjectSemanticType::WALL},
{"MAX_OBJECT_SEMANTIC_LABEL",
ObjectSemanticType::MAX_OBJECT_SEMANTIC_LABEL}}

在文件 object_types.h 第 169 行定义.

169 {
170 {"UNKNOWN", ObjectSemanticType::UNKNOWN},
171 {"IGNORE", ObjectSemanticType::IGNORE},
172 {"GROUND", ObjectSemanticType::GROUND},
173 {"OBJECT", ObjectSemanticType::OBJECT},
174 {"CURB", ObjectSemanticType::CURB},
175 {"VEGETATION", ObjectSemanticType::VEGETATION},
176 {"FENCE", ObjectSemanticType::FENCE},
177 {"NOISE", ObjectSemanticType::NOISE},
178 {"WALL", ObjectSemanticType::WALL},
179 {"MAX_OBJECT_SEMANTIC_LABEL",
180 ObjectSemanticType::MAX_OBJECT_SEMANTIC_LABEL}};

◆ kName2SubTypeMap

const std::map<std::string, ObjectSubType> apollo::perception::base::kName2SubTypeMap
初始值:
= {
{"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},
}

在文件 object_types.h 第 265 行定义.

265 {
266 {"UNKNOWN", ObjectSubType::UNKNOWN},
267 {"UNKNOWN_MOVABLE", ObjectSubType::UNKNOWN_MOVABLE},
268 {"UNKNOWN_UNMOVABLE", ObjectSubType::UNKNOWN_UNMOVABLE},
269 {"CAR", ObjectSubType::CAR},
270 {"VAN", ObjectSubType::VAN},
271 {"TRUCK", ObjectSubType::TRUCK},
272 {"BUS", ObjectSubType::BUS},
273 {"CYCLIST", ObjectSubType::CYCLIST},
274 {"MOTORCYCLIST", ObjectSubType::MOTORCYCLIST},
275 {"TRICYCLIST", ObjectSubType::TRICYCLIST},
276 {"PEDESTRIAN", ObjectSubType::PEDESTRIAN},
277 {"TRAFFICCONE", ObjectSubType::TRAFFICCONE},
278 {"MAX_OBJECT_TYPE", ObjectSubType::MAX_OBJECT_TYPE},
279};

◆ kObjectName2TypeMap

const std::map<std::string, ObjectType> apollo::perception::base::kObjectName2TypeMap
初始值:
= {
{"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}}

在文件 object_types.h 第 144 行定义.

144 {
145 {"UNKNOWN", ObjectType::UNKNOWN},
146 {"UNKNOWN_MOVABLE", ObjectType::UNKNOWN_MOVABLE},
147 {"UNKNOWN_UNMOVABLE", ObjectType::UNKNOWN_UNMOVABLE},
148 {"PEDESTRIAN", ObjectType::PEDESTRIAN},
149 {"BICYCLE", ObjectType::BICYCLE},
150 {"VEHICLE", ObjectType::VEHICLE},
151 {"MAX_OBJECT_TYPE", ObjectType::MAX_OBJECT_TYPE}};

◆ kObjectSemanticType2NameMap

const std::map<ObjectSemanticType, std::string> apollo::perception::base::kObjectSemanticType2NameMap
初始值:
= {
{ObjectSemanticType::UNKNOWN, "UNKNOWN"},
{ObjectSemanticType::IGNORE, "IGNORE"},
{ObjectSemanticType::GROUND, "GROUND"},
{ObjectSemanticType::OBJECT, "OBJECT"},
{ObjectSemanticType::CURB, "CURB"},
{ObjectSemanticType::VEGETATION, "VEGETATION"},
{ObjectSemanticType::FENCE, "FENCE"},
{ObjectSemanticType::NOISE, "NOISE"},
{ObjectSemanticType::WALL, "WALL"},
{ObjectSemanticType::MAX_OBJECT_SEMANTIC_LABEL,
"MAX_OBJECT_SEMANTIC_LABEL"}}

ObjectSemanticType mapping

在文件 object_types.h 第 156 行定义.

156 {
157 {ObjectSemanticType::UNKNOWN, "UNKNOWN"},
158 {ObjectSemanticType::IGNORE, "IGNORE"},
159 {ObjectSemanticType::GROUND, "GROUND"},
160 {ObjectSemanticType::OBJECT, "OBJECT"},
161 {ObjectSemanticType::CURB, "CURB"},
162 {ObjectSemanticType::VEGETATION, "VEGETATION"},
163 {ObjectSemanticType::FENCE, "FENCE"},
164 {ObjectSemanticType::NOISE, "NOISE"},
165 {ObjectSemanticType::WALL, "WALL"},
166 {ObjectSemanticType::MAX_OBJECT_SEMANTIC_LABEL,
167 "MAX_OBJECT_SEMANTIC_LABEL"}};

◆ kObjectType2NameMap

const std::map<ObjectType, std::string> apollo::perception::base::kObjectType2NameMap
初始值:
= {
{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

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

135 {
136 {ObjectType::UNKNOWN, "UNKNOWN"},
137 {ObjectType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
138 {ObjectType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
139 {ObjectType::PEDESTRIAN, "PEDESTRIAN"},
140 {ObjectType::BICYCLE, "BICYCLE"},
141 {ObjectType::VEHICLE, "VEHICLE"},
142 {ObjectType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"}};

◆ kSubType2NameMap

const std::map<ObjectSubType, std::string> apollo::perception::base::kSubType2NameMap
初始值:
= {
{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"},
}

在文件 object_types.h 第 249 行定义.

249 {
250 {ObjectSubType::UNKNOWN, "UNKNOWN"},
251 {ObjectSubType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
252 {ObjectSubType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
253 {ObjectSubType::CAR, "CAR"},
254 {ObjectSubType::VAN, "VAN"},
255 {ObjectSubType::TRUCK, "TRUCK"},
256 {ObjectSubType::BUS, "BUS"},
257 {ObjectSubType::CYCLIST, "CYCLIST"},
258 {ObjectSubType::MOTORCYCLIST, "MOTORCYCLIST"},
259 {ObjectSubType::TRICYCLIST, "TRICYCLIST"},
260 {ObjectSubType::PEDESTRIAN, "PEDESTRIAN"},
261 {ObjectSubType::TRAFFICCONE, "TRAFFICCONE"},
262 {ObjectSubType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"},
263};

◆ kSubType2TypeMap

const std::map<ObjectSubType, ObjectType> apollo::perception::base::kSubType2TypeMap
初始值:
= {
{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::SMALLMOT, ObjectType::VEHICLE},
{ObjectSubType::BIGMOT, ObjectType::VEHICLE},
{ObjectSubType::NONMOT, ObjectType::BICYCLE},
{ObjectSubType::TRAFFICCONE, ObjectType::UNKNOWN_UNMOVABLE},
{ObjectSubType::MAX_OBJECT_TYPE, ObjectType::MAX_OBJECT_TYPE},
}

ObjectSubType mapping

在文件 object_types.h 第 230 行定义.

230 {
231 {ObjectSubType::UNKNOWN, ObjectType::UNKNOWN},
232 {ObjectSubType::UNKNOWN_MOVABLE, ObjectType::UNKNOWN_MOVABLE},
233 {ObjectSubType::UNKNOWN_UNMOVABLE, ObjectType::UNKNOWN_UNMOVABLE},
234 {ObjectSubType::CAR, ObjectType::VEHICLE},
235 {ObjectSubType::VAN, ObjectType::VEHICLE},
236 {ObjectSubType::TRUCK, ObjectType::VEHICLE},
237 {ObjectSubType::BUS, ObjectType::VEHICLE},
238 {ObjectSubType::CYCLIST, ObjectType::BICYCLE},
239 {ObjectSubType::MOTORCYCLIST, ObjectType::BICYCLE},
240 {ObjectSubType::TRICYCLIST, ObjectType::BICYCLE},
241 {ObjectSubType::PEDESTRIAN, ObjectType::PEDESTRIAN},
242 {ObjectSubType::SMALLMOT, ObjectType::VEHICLE},
243 {ObjectSubType::BIGMOT, ObjectType::VEHICLE},
244 {ObjectSubType::NONMOT, ObjectType::BICYCLE},
245 {ObjectSubType::TRAFFICCONE, ObjectType::UNKNOWN_UNMOVABLE},
246 {ObjectSubType::MAX_OBJECT_TYPE, ObjectType::MAX_OBJECT_TYPE},
247};

◆ kVisualLandmarkName2TypeMap

const std::map<std::string, base::VisualLandmarkType> apollo::perception::base::kVisualLandmarkName2TypeMap
初始值:
= {
{"RoadArrow", VisualLandmarkType::RoadArrow},
{"RoadText", VisualLandmarkType::RoadText},
{"TrafficSign", VisualLandmarkType::TrafficSign},
{"TrafficLight", VisualLandmarkType::TrafficLight},
}

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

125 {
126 {"RoadArrow", VisualLandmarkType::RoadArrow},
127 {"RoadText", VisualLandmarkType::RoadText},
128 {"TrafficSign", VisualLandmarkType::TrafficSign},
129 {"TrafficLight", VisualLandmarkType::TrafficLight},
130};

◆ kVisualLandmarkType2NameMap

const std::map<VisualLandmarkType, std::string> apollo::perception::base::kVisualLandmarkType2NameMap
初始值:
= {
{VisualLandmarkType::RoadArrow, "RoadArrow"},
{VisualLandmarkType::RoadText, "RoadText"},
{VisualLandmarkType::TrafficSign, "TrafficSign"},
{VisualLandmarkType::TrafficLight, "TrafficLight"},
}

在文件 object_types.h 第 117 行定义.

117 {
118 {VisualLandmarkType::RoadArrow, "RoadArrow"},
119 {VisualLandmarkType::RoadText, "RoadText"},
120 {VisualLandmarkType::TrafficSign, "TrafficSign"},
121 {VisualLandmarkType::TrafficLight, "TrafficLight"},
122};

◆ kVisualName2TypeMap

const std::map<std::string, base::VisualObjectType> apollo::perception::base::kVisualName2TypeMap
初始值:
= {
{"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},
}

在文件 object_types.h 第 213 行定义.

213 {
214 {"CAR", VisualObjectType::CAR},
215 {"VAN", VisualObjectType::VAN},
216 {"BUS", VisualObjectType::BUS},
217 {"TRUCK", VisualObjectType::TRUCK},
218 {"BICYCLE", VisualObjectType::BICYCLE},
219 {"TRICYCLE", VisualObjectType::TRICYCLE},
220 {"PEDESTRIAN", VisualObjectType::PEDESTRIAN},
221 {"TRAFFICCONE", VisualObjectType::TRAFFICCONE},
222 {"UNKNOWN_MOVABLE", VisualObjectType::UNKNOWN_MOVABLE},
223 {"UNKNOWN_UNMOVABLE", VisualObjectType::UNKNOWN_UNMOVABLE},
224 {"MAX_OBJECT_TYPE", VisualObjectType::MAX_OBJECT_TYPE},
225};

◆ kVisualType2NameMap

const std::map<VisualObjectType, std::string> apollo::perception::base::kVisualType2NameMap
初始值:
= {
{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"},
}

在文件 object_types.h 第 199 行定义.

199 {
200 {VisualObjectType::CAR, "CAR"},
201 {VisualObjectType::VAN, "VAN"},
202 {VisualObjectType::BUS, "BUS"},
203 {VisualObjectType::TRUCK, "TRUCK"},
204 {VisualObjectType::BICYCLE, "BICYCLE"},
205 {VisualObjectType::TRICYCLE, "TRICYCLE"},
206 {VisualObjectType::PEDESTRIAN, "PEDESTRIAN"},
207 {VisualObjectType::TRAFFICCONE, "TRAFFICCONE"},
208 {VisualObjectType::UNKNOWN_MOVABLE, "UNKNOWN_MOVABLE"},
209 {VisualObjectType::UNKNOWN_UNMOVABLE, "UNKNOWN_UNMOVABLE"},
210 {VisualObjectType::MAX_OBJECT_TYPE, "MAX_OBJECT_TYPE"},
211};

◆ kVisualTypeMap

const std::map<VisualObjectType, ObjectType> apollo::perception::base::kVisualTypeMap
初始值:
= {
{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

在文件 object_types.h 第 185 行定义.

185 {
186 {VisualObjectType::CAR, ObjectType::VEHICLE},
187 {VisualObjectType::VAN, ObjectType::VEHICLE},
188 {VisualObjectType::BUS, ObjectType::VEHICLE},
189 {VisualObjectType::TRUCK, ObjectType::VEHICLE},
190 {VisualObjectType::BICYCLE, ObjectType::BICYCLE},
191 {VisualObjectType::TRICYCLE, ObjectType::BICYCLE},
192 {VisualObjectType::PEDESTRIAN, ObjectType::PEDESTRIAN},
193 {VisualObjectType::TRAFFICCONE, ObjectType::UNKNOWN_UNMOVABLE},
194 {VisualObjectType::UNKNOWN_MOVABLE, ObjectType::UNKNOWN_MOVABLE},
195 {VisualObjectType::UNKNOWN_UNMOVABLE, ObjectType::UNKNOWN_UNMOVABLE},
196 {VisualObjectType::MAX_OBJECT_TYPE, ObjectType::MAX_OBJECT_TYPE},
197};