syntax = "proto3";
import "google/protobuf/any.proto";
import "google/protobuf/timestamp.proto";
import "geometry.proto";
import "data_source.proto";
import "calib_param.proto";
import "vehicle_signal.proto";
import "vehicle_signal_v2.proto";
import "command_signal.proto";
import "object_warning.proto";
import "camera.proto";
import "scene.proto";
import "tsr_define.proto";

// VERSION
// 0.6

package perception;

message Object {
  // 目标检测分类
  enum ObjectType {
    kNone = 0;
    kVehicle = 1;  // 车辆
    kPed = 2;      // 行人
    kBike = 3;     // 二轮车
    kCone = 4;     // 锥桶

    kVehicleWheel = 5;        // 车轮
    kVehiclePlate = 6;        // 车牌
    kPedHead = 7;             // 人头
    kCyclist = 8;             // 骑行者
    kWarningTriangle = 9;     // 三角警告牌
    kSmallTrafficSign = 10;   // 小标牌
    kBigTrafficSign = 11;     // 大标牌
    kTrafficLight = 12;       // 交通信号灯
    kAnimals = 13;            // 动物
    kVehicleLight = 14;       // 车灯
    kStreetLamp = 15;         // 路灯
    kRoadBarrier = 16;        // 水马
    kTrafficLightBulb = 17;   // 交通信号灯的灯芯
    kTrafficLightDigit = 18;  // 交通信号灯的数字
    kObstacle = 19;           // 障碍物
    kThreeWheeledVehicle = 20;// 三轮车
    kObjectTypeNum = 24;
  }

  enum ObjectCategory {
    kCategoryNone = 0;

    kCategoryCar = 1;             // 小轿车
    kCategorySuv = 2;             // SUV
    kCategoryPickup = 3;          // 皮卡
    kCategoryMediumCar = 4;       // 中型车
    kCategoryVan = 5;             // 面包车
    kCategoryBus = 6;             // 客车
    kCategoryTruck = 7;           // 卡车/罐车/大型货车/工程车
    kCategorySpecialVehicle = 8;  // 特种车
    kCategoryTricycle = 9;        // 三轮车/三轮骑行者
    kCategoryUnknownVehicle = 10; // 未知车辆

    kCategoryPedestrian = 30;     // 行人
    kCategoryBike = 31;           // 自行车/摩托车
    kCategoryCyclist = 32;        // 自行车骑行者/摩托车骑行者

    kCategoryTrafficSign = 40;    // 交通标志牌

    kCategoryVehicleWheel = 90;   // 车轮
    kCategoryLicensePlate = 91;   // 车牌
    kCategoryHead = 92;           // 人头
  }

  // 车辆姿态分类
  enum VehiclePose {
    kInvalid = 0;           // 背景
    kLeftTail = 1;          // 左侧同向车
    kMidTail = 2;           // 中间同向车
    kRightTail = 3;         // 右侧同向车
    kLeftHead = 4;          // 左侧对向车
    kMidHead = 5;           // 中间对向车
    kRightHead = 6;         // 右侧对向车
    kLeftSide = 7;          // 朝左横向车
    kRightSide = 8;         // 朝右横向车
    kLeftCutIn = 9;         // 左侧切入
    kRightCutIn = 10;       // 右侧切入
    kLeftCutOut = 11;       // 左侧切出
    kRightCutOut = 12;      // 右侧切出
    kOccluded = 13;         // 车头遮挡/车尾遮挡/横向遮挡 (deprecated)
    kSide = 14;             // 横向车(不知道朝左，还是朝右)
    kOccludedTail = 15;     // 车尾遮挡
    kOccludedHead = 16;     // 车头遮挡
    kOccludedSide = 17;     // 横向遮挡
    kVehicleOtherPose = 18; // 其他(切车、横向车、遮挡车)
    kUnknownPose = 20;      // unknown pose
  }

  enum OccludedType {
    kWithoutOccluded = 0;  // 无遮挡
    kPartOccluded = 1;     // 部分遮挡
    kLeftOccluded = 2;     // 左遮挡
    kRightOccluded = 4;    // 右遮挡
    kTopOccluded = 8;      // 上遮挡
    kBottomOccluded = 16;  // 底部遮挡
  }

  // 行人姿态分类
  enum PedPose {
    kPedInvalidPose = 0;   // 背景
    kPedForward = 1;       // 朝前
    kPedBackward = 4;      // 朝后
    kPedLeft = 7;          // 朝左
    kPedRight = 10;        // 朝右
    kPedUnknownPose = 20;  // 未知朝向
  }

  enum PedCls {
    kPedInvalidCls = 0;   // 背景
    kPedFull = 1;         // 完整行人
    kPedOccluded = 2;     // 遮挡行人
    kPedCyclist = 3;      // 骑车行人
    kPedAdvert = 4;       // 广告行人
    kPedFakeFull = 5;     // 伪装直立行人
    kPedFakeCyclist = 6;  // 伪装骑行者
    kPedUnknownCls = 20;  // 未知类别
  }

  // 锚点信息
  enum AnchorPtInfo {
    kVehicleHead = 0;
    kVehicleTail = 1;
    kVehicleFrontWheel = 2;  // deprecated
    kVehicleRearWheel = 3;   // deprecated
    kVehicleSomeWheel = 4;
    kDetectBottomCenter = 5;
    kVehicleLeftFrontWheel = 6;
    kVehicleLeftRearWheel = 7;
    kVehicleRightFrontWheel = 8;
    kVehicleRightRearWheel = 9;
    kMonocular3DFront = 21;
    kMonocular3DRear = 22;
    kMonocular3DLeft = 23;
    kMonocular3DRight = 24;
    kMonocular3DCenter = 25;
  }

  // 车辆测距方式
  enum MeasureType {
    kVehicleMeasureHeadReg = 0;  
    kVehicleMeasureTailReg = 1;
    kVehicleMeasureDetect = 2;
    kVehicleMeasureWheel = 3;
    kVehicleMeasurePlate = 4;
    kVehicleMeasureHeadProjection = 5;
    kVehicleMeasureTailProjection = 6;
    kVehicleMeasureHeadWidth = 7;
    kVehicleMeasureTailWidth = 8;
    kPedMeasureBox = 10;  // 行人测距方式
    kPedMeasureProjection = 11;

    // add 2024/09/20
    kVehicleMeasureLaneWidth = 9;   // 基于车道宽度
    kVehicleMeasureDetHeight = 12;  // 基于检测框高度
    kVehicleMeasureDetWidth = 13;     // 基于检测框宽度
    kVehicleMeasureRegHeight = 14;    // 基于回归框高度
    kVehicleMeasureRegWidth = 15;     // 基于回归框宽度

    kMeasureMono3D = 16;  // 模型测距方式
    kMeasureBev = 17;
    kMeasureFusion = 20;  // 融合测距
  }

  // 车型细分类
  enum VehicleClass {
    kNegative = 0;        // 背景
    kBus = 1;             // 大巴
    kCar = 2;             // 小轿车,suv
    kMiniBus = 3;         // 面包车
    kBucketTruck = 4;     // 斗卡
    kContainerTruck = 5;  // 箱卡
    kTricycle = 6;        // 三轮车
    kTanker = 7;  // 油罐车,晒水车（车身带有圆形,椭圆形,半圆形的罐）
    kCementTankTruck = 8;   // 水泥罐车
    kPickup = 9;            // 皮卡
    kSedimentTruck = 10;    // 渣土车
    kIveco = 11;            // 依维柯
    kSpecialCar = 12;       // 异型车
    kCityAuto = 13;         // 市政车
    kVehicleUnknown = 14;   // 未知车辆
    kWrecker = 15;          // 小型拖车，清障车
    kFlatTransporter = 16;  // 大型平板拖车
    kTractorHead = 17;      // 卡车车头,牵引车车头
    kSpecialFlatTransporter = 18;  // 大型特种拖车（相对于大型平板拖车会多挡板）
    kCarCarrier = 19;  // 轿运车

    // 盖布车（车身上的货物全部被布盖着，同时对车辆尾部进行了遮挡）
    kTruckWithTrap = 20;
    kEngineeringVehicle = 21;  // 工程车
    kSweeper = 22;             // 扫地车
    kRoadServiceCar = 23;      // 道路维修车
    kSanitationTruck = 24;     // 环卫车
    kGarbageTruck = 25;        // 垃圾车
    kFakeCar = 26;             // 伪装小车
  }

  enum WheelClass {
    kWheelUnknown = 0;  // 车轮方向未知
    kWheelFront = 1;    // 前车轮
    kWheelRear = 2;     // 后车轮
  }

  enum TrafficLightColor {  // 交通灯颜色 cls
    kTLCBackground = 0;     // 背景
    kTLCRed = 1;            // 红灯
    kTLCGreen = 2;          // 绿灯
    kTLCYellow = 3;         // 黄灯
    kTLCUnknown = 8;        // 未知
  }

  enum TrafficLightShape {  // 交通灯形状 pose
    kTLSBackground = 0;     // 背景
    kTLSUp = 1;             // 上
    kTLSDown = 2;           // 下
    kTLSLeft = 3;           // 左
    kTLSRight = 4;          // 右
    kTLSCircle = 5;         // 圆
    kTLSTurnAround = 6;     // 调头
    kTLSDigit = 7;          // 数字
    kTLSPerson = 8;         // 人
    kTLSBicycle = 9;        // 自行车
    kTLSUnknown = 16;       // 未知
  }

  enum VehicleLightClass {  // 车灯分类
    kVLUnknown = 0;
    kVLHeadLight = 1;        // 车头灯
    kVLTailLight = 2;        // 车尾灯
    kVLBrakeLight = 4;       // 刹车等
    kVLTurnLeftLight = 8;    // 左变道灯
    kVLTurnRightLight = 16;  // 右变道灯
  }

  enum VehicleLightStatus {  // 车灯状态
    kVLSUnknown = 0;
    kVLSOn = 1;                // 开
    kVLSOff = 2;               // 关(指示灯全灭)
    kVLSFlash = 3;             // 闪烁(deprecated)
    kVLSLeftTurnLightOn = 4;   // 左转向灯亮
    kVLSRightTurnLightOn = 8;  // 右转向灯亮
    kVLSBrakeLightOn = 16;     // 刹车灯亮
    kVLSHazardLightOn = 32;    // 双闪灯亮
  }

  // 工况场景判断
  enum MoveState {
    kMSUnknown = 0;              // 未知
    kEgoDirectionDriving = 1;    // 跟车流方向一致,向前行驶
    kEgoDirectionStopped = 2;    // 跟车流方向一致, 停止
    kEgoDirectionReversing = 3;  // 跟车流方向一致, 横穿
    kOnComming = 4;              // 对向来车
    kCrossing = 5;               // 横穿车辆
    kStationary = 6;             // 静止
    kTurning = 7;                // 转弯
  }

  // 目标位置状态 -> 2024/09/20
  enum PositionState {
    kPosUnknown = 0;         // 未知
    kPosShortDistance = 1;   // 近距离
    kPosMediumDistance = 2;  // 中距离
    kPosLongDistance = 3;    // 远距离
  }

  message ImageInfo {
    perception.common.Rect2f det_rect = 1;               // 检测框
    perception.common.Rect2f reg_rect = 2;               // 回归框(尾部框)
    perception.common.Rect2f track_rect = 3;             // 跟踪框
    perception.common.Rect2f smooth_rect = 4;            // 光流跟踪框
    perception.common.Rect2f plate_rect = 5;             // 车牌框
    repeated perception.common.Rect2f wheel_list = 6;    // 车轮踪框
    repeated perception.common.Point2f reg_pt_list = 7;  // 回归点列表
    perception.common.Rect2f bike_rect = 8;              // 二轮车框

    perception.common.Box3D box = 10;                    // 3dbox
    minieye.CamID camera_id = 11;                       // 对应那个摄像头

    perception.common.Rect2f det_rc_refined = 15;       // 经过refine(补框)后的检测框
    perception.common.Rect2f reg_rc_refined = 16;       // 经过refine(补框)后的回归框
    perception.common.Rect2f det_rc_refined_vel = 17;   // 经过refine(补框)后的检测框的速速
    reserved 18;
    GroundContactLines ground_contact_lines = 19;       // 车辆四个面的接地线，图像侧按 (u, v, z) 组织
  }

  message GroundContactLines {
    perception.common.Point3fList front = 1;  // 前面接地线，固定 5 个点
    perception.common.Point3fList rear = 2;   // 后面接地线，固定 5 个点
    perception.common.Point3fList left = 3;   // 左面接地线，固定 5 个点
    perception.common.Point3fList right = 4;  // 右面接地线，固定 5 个点
  }

  enum VehicleRigidAnchor {
    kVRARear = 0;
    kVRARearWheel = 1;
    kVRAHeadWheel = 2;
    kVRAHead = 3;
    kVRAMaxNum = 4;
  }

  enum ObjImportanceType {
    kNormal = 0;      // 普通的目标
    kCrucial = 1;     // 决定性的目标，cipv, cipp
    kInterested = 2;  // 关注的目标
  }

  message VehicleRigid {
    // 长度方向，刚体量测细节
    repeated perception.common.Float meas_along_length =
        1;                          // kVRAMaxNum * kVRAMaxNum
    perception.common.Float w = 2;  // width
    perception.common.Float h = 3;  // height
  }

  enum TrackStatus {
    kTSUnknown = 0;
    kTSFirstDetectd = 1;  // 第一次检测
    kTSTracking = 2;      // 稳定跟踪 (只针对关键车)
    kTSPredict = 3;       // 预测
  }

  enum SelectLevelStatus {
    kSLOriginDet = 0;            // 原始检测
    kSLDetAfterInnerROINMS = 1;  // 经过ROI内NMS后的检测
    kSLDetAfterCrossROINMS = 2;  // 经过ROI间NMS后的检测
    kSLReservered = 3;           // 保留字段
    kSLCandidateDet = 4;  // 候选目标 (所有检测出来的目标都是候选目标)
    kSLConcerned = 5;  // 需要重点关注的目标
    kSLCrucial = 6;    // 决定性的目标 (cipv, cipp)
  }

  enum LaneDirection {           // 车道朝向
    kSameDirectionLane = 0;      // 同向车道
    kOppositeDirectionLane = 1;  // 对向车道
    kObjDirectionUnknown = 2;    // 方向unknown
  }

  enum PropertyType {
    kPropertyVehicleRearLamp = 0;
    kPropertyInvalidity = 1;
    kPropertyOcclusion = 2;
    kPropertyLeftOccluded = 3;    // 左遮挡
    kPropertyRightOccluded = 4;   // 右遮挡
    kPropertyBottomOccluded = 5;  // 底部遮挡
    kPropertyTopOccluded = 6;     // 上部遮挡
  }

  enum PropertyInvalidity {
    kReservedInvalidity = 0;
    kVelocityInvalidity = 1;
    kPositionInvalidity = 2;
    kHeadingInvalidity = 4;
  }

  enum ObstacleType {
    kObstacleBackground = 0;              // 背景
    kObstacleCone = 1;                    // 锥桶
    kObstacleCrashBarrel = 2;             // 防撞桶
    kObstacleWarningTriangle = 3;         // 三角警告牌
    kObstacleCylindrical = 4;             // 柱形石墩
    kObstacleSphericalstone = 5;          // 球形石墩
    kObstaclePlasticpole = 6;             // 塑料地桩
    kObstacleBumpingpost = 7;             // 铁地桩
    kObstacleWaterbarrier = 8;            // 水马
    kObstacleCarton = 9;                  // 纸箱子
    kObstacleTyre = 10;                   // 轮胎
    kObstaclePlasticpoleBumpingpost = 11; // 地桩（塑料地桩、铁地桩）
    kObstacleOther = 32;                  // 其它
  }

  enum Mode {
    kNoneMode = 0;
    kPilotMode = 1;    // 行车
    kParkingMode = 2;  // 泊车
    kCamera1Mono3d = 4;// camera1使用mono3d
  }

  // 法规场景具体类型
  enum SpecificSceneType {
    kSceneUnknown = 0;      // 未知
    kSceneCNCAP2024SCP = 1;      // SCP场景
    kSceneCNCAP2024CCFT = 2;     // CCFT场景
    kSceneCNCAP2024CCRS = 3;     // CCRS场景
    kSceneCNCAP2024SCPO = 4;     // SCPO场景
    kSceneCNCAP2024CCRH = 5;     // CCRH场景
    kSceneCNCAP2024CPLA = 6;     // CPLA场景
    kSceneCNCAP2024CPLAN = 7;    // CPLA_N场景
    kSceneCNCAP2024CPTALN = 8;   // CPTA_LN场景
    kSceneCNCAP2024CPTALF = 9;   // CPTA_LF场景
    kSceneCNCAP2024CPTARF = 10;  // CPTA_RF场景
    kSceneCNCAP2024CPFAO = 11;   // CPFAO场景
    kSceneCNCAP2024CPFAON = 12;  // CPFAO_N场景
    kSceneCNCAP2024CPNCO = 13;   // CPNCO场景
    kSceneCNCAP2024CBNAO = 14;   // CBNAO场景
    kSceneCNCAP2024CSFAO = 15;   // CSFAO场景
    kSceneCNCAP2024CSTALN = 16;  // CSTA_LN场景
    kSceneCNCAP2024CBLA = 17;    // CBLA场景
    kSceneCNCAP2024CSTARN = 18;  // CSTA_RN场景
    kScene1242CPFA = 19;         // 行人从左到右横穿
    kScene1242CPNA = 20;         // 行人从右到左横穿
    kScene1242CPLA = 21;         // 正前方静止行人
    kScene1242CCRS = 22;         // 1242 CCRS场景
    kScene1242CCRM = 23;         // 1242 CCRM场景
  }
  //
  //enum SFObstaclePropertyType {
    //
  //  SAF_OBS_PRO_NOT_ON_ROAD = (1<<0),【根据freespace判断⽬标是否在道路边界外】
  //  SAF_OBS_PRO_COVERD_BY_OTHERS = (1 << 1),//【⽬标是否被物体遮挡】
  //  SAF_OBS_PRO_OBSERVE_JUMP = (1 << 2),// 【通过图像检测框判断⽬标是否跳变】
  //  SAF_OBS_PRO_OBSERVE_SIDE = (1 << 3),// 【⽬标是否在图像边缘】
    //通过⻆点、检测框、速度⽐例判断横穿转直⾏，仅骑⻋⼈输出，内部使⽤
  //  SAF_OBS_PRO_BT_TAP_LEVEL_1 = (1 << 4),
  //  SAF_OBS_PRO_BT_TAP_LEVEL_2 = (1 << 5),
  //  SAF_OBS_PRO_BT_TAP_LEVEL_3 = (1 << 6),
  //  SAF_OBS_PRO_PED_ON_MOTOR = (1 << 7),//【可能是三轮⻋上⾏⼈flag，根据IOU进⾏判断】
  //  SAF_OBS_PRO_PED_GROUP = 1 << 8, //【⼈群】
  //  SAF_OBS_PRO_CROSSING_GHOST= 1 << 9,//【⻤探头】 
  //}
  message PropertyValue {
    int32 value = 1;
    float valuef = 2;
    float confidence = 3;
  }

  message OperatingCondition {
    enum RoadSurface {
      kRoadSurfaceSmooth = 0;
      kRoadSurfaceBumpy = 1;
    }
    enum RoadGradient {
      kRoadGradientFlatGround = 0;
      kRoadGradientUphill = 1;
      kRRoadGradientDownhill = 2;
    }
    enum MotionState {
      kMotionStateNone = 0;
      kMotionStateStationary = 1;
      kMotionStateMoving = 2;
      kMotionStateTurning = 4;
      kMotionStateStraight = 8;
    }
    bool airborne = 1;                   // 悬空
    RoadSurface road_surface = 2;        // 颠簸
    RoadGradient road_gradient = 3;      // 上下坡
    uint32 motion_state = 4;             // 运动状态 
  }

  message LaneAssignment {
    perception.common.Int lane_index = 1;  // 车道位置(--3 -2 -1 0 1 2 3)
    LaneDirection direction = 2;           // 车道朝向
    // 是否侵道 ( > 0 - 侵道, < 0 - 未侵道, 其值为侵入的多少, 单位m)
    perception.common.Float has_cut_lane = 3;

    // 透视图下车尾侵入本车道的比例[-103, 100]
    // < 0, 侵入当前右车道线，> 0, 侵入当前左车道线, 0 - 无侵入
    // -101 -> 无车尾回归框
    // -102 -> 无匹配车道线
    // -103 -> 既无回归框也无车道线
    perception.common.Int cut_in_ratio_on_persp = 4;

    // 关联的车道属性 
    repeated perception.common.Int associated_lane_idxs = 5;
  }

  // 单目3D信息
  message Monocular3D {
    // Box3D中心点的像素坐标(xc, yc)
    perception.common.Point2f ctr_pt_2d = 1;
    // 深度(z)
    perception.common.Float z = 2;

    // Box3D(l, w, h)
    perception.common.Float l = 3;
    perception.common.Float w = 4;
    perception.common.Float h = 5;

    // alpha(人眼看的车辆方向)
    perception.common.Float alpha = 6;

    // 模型原始测距的锚点信息
    AnchorPtInfo anchor = 7;

    // 模型原始输出的3D位置和朝向信息
    message Model3DPos {
      float x3d = 1;
      float y3d = 2;
      float z3d = 3;
      float heading = 4;
    }
    Model3DPos model_3d_pos = 8;
  }

  message WorldInfo {
    perception.common.XYZ vel = 1;      // 速度
    perception.common.XYZ rel_vel = 2;  // 相对速度
    perception.common.XYZ acc = 3;      // 加速度
    perception.common.XYZ pos = 4;      // 位置
    perception.common.Size3D size = 5;  // 长宽高
    // 与自车的中心夹角 左边缘夹角 右边缘夹角
    perception.common.Angle3f angle = 6;  
    
    // 基于回归框估计的宽高
    perception.common.Size3D size_est1 = 7; 

    // 基于检测框估计的宽高
    perception.common.Size3D size_est2 = 8; 

    perception.common.Box3D box = 10;  // 3dbox

    uint32 id = 11;  // 目标id

    // 类型细分类，可能取：
    //
    // - VehicleClass
    // - PedCls
    // - TrafficLightColor
    // - tsr.SignType
    // 
    perception.common.Int cls = 12;

    // 模糊类型。
    //
    // 遮挡等情况下，模型无法判断物体具体类型，possible_cls_list
    // 表示此物体的可能类型。
    //
    // - 当此列表为空时，视作仅包含 cls.val。
    // - 当此列表仅包含 cls.val，表示结果不模糊的。
    // - 否则，cls.val 的值是无效的（一般设为某种未知类型）。
    repeated int32 possible_cls_list = 42;

    float val = 13;  // 分类值 
    perception.common.Int pose = 14;  // 姿态分类 : VehiclePose PedPose TrafficLightShape
    float ttc = 15;                   // 碰撞时间
    float headway = 16;               // 时距=距离/自车速度
    int32 cipv = 17;  // 前方目标是否为关键车(CIPV)，关键车为1，非关键车为0
    int32 cipp = 18;  // 前方目标是否为关键人(CIPP)，关键人为1，非关键人为0
    perception.common.PoseAngle pose_angle =
        19;  // 姿态角，单位：度，左正右负, ±180
    perception.common.Int motion_state = 20;  // 运动状态，参考MoveState定义
    AnchorPtInfo anchor = 21;                 // 测距对应的锚点信息

    perception.common.Point3D pos_var = 22;   // pos的方差(deprecated) 
    perception.common.Point3D size_var = 23;  // 长宽高的方差(deprecated) 

    // (deprecated) pose_angle的方差
    perception.common.Point3D pose_angle_var = 24;
    perception.common.XYZ anchor_offset = 25;       // 锚点的offset
    repeated perception.common.XY odom_trace = 26;  // 历史轨迹

    perception.common.Int pose_ori = 30;  // 模型直出的pose
    perception.common.Int cls_ori = 31;   // 模型直出的cls
    ObjectType hit_type = 32;             // 目标检测大类别
    float confidence = 33;                // 综合置信度
    MeasureType measure_type = 34;        // 量测类型
    TrackStatus track_status = 35;        // 跟踪状态
    LaneAssignment road_assignment = 36;  // 目标所在的车道信息
    int32 life_time = 37;                 // 生命周期
    int32 index = 38;                     // 索引
    uint32 age = 39;                      // 目标存活周期

    Monocular3D monocular_3d = 40;  // 单目3D信息
    //障碍物（⾏⼈、骑⻋⼈）属性，包含：是否在道路边界外, 是否被遮挡等，其中pro_flag按照bitmap⽅式SFObstaclePropertyType填充：
    int32 pro_flag = 41;
    ObjectCategory object_category = 43;  // 检测细分类，保留模型原始类别语义
    GroundContactLines ground_contact_lines = 44;  // 车辆四个面的接地线，转换到车身坐标系后的点集
  }

  message FusionInfo {  // fusion要用到的关联信息
    // 关联到的各个摄像头的检测框
    repeated ImageInfo associated_image_infos = 1;
    // 关联到的各个摄像头的检测框
    repeated WorldInfo associated_world_infos = 2;
    repeated float associated_conf_matrix = 3;  // 关联置信度 num * num
    WorldInfo fusion_world_info = 4;            // 多视fusion后的结果
    map<int32, PropertyValue> properties = 5;   // <PropertyType, PropertyValue>
  }

  int32 hit_id = 1;         // 目标检测ID (deprecated, 以hit_type为准)
  ObjectType hit_type = 2;  // 目标检测类别enum
  string hit_type_str = 6;  // 目标检测类别string
  float confidence = 3;     // 检测置信度(综合)

  int32 frame_cnt = 4;       // frame count
  int32 life_time = 5;       //  live us
  uint64 time_creation = 7;  // 障碍物被识别的时间戳(微秒)

  ImageInfo image_info = 8;  // 图像信息 (前视1v专用)
  WorldInfo world_info = 9;  // 车辆坐标系下信息 (前视1v专用)

  int32 track_status = 10;  // track状态
  int32 trace_status = 11;  // deprecated
  int32 select_level = 12;  // 选择等级 (SelectLevelStatus)

  uint32 id = 15;                 // object id
  FusionInfo fusion_info = 16;    // fusion需要信息
  MeasureType measure_type = 17;  // 量测类型

  uint64 timestamp = 18;  // 当前时刻 timestamp (微秒)
  uint64 frame_id = 19;   // 当前帧 frame id

  perception.common.Int lane_assignment = 21;  // 目标所在车道信息(deprecated)
  // 是否侵道 ( > 0 - 侵道, < 0 - 未侵道, 其值为侵入的多少, 单位m)(deprecated)
  perception.common.Float has_cut_lane = 22;

  VehicleRigid veh_rigid = 23;  // 车辆刚体信息

  perception.common.FloatArray features = 24;  // 特征向量

  LaneAssignment road_assignment = 25;  // 目标所在车道信息
  uint32 occluded_mask = 26;            // 值域范围(0 | OccludedType[i])
  google.protobuf.Timestamp timestamp_ts = 27;  // 管理面时间
  google.protobuf.Timestamp tick_ts = 28;       // 数据面时间
  // 遮挡率可以使用该map表示
  map<int32, PropertyValue> properties = 29;  // <PropertyType, PropertyValue>
  OperatingCondition operating_condition = 30;  // 工况
  SpecificSceneType specific_scene = 31;        // 法规场景具体类型
  uint32 age = 32;                              // 目标存活周期
  ObjectCategory object_category = 33;          // 检测细分类，保留模型原始类别语义

  repeated Object key_components = 60;  // 组件信息
}

// topic : "ObjectPerceptionObjectList"
message ObjectList {
  repeated Object list = 1;  // object list

  string version = 3;  // 版本号

  uint64 frame_id = 4;   // 帧IDs
  uint64 timestamp = 5;  // utc时戳, us

  perception.object.Warning warning = 6;           // 告警
  repeated perception.common.Rect2f roi_list = 7;  // 检测ROI列表

  uint64 tick = 9;                      // tick时戳, us
  uint64 start_time_us = 10;            // 算法流程开始时间
  uint64 end_time_us = 11;              // 算法流程结束时间
  repeated uint64 profiling_time = 12;  // 模块耗时列表
  repeated Scene scene = 13;            // 场景分类（deprecated）
  SceneList scene_list = 14;            // 场景分类

  minieye.DataSource data_source = 15;        // 描述数据源 字节数: 4
  minieye.CalibParam calib_param = 16;        // 标定参数
  minieye.VehicleSignal vehicle_signal = 17;  // 车身信号
  minieye.CameraParam camera_param = 18;  // 相机内外参数(多v融合结果不适用)
  minieye.CamID cam_id = 19;  // 摄像头id(cam_id.id(), 等同instance_id)
  uint32 cam_prj_id = 20;     // 用于进行投影变换的id
  minieye.CommandSignal command_signal = 21;    // 触发式信号
  google.protobuf.Timestamp timestamp_ts = 22;  // 管理面时间
  google.protobuf.Timestamp tick_ts = 23;       // 数据面时间

  minieye.VehicleSignalHighFreq vehicle_signal_high_freq = 24; // 车身高频信号
  minieye.VehicleSignalLowFreq vehicle_signal_low_freq = 25; // 车身低频信号
  uint32 mode = 26;                        // 模式
  repeated uint32 frame_ids = 27;          // [前短焦，后，前长焦，往左前看，往左后看，往右前看，往右后看]  不存在的补0
  uint64 roadmarking_frame_id = 28;               // 匹配路面感知的frame_id
  uint64 roadmarking_tick_ms = 29;                // 匹配路面感知的tick(毫秒)
  google.protobuf.Any debug_details = 30;  // debug信息
}

// topic : "ObjectPerceptionVisionObjects"
message VisionObjects {
  string version = 1;                          // 版本号
  google.protobuf.Timestamp tick = 2;          // 数据面时间
  google.protobuf.Timestamp timestamp = 3;     // 管理面时间
  repeated Object.FusionInfo fusion_info = 4;  // 视觉检测结果
  // [前短焦，后，前长焦，往左前看，往左后看，往右前看，往右后看]
  // 不存在的补0
  repeated uint32 frame_ids = 5;  // 各v的frame_id
  SceneList scene = 6;            // 场景分类

  google.protobuf.Timestamp start_tick = 7;  // 算法开始时间
  google.protobuf.Timestamp end_tick = 8;    // 算法结束时间
  uint32 mode = 9;                           // 模式
  uint64 roadmarking_frame_id = 10;          // 匹配路面感知的frame_id
  uint64 roadmarking_tick_ms = 11;            // 匹配路面感知的tick(毫秒)
}

// topic : "VisionObjectsWarning"
// perception.object.Warning

// topic : "SagWarning"
// perception.object.SAGWarning
