cross_doctor/proto/xlcomm.proto

syntax = "proto3";

package xlsyn;
option java_package = "com.xinglusyn.proto";
import "traj.proto";
import "map_match.proto";

// 路况状态的计算来源分类
enum seg_status_src_t {
    RTT_SRC_SELF = 0;  // 自研原始路况状态
    RTT_SRC_GAODE = 1;  // 路况未计算出路况速度, eta计算出了eta速度
    RTT_SRC_SHIJIGAOTONG = 2;
    RTT_SRC_SHIJIGAOTONG_RTIC = 3;
    RTT_SRC_SELF_FILLING = 4;
    RTT_SRC_STABLENESS_FILLING = 5;  // 时间平滑的结果
    RTT_SRC_SPACE_FILLING = 6;  // 普通平滑的结果
    RTT_SRC_STABLENESS_SPACE_FILLING = 7;  // 时间平滑及空间平滑的结果
    RTT_SRC_RTIC_FILLING = 8;
    RTT_SRC_DEGREE_FILLING = 9;
    RTT_SRC_FORM_WAY_FILLING = 10;
    RTT_SRC_LEN_FILLING = 11;
    RTT_SRC_CHANGES = 12;
    RTT_SRC_CLOSELINK_ML = 13;  // new_add 封闭道路机器学习模型直接输出的结果
    RTT_SRC_CLOSELINK_SMOOTH_ML = 14;  // new_add 封闭道路用ML模型平滑的结果
    RTT_SRC_SPARSE_FILING = 15;  // new_add 稀疏模型填补的结果[已下线]
    RTT_SRC_TIME_FILING = 16;  // new_add 邻近时间填补的结果
    RTT_SRC_TIMESPACE_FILING = 17;  // new_add 邻近时间填补及空间平滑的结果
    RTT_SRC_DEFAULT_FILING = 18;  // new_add 默认0.61倍ffs填补的结果
    RTT_SRC_DEFAULTSPACE_FILING = 19;  // new_add 默认0.61倍ffs填补及空间平滑的结果
    RTT_SRC_FLOWFIX_FILLING = 20;  // new_add 根据上下游流量校验的结果
    RTT_SRC_GLSML_FILLING = 21;  // new_add 平滑机器学习模型直接输出的结果
    RTT_SRC_GROUND_LINK_ML = 22;  // new_add 地面普通道路ML模型输出的结果
    RTT_SRC_GROUND_LINK_LIGHT_ML = 23;  // new_add 地面红绿灯道路ML模型输出的结果
    RTT_SRC_GROUND_LINK_LESSDATA_ML = 24;  // new_add 地面数据稀疏道路ML模型输出的结果
    RTT_SRC_GROUND_LINK_MINROAD_ML = 25;  // new_add 地面小路ML模型输出的结果
    RTT_SRC_IMAGE_LIGHT_LINK_ML = 26;  // new_add 基于图像的红绿灯道路路况(rtti_sw输出)
    RTT_SRC_IMAGE_COMM_LINK_ML = 27;  // new_add 基于图像的非红绿灯道路路况(rtti_sw输出)
    RTT_SRC_IMAGE_CLASSIC = 28;  // new_add 基于图像的基于规则的判定路况(rtti_sw输出)
    RTT_SRC_FIX_BY_JAM_PROB = 29;  // 基于拥堵概率进行修正后的状态
    RTT_SRC_GROUND_LINK_LIGHT_2_ML = 30;// 新灯前模型结果
    RTT_SRC_LONG_JAM_SMOOTH = 31;// 长等灯平滑结果
    RTT_SRC_RESERVED_1 = 32;//保留1
    RTT_SRC_LOW_CONF_JAM_TAG = 33;//低置信拥堵标志
    RTT_SRC_LOW_CONF_JAM = 34;//低置信拥堵
    RTT_SRC_SZPA_FIX = 35; //服务区平行路的拥缓修正
    RTT_SRC_RESERVED_5 = 36;//保留5
    RTT_SRC_RESERVED_6 = 37;//保留6
    RTT_SRC_RESERVED_7 = 38;//保留7
    RTT_SRC_RESERVED_8 = 39;//保留8
    RTT_SRC_RESERVED_9 = 40;//保留9
}

// 单车速度样本的标记分类
enum  sample_tag_t{
    sample_tag_normal = 0;  // 正常样本
    sample_tag_luan_kill = 1;   // 因轨迹混乱被kill
    sample_tag_park_kill = 2;   // 因固定点停车被kill
    sample_tag_poi_kill = 3;    // 因poi关联的异常行为被kill
    sample_tag_tollgate_kill = 4;   //因收费站引起的异常行为被kill
    sample_tag_stand_still_filter=5;    // 异常停车过滤
    sample_tag_lowM_filter=6;   // 完走率过滤
    sample_tag_pickup_filter=7; // 小路pickup样本过滤
    sample_tag_rc6_old_filter=8;    // 小路旧样本过滤
    sample_tag_too_old_filter=9;    // 旧样本过滤
    sample_tag_odd_filter=10;   // 离群样本过滤
    sample_tag_onlyOld_filter=11;   // 小路上纯旧样本全删
    sample_tag_too_fast_filter=12;  // 超高速样本过滤
    sample_tag_express_kill_low_filter=13;  // 城际高速低速样本过滤
    sample_tag_tunnel_kill_filter=14;   // 隧道样本过滤
    sample_tag_trend_kill_filter=15;    // 趋势过滤
    sample_tag_light_prefer_low_filter=16;  // 信号灯前偏爱低速
    sample_tag_trunk_filter=17; // 货车样本过滤
    sample_tag_sparse_traj_filter=18;   // 轨迹过稀的样本过滤
    sample_tag_not_finish_light_filter=19;  // 未走完信号灯的样本过滤
    sample_tag_car_trip_head_filter=20; // 私家车单次行程起始段样本过滤
    sample_tag_car_trip_tail_filter=21; // 私家车单次行程末尾段样本过滤
    sample_tag_netcar_trip_head_filter=22;  // 网约车单次行程起始段样本过滤
    sample_tag_netcar_trip_tail_filter=23;  // 网约车单次行程末尾段样本过滤
    sample_tag_netcar_pickup_head_filter=24;    // 网约车接客开始段样本过滤
    sample_tag_netcar_pickup_tail_filter=25;    // 网约车接客末尾段样本过滤
    sample_tag_netcar_other_switch_filter=26;   // 网约车其他状态切换导致的样本过滤
    sample_tag_turnback_filter=27;  // 轨迹掉头过滤
    sample_tag_coin_filter=28;  // 重复样本过滤
    sample_tag_branchflow_filter=29;    // 支流过滤
    sample_tag_abnormal_match   = 30;//异常匹配样本过滤
    sample_tag_badcar=31;   // 被车辆黑名单过滤掉
    sample_tag_illegal_on_lane=32;//高速上异常高速样本,可能占用了应急车道
    sample_tag_suburb_still_filter=33;//郊区异常停留
    sample_tag_slow_empty_kill=34;  // 针对滴滴等网约车的空车状态进行的低速过滤
    sample_tag_allstop_kill=35;   // 所有轨迹都在固定点停留
    sample_tag_deviate_kill=36;   // 因轨迹偏离道路而过滤
    sample_tag_workzone_kill=37;  // 在工作园区内过滤掉非送客状态的营运车辆的低速本
    sample_tag_badsrc_kill=38; // 不良渠道轨迹的样本舍弃
    sample_tag_poi_old_kill=39; // poi关联的link上的样本时间过滤
    sample_tag_truck_low_kill=40; // 经过客货车综合对比，舍弃偏低速的货车样本
}

message rtt_tlink_diverge_t {
    int32 dist2cross = 1;//距离路口的距离（单位:cm）(SW用)
    uint64 out_xlink_id = 2;//出口Link（经过路口后的第一条非交叉口内link）的tlinkid(SW用)
    int32 eta_speed = 3;//该方向上的eta速度(ETACalculator输出用)
    int32 dist2branch = 4;//经过该路进入非主流路前的距离（只保存100米以内的距离，因为一般100米以内会受多流向影响）
    uint64 out_linkid = 5; //出口Link的linkid(末尾数字为dir),不是xlink_id(没有赋值)
    int32 refine_eta_speed = 6;  // 精细化的eta速度，单位为0.01km/h，仅当速度小于5km/h时，才提供该字段
};

// 某个流向的速度和状态信息
message rtt_flow_status_t {
    uint64 out_xlink_id = 1; //出口Link（经过路口后的第一条非交叉口内link）的tlinkid
    int32 status = 2;
    int32 speed = 3;
    int32 turn_type = 4;  //转向类型,现有取值:0,1,2,3分别表示:直行,左转,右转,掉头
    uint64 out_linkid = 5; //出口Link的linkid(末尾数字为dir),不是xlink_id(没有赋值)
}

// 多流向的状态结构体
message rtt_multiflow_status_t {
    repeated rtt_flow_status_t status_bkt = 1; // 多个流向的状态信息
    int32 multi_type = 2;  // 指明多个状态的含义。默认情况下表示指向下游多个link的分流向路况；当取值为1时，表示内部样本分层的情况，此时out_xlink_id取值为路况状态值，如:0,1,2,4。
}

// 长link的分段路段结构体
message rtt_subsection_status_t {
    repeated int32 subsection_data = 1;   // 分段的速度状态信息
}

//等灯详情信息
message rtt_light_wait_detail_t{
    int32 count = 1; // 等灯次数
    repeated int32 wait_queue_lens = 2; // 等灯队列的长队数组。0号元素表示末次等灯队列长度
    int32 life = 3; // 信息被复用的批次个数.取值恒大于0.取值n表示该被第n次延续使用;当属于真实计算结果时,不包含该字段.
}

message rtt_tlink_light_t {
    int32 count = 1;  //等灯个数
    int32 time  = 2;  // time of pass light
    int32 dis_firstwait2light = 3;  //distance of first wait to the light
    int32 is_passed            = 4; //is have  passed the light
    int32 dis_firstwait2link  = 5;  //distance of first wait to the end of link
    int32 dis_first2end = 6;
    int32 dis_last2end = 7;
};

message rtt_tlink_ml_t {
    int32 stay_len = 1;//停留长度
    int32 stay_period = 2;//停留时间
    uint32 latest_timestamp = 3;//驶离时间(最新数据时间)，有一个例外：在红绿灯前，受影响的多个Link的latesttime都被设置为整个受影响轨迹串的最后一个点对的末尾点的时间
    rtt_tlink_light_t light_info = 4;
    int32 max_stop_period = 5;
    int32 start_pos = 6; // 样本覆盖link的起点位置,不考虑link的顺向逆向,统一用0表示link起点位置
};

message rtt_sample_statistics_t {
    // 由高到低4个字节分别存放: 总样本数| 状态=0样本数| 状态=1样本数| 状态=2样本数
    int32 inuse_cnt = 1;  // 按字节存储in_use样本的统计
    int32 normal_cnt = 2; // 按字节存储in_use,rc6_old,too_old样本的统计
    int32 total_cnt = 3;  // 按字节存储除SW标记异常的所有样本的统计
};

message close_link_detail_t {
    float p0 = 1;
    float p2 = 2;
    float relative_speed = 3;
}

// 单车样本或平均速度样本数据
message rtt_tlink_spt_t {
    uint64 xlink_id = 1;
    int32 speed = 2;
    // for one car
    uint32 load_status = 3;
    int32 priority = 4;
    uint32 t = 5; //样本时间，通常指的是车辆离开Link的时间，有一个例外是：被判定为疑似异常停车的时候，设置为异常停车开始的时间
    uint64 car_id = 6;
    // for one state
    uint32 status = 8;
    // 2015_04_17
    int32 eta_speed = 9;
    uint32 offset = 10;
    // types 0:gps_speed 1:avg_speed 2:light_speed
    int32 type = 11;
    // type of caculation
    seg_status_src_t src = 12;
    int32 reliability = 13;
    // car_num
    int32 flow = 14;
    // if it's the last link_spt, pass_by = false
    bool pass_by = 15;
    // is stand still
    bool is_stand_still = 16;
    // order_status
    xlsyn.order_status_t order_status = 17;
    uint32 city_id = 18;
    int32 gps_speed = 19;
    rtt_tlink_ml_t ml_info = 20;
    close_link_detail_t close_link_detail = 21;
    repeated float clm_data = 22;  // new_add 当src=RTT_SRC_CLOSELINK_ML时，这里包含一些辅助信息
    // added by gavanwang@20170425
    int32 eta_speed_m1 = 23;
    int32 eta_speed_m2 = 24;
    sample_tag_t tag = 25; // 样本标记
    // added by gavanwang@20171106
    int32   gd_speed = 26;
    int32   gd_status = 27;
    // added by liguangsun@20180102
    repeated float light_ml_features = 28;  // feature array for light ml model
    // add by gavanwang@20180201
    repeated rtt_tlink_diverge_t diverge_info = 29; // 分流信息
    // add by thomasyyang@20180329
    int32 smooth_speed = 30;                // 用于存储平滑机器学习模型结果
    int32 smooth_status = 31;
    repeated float gml_data = 32;//用于slidewindows向下游传递数据信息(地面道路红绿灯模型)
    int32 calc_speed = 33;                  // 用于存储Calculator结果
    int32 calc_status = 34;
    seg_status_src_t calc_src = 35;
    int32 method = 36;                      // 用于标记平滑时采用传统还是ML方法
    rtt_sample_statistics_t samples_info = 37; //用于向Publish模块传递各标签样本数统计
    rtt_multiflow_status_t multiflow_status = 38; // 多流向状态
    int32 mt_speed = 39;  // 路况速度 for 美团
    int32 mt_status = 40;  // 路况状态 for 美团
    int32 rtti_src = 41;  // 富媒体来源 0-众包设备,1-滴滴设备
    int32 flow_speed = 42;
    rtt_subsection_status_t subsection_status = 43; // 分段路段数据,在内部字段中,依次存储千分数、速度和状态
    repeated uint64 ll_data = 44;//存储64位整数,目前首位存300米外最近等灯处linkid_dir
    rtt_light_wait_detail_t light_wait_detail = 45; // 等灯详情
    rtt_speed_odd_point_t speed_odd_point = 46; //  速度突变点信息
    int32 refine_eta_speed = 47;  // 精细化的eta速度，单位为0.01km/h，仅当速度小于5km/h时，才提供该字段
};

message rtt_tlink_spt_bkt_t {
    repeated rtt_tlink_spt_t bkt = 1;
    uint32 pack_info = 2;
    uint32 t = 3;
    string ver = 4;
};

message rtt_stand_still_vehicle_t {
    uint64 car_id = 1;
    uint32 t = 2;
};

// 一批停车信息
message rtt_stand_still_vehicle_bkt_t {
    repeated rtt_stand_still_vehicle_t bkt = 1;
    uint32 pack_info = 2;
    uint32 t = 3;
};

// 边的状态：速度值和路况
message rtt_seg_status_t {
    xlsyn.rtt_seg_t seg = 1;     // 描述路况状态的路段
    xlsyn.rtt_seg_t next_seg = 2;    // 该速度关联的下一条路段
    uint32  timestamp  = 3;    // 时间戳
    int32   qq_speed = 4;      // 边的速度km/h
    int32   qq_status  = 5;    // 边的状态，畅通、缓行、拥堵
    int32   use = 6;
    int32   gd_speed = 7;
    int32   gd_status = 8;
    int32   sj_speed = 9;
    int32   sj_status = 10;
    int32   t1 = 11;
    int32   t2 = 12;
    int32   t3 = 13;
    int32   eta_speed = 14;
    seg_status_src_t src = 15;
    // added by gavanwang@20170425
    int32 eta_speed_m1 = 16;  // 表示过渡期的重构后的eta_speed
    int32 eta_speed_m2 = 17;
    // added by thomasyyang@20180329
    int32 smooth_speed = 18;  // 平滑ML模型路况速度: km/h
    int32 smooth_status = 19; // 平滑ML模型路况状态: 畅通, 缓行, 拥堵, 极度拥堵
    int32 reliability = 20;    // 路况状态的置信度: 取值0~99
    // added by gavanwang@20180423
    repeated rtt_tlink_diverge_t diverge_info = 21;
    // added by thomasyyang@20180615
    int32 trad_speed = 22;       // 平滑传统模型路况速度: km/h
    int32 trad_status = 23;      // 平滑传统模型路况状态: 畅通, 缓行, 拥堵, 极度拥堵
    seg_status_src_t trad_src = 24;  // 平滑传统模型路况src
    int32 calc_speed = 25;       // Calculator计算出来的原始路况速度
    int32 calc_status = 26;      // Calculator计算出来的原始路况状态
    seg_status_src_t calc_src = 27;  // Calculator计算出来的原始路况src
    int32 method = 28;       // 用于标记平滑时采用传统还是ML方法
    rtt_sample_statistics_t samples_info = 29;  // 用于存储Calculator模块中各标签样本数
    rtt_multiflow_status_t multiflow_status = 30; // 多流向状态
    int32 mt_speed = 31;  // 路况速度 for 美团
    int32 mt_status = 32; // 路况状态 for 美团
    int32 rtti_src = 33;  // 富媒体来源 0-众包设备,1-滴滴设备
    int32 storm_status = 34;  // 人工干预前Jstorm生产的路况状态
    rtt_subsection_status_t subsection_status = 35; // 分段路段数据: 内部字段存储各段的千分数和状态
}

// 批量接口
message rtt_seg_status_bucket_t {
    repeated rtt_seg_status_t seg_bucket = 1;
    uint32 count = 2;    // 包的个数
    uint32 idx = 3;      // 当前包的idx, 0为起始值
    uint32 batch = 4;    // 路况的批次信息
    string ver = 5;
    uint32 admin_code = 6;
    bool high_priority = 7; // for merge status
}

// 某个城市的一个批次的发布信息统计结果
message rtt_city_publish_stat_t {
    uint32 city_id = 1;     // 城市id
    uint32 timestamp = 2;     // 发布时间戳
    int32 pub_link_count = 3;
    int32 show_link_count = 4;  // 前台展示的link总数
    int32 calc_link_count = 5;  // 后台计算的link总数
    float show_link_percent = 6;  // 前台展示的link比例
    float calc_link_percent = 7;  // 后台计算的link比例
}

////////////////////////////////////////////////////////////////
// 新增加一系列与交通延误信息相关的message
message xl_delayinfo_t {
    int32 delay_time = 1; // 单车延误时间或平均延误时间,秒
    float stop_times = 2; // 单车停车次数或平均停车次数
    int32 queue_len = 3;  // 排队长度，米
    int32 speed = 4;  // 行驶速度，单位：0.01km/h
    float jam_index = 5; // 拥堵指数
    int32 travel_time = 6; // 行程时间,秒
    repeated int32 stop_dists = 7;  // 停车距离数组,米
    int32 truck_percent = 8;  // 对单车，0表示非货车；非0表示货车；对于路段或路口，则表示百分比数值
    // 以下字段在单车情形下不使用
    int32 car_num = 9;  // 车辆个数
    int32 park_percent = 10; // 停车率, 1表示0.0001
    int32 turn_ratio_0 = 11; // 直行占比, 1表示0.0001
    int32 turn_ratio_1 = 12; // 左转占比, 1表示0.0001
    int32 turn_ratio_2 = 13; // 右转占比, 1表示0.0001
    int32 turn_ratio_3 = 14; // 掉头占比, 1表示0.0001
    int32 vacant_green_percent = 15;  // 空放占比, 1表示0.0001
    int32 ffs = 16;              // 自由流速度, 单位：0.01km/h
    int32 capacity = 17;        // 通行能力, 辆/小时
    int32 overflow = 18;        // 是否溢流0/1
    int32 imbalance = 19;       // 是否失衡0/1
    int32 deadlock = 20;        // 是否死锁0/1
    string overflow_desc = 21;  // 溢流描述信息
    string imbalance_desc = 22; // 失衡描述信息
    int32 move_speed = 23;  // 不停车速度，单位：0.01km/h
    float imbalance_index = 24; // 失衡系数
    // 新增加的指标
    int32 park_time = 25; // 单车停车时间或平均停车时间,秒
    int32 high_park_percent = 26; // 发生多次停车的占比,取值0~100,1表示1%
    int32 std_flow = 27; // 相对流量,取值1~100,0表示无数据,计算规则为：实际单位小时流量/当日小时流量峰值
};

// 单车的延误信息
message xl_car_delayinfo_t {
    uint64 car_id = 1;  // 车ID
    uint64 xlink_id = 2; // 星路的linkid
    int32 turn_type = 3;  // 转向类型,0,1,2,3表示：直行、左转、右转、掉头
    xl_delayinfo_t delay_info = 4;  // 延误信息
    uint32 pass_timestamp = 5; // 车辆经过路口的时间戳
    uint64 out_xlink_id = 6;  // 下游路段的星路linkid
};

// 一批单车延误数据
message xl_car_delayinfo_bkt_t {
    repeated xl_car_delayinfo_t bkt = 1;  // 单车延误数据集合
    int32 citycode = 2;   // 城市编码
    uint32 pack_info = 3; // 批次分装信息
    uint64 t = 4;         // 计算批次的Unix时间戳
    string ver = 5;       // 版本信息，预留
}

//////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////
// 对外公开的单流向延误数据message

// 路段单流向延误特征
message xl_inroad_flow_record_t {
    uint64 seg_id = 1;    // 路段id
    string inroadid = 2;    // 进口道ID    
    int32 turn_type = 3;    // 转向类型, 整数取值范围：0~3
    int32 car_num = 4;      // 车辆个数, 整数取值范围：0~1000
    int32 truck_percent = 5; // 货车比例, 整数取值范围：0~100
    int32 delay_time = 6;    // 延误时间, 整数取值范围：0~600
    float stop_times = 7;   // 平均停车次数, 浮点数取值范围：0~10
    int32 queue_len = 8;    // 排队长度, 整数取值范围：0~500
    int32 speed = 9;        // 平均行驶速度, 整数取值范围：0~15000
    int32 move_speed = 10;  // 不停车速度, 整数取值范围：0~15000
    float jam_index = 11;   // 拥堵指数, 浮点数取值范围：0.0~50.0
    int32 travel_time = 12; // 行程时间, 整数取值范围：0~3600
    repeated int32 stop_dists = 13;  // 等灯距离数组, 数组内整数元素取值范围：0~500
    uint32 timestamp = 14; // 数据时间戳
};

// 路段单流向延误特征的集合
message xl_inroad_flow_record_bkt_t {
    repeated xl_inroad_flow_record_t bkt = 1;  // 单流向的延误数据集合
    int32 citycode = 2;   // 城市编码
    uint32 pack_info = 3; // 批次分装信息
    uint64 t = 4;         // 计算批次的Unix时间戳
    string ver = 5;       // 版本信息，预留
};


/////////////////////////////////////////////////////////

/// @brief 时段信息
message xl_tp_t
{
    int32 start_hm = 1; // 时段开始的小时分钟数字,后2位为分钟,高位为小时,如:930表示09:30
    int32 end_hm = 2;   // 时段结束的小时分钟数字,后2位为分钟,高位为小时
    int32 weekday = 3;  // 限定星期几, 0表示不限制，1~7对应7天，8表示工作日；9表示周末。当取值为yyyymmdd时，表示具体的一天
    int32 type    = 4;  // 时段类型,默认0表示普通时段,1表示小时级时段,2表示单日典型时段
};

// 单个流向的延误信息
message xl_flow_delayinfo_t {
    uint64 xlink_id = 1; // 星路的xlinkid
    string inroadid = 2; // 进口道ID
    int32 turn_type = 3;  // 转向类型,0,1,2,3表示：直行、左转、右转、掉头
    xl_delayinfo_t delay_info = 4;  // 延误信息
    uint64 timestamp = 5; // 执行汇总统计的时间窗末尾时刻，通常为整分或整5分的时刻
    int32 time_window = 6;  // 统计时间窗，单位为分钟
    xl_tp_t tp = 7;  // 时段信息，为tp赋值，则表示这是该路口在这个时段内的延误信息
    int32 daynum = 8;   // 统计日期，yyyymmdd
};

// 一批进口道的延误数据
message xl_flow_delayinfo_bkt_t {
    repeated xl_flow_delayinfo_t bkt = 1;  // 流向的延误数据集合
    int32 citycode = 2;   // 城市编码
    uint32 pack_info = 3; // 批次分装信息
    uint64 t = 4;         // 计算批次的Unix时间戳
    string ver = 5;       // 版本信息，预留
}

// 单个进口道包含的所有流向的延误信息
message xl_inroad_delayinfo_t {
    uint64 xlink_id = 1; // 星路的xlinkid
    string inroadid = 2; // 进口道ID
    xl_delayinfo_t delay_info = 3;  // 进口道的延误信息
    repeated xl_flow_delayinfo_t flow_delay_infos = 4;  // 多个流向的延误信息
    uint64 timestamp = 5; // 执行汇总统计的时间窗末尾时刻，通常为整分或整5分的时刻
    int32 time_window = 6;  // 统计时间窗，单位为分钟
    xl_tp_t tp = 7;  // 时段信息，为tp赋值，则表示这是该路口在这个时段内的延误信息
    int32 daynum = 8;   // 统计日期，yyyymmdd
};

// 一批进口道的延误数据
message xl_inroad_delayinfo_bkt_t {
    repeated xl_inroad_delayinfo_t bkt = 1;  // 进口道延误数据集合
    int32 citycode = 2;   // 城市编码
    uint32 pack_info = 3; // 批次分装信息
    uint64 t = 4;         // 计算批次的Unix时间戳
    string ver = 5;       // 版本信息，预留
}

// 转向的统计信息
message xl_turninfo_t {
    int32 car_num = 1;  // 车辆个数
    int32 turn_ratio_0 = 2; // 直行占比, 1表示0.0001, 也可以直接整数表示车辆个数。
    int32 turn_ratio_1 = 3; // 左转占比, 1表示0.0001，同上。
    int32 turn_ratio_2 = 4; // 右转占比, 1表示0.0001，同上。
    int32 turn_ratio_3 = 5; // 掉头占比, 1表示0.0001，同上。
};

// 一辆车的转向记录
message xl_turn_record_t {
    uint64 in_xlinkid = 1;  // 灯前的xlinkid
    uint64 out_xlinkid = 2; // 灯后的xlinkid
    int32 turn_type = 3;  // 转向类型,0,1,2,3表示：直行、左转、右转、掉头
    uint32 timestamp = 4; // 车辆经过路口的时间戳
}

// 单个出口道包含的信息
message xl_outroad_info_t {
    uint64 xlink_id = 1; // 星路的xlinkid
    string outroadid = 2; // 出口道ID
    xl_turninfo_t turn_info = 3;  // 转向信息
    xl_tp_t tp = 4;  // 时段信息
    int32 daynum = 5;   // 统计日期，yyyymmdd
};


// 一批出口道的转向数据
message xl_outroad_info_bkt_t {
    repeated xl_outroad_info_t bkt = 1;  // 出口道转向数据数据集合
};


// 单个路口的包含的所有流向的延误信息
message xl_cross_delayinfo_t {
    string crossid = 1; // 路口ID
    xl_delayinfo_t delay_info = 2;  // 路口的延误信息
    repeated xl_inroad_delayinfo_t inroad_delay_infos = 3;  // 所有进口道的所有流向的延误信息
    uint64 timestamp = 4; // 执行汇总统计的时间窗末尾时刻，通常为整分或整5分的时刻
    int32 time_window = 5;  // 统计时间窗，单位为分钟
    xl_tp_t tp = 6;  // 时段信息，为tp赋值，则表示这是该路口在这个时段内的延误信息
    int32 daynum = 7;   // 统计日期，yyyymmdd
    repeated xl_outroad_info_t outroad_infos = 8;  // 所有出口道的转向统计信息
};


// 一批路口的延误数据
message xl_cross_delayinfo_bkt_t {
    repeated xl_cross_delayinfo_t bkt = 1;  // 路口延误数据集合
    int32 citycode = 2;   // 城市编码
    uint32 pack_info = 3; // 批次分装信息
    uint64 t = 4;         // 计算批次的Unix时间戳
    string ver = 5;       // 版本信息，预留
};

////////////////////////////////////////////////////////////////////////////////
// 城市路口巡检报告相关的结构体定义

// 一个转向结构体
message xl_cross_flow_t {
    string inroadid = 1; // 进口道ID
    int32 turn_type = 2;  // 转向类型,0,1,2,3表示：直行、左转、右转、掉头
};

// 路口问题结构体
message xl_cross_problem_t {
    xl_cross_delayinfo_t cross_delay = 1;
    repeated xl_cross_flow_t target_flows = 2;  // 有问题的转向或进口道列表
};

// 路口潮汐计算详情结构体
message xl_cross_tide_detail_t {
    int32 L1 = 1; // 早高峰较大的进口道流量
    int32 L2 = 2; // 早高峰较小的进口道流量
    repeated string inroadid_pair1 = 3;
    int32 L3 = 4; // 晚高峰较大的进口道流量
    int32 L4 = 5; // 晚高峰较小的进口道流量
    repeated string inroadid_pair2 = 6;
    float Fa = 7; // 早高峰的潮汐指数
    float Fb = 8; // 晚高峰的潮汐指数
    int32 pair_mode = 9; // 早晚高峰的对向进口道模式，0:不确定, 1:相同, 2:相反
};

// 路口潮汐结构体
message xl_cross_tide_t {
    string crossid = 1; // 路口ID 
    int32 daynum = 2;   // 统计日期，yyyymmdd
    float tide_index = 3;   // 潮汐系数，0表示无意义
    bool is_tide = 4;   // 是否发生潮汐现象
    xl_cross_tide_detail_t detail = 5; // 计算过程数据，便于核查结果
};

// 路口巡检的整体指标
message xl_cross_inspection_index_t {
    xl_delayinfo_t day_index = 1;   // 日报指标，for day_report
    xl_delayinfo_t week_index = 2;   // 全周时段的指标，for week_report
    xl_delayinfo_t workday_index = 3;   // 工作日时段的指标，for week_report    
    xl_delayinfo_t weekend_index = 4;   // 周末时段的指标，for week_report
};

// 路口进口道的转向车道资源不匹配问题
message xl_inroad_turnlane_mismatch_t {
    string crossid = 1; // 路口ID
    string inroadid = 2; // 进口道ID
    xl_tp_t tp = 3;  // 时段信息
    int32 flow_percent0 = 4;  // 直行流量占比，取值0~100, 默认赋值为0，如果>0，则表示该流向的车道数不足
    int32 flow_percent1 = 5;  // 左转流量占比，取值0~100, 默认赋值为0，如果>0，则表示该流向的车道数不足。以上2个字段只会有一个大于0。
    repeated float lane_nums = 6;  //  包含4个元素依次为: 直行车道数，左转车道数，右转车道数，掉头车道数
};


// 城市路口巡检报告
message xl_cross_report_t {
    int32 area_id = 1;  // 辖区ID
    int32 citycode = 2; // 城市编码
    int32 daynum = 3;   // 统计日期，yyyymmdd
    int32 type = 4;  // 报告类型，0表示日报，1表示周报
    xl_cross_inspection_index_t job_index = 5;    // 整体指标
    xl_cross_inspection_index_t job_index_prev = 6;    // 前一个周期的整体指标
    repeated xl_cross_delayinfo_t all_crosstp_indexes = 7;    // 整体指标
    repeated xl_cross_delayinfo_t all_crosstp_indexes_prev = 8;    // 整体指标    // 前一个周期的整体指标
    // 以下是各类问题的结构体
    repeated xl_cross_problem_t multi_park_crosses = 9;  // 多次停车的路口  
    repeated xl_cross_problem_t bad_park_crosses = 10;  // 停车次数多的路口
    repeated xl_cross_problem_t inroad_imbalance_crosses = 11;  // 进口道失衡的路口
    repeated xl_cross_problem_t turn_imbalance_crosses = 12;  // 转向失衡的路口
    repeated xl_cross_tide_t tide_crosses = 13;  // 潮汐路口
    repeated xl_inroad_turnlane_mismatch_t inroad_turnlane_mismatchs = 14;  // 进口道转向车道资源不匹配问题
};

/////////////////////////////////////////////////////////////////////////////////


/// 路口的单日流量数据
message xl_cross_flowdata_t
{
    string crossid = 1;  // 路口ID
    repeated int32 flows = 2;  // 流量数组，每个元素对应一个15分钟时段的流量数据，共计96个元素
    int32 daynum = 3;  // 统计日期
};

message xl_cross_flowdata_bkt_t
{
    repeated xl_cross_flowdata_t bkt = 1;  // 路口流量数据集合
    int32 citycode = 2;   // 城市编码
};

/////////////////////////////////////////////////////////////////////////////////


// 一个link的一个hts数据项
message rtt_tlink_hts_item_t {
    uint64 xlink_id = 1;  // xlink_id,需要经过转换才能得到四维linkid
    uint32 tp = 2;  // 一周内10分钟时段序号,取值0~1007
    int32 speed = 3;  // 速度,km/h
    int32 status = 4;  // 状态, 取值：0,1,2
    float fringe = 5;  // 速度靠近状态边界的相对程度
    int32 next_change_tp_num = 6;  // 下次状态改变的tp个数
    int32 sd = 7;  // 速度标准差
};
// hts数据项数组,用于在一个消息
message rtt_tlink_hts_bkt_t {
    repeated rtt_tlink_hts_item_t hts_bkt = 1;
};


//  经过link的车流计数信息
message rtt_link_car_flow_t
{
    uint64 xlink_id = 1;
    int32 flow = 2;  // 车流量
    int32 orig_flow = 3; // 原始车流量
    uint64 out_xlink_id = 4;  // 下游路段的tlinkid
    int32 speed = 5;  // 车流速度
}

// 车流计数信息集合
message rtt_link_car_flow_bkt_t
{
    repeated rtt_link_car_flow_t  flow_bkt = 1; // 车流计数信息集合
}

// 速度突变点信息:sop
message rtt_speed_odd_point_t
{
    int32 pos = 1;       // 在link上相对起点的距离
    uint32 odd_time = 2; // 速度变化的时刻
    uint64 link_id = 3;  // linkid,  包含dir，不是tlinkid
    uint32 lon = 4;      // 轨迹点原始经度*10的6次方
    uint32 lat = 5;      // 轨迹点原始纬度*10的6次方
    int32 direction = 6;  // 方位角,取值[0，360)
    uint64 car_id = 7; // 车ID，当该字段被赋值时，表示单车速度变化点
    int32 car_num = 8; // 发现sop的车辆个数
    uint32 update_time = 9; // 事件被检测或发布的时刻
    uint32 end_time = 10;  // 预计事件消失的时刻
    int32 citycode = 11;  // 所属的城市编码
    string detail = 12;    // 传递一些额外的信息
}

// 单个红绿灯时间片段
message rtt_rg_single_slice_t {
    sint32 phase = 1; // 1,0分别表示红灯和绿灯
    int32 offset_start = 2; // 相对于计算时刻，时间片段起点时刻的偏移秒数
    int32 offset_end = 3;   // 相对于计算时刻，时间片段终点时刻的偏移秒数
    int32 dist_to_light = 4;  // 停车位置到信号灯的距离，单位:米
};

// 红绿灯快照：时间片段序列
message rtt_rg_slices_t {
    uint64 car_id = 1;    // 车ID
    uint64 xlink_id = 2;  // 紧挨着信号灯的xlink_id
    uint32 timestamp = 3;  // 检测输出这个红绿时间片段序列的时间戳
    repeated rtt_rg_single_slice_t slices = 4; // 多个红绿时间片段
    uint64 out_xlink_id = 5;  // 下游的第一个普通link的tlinkid
    int32 turn_type = 6;  // 转向类型,现有取值:0,1,2,3分别表示:直行,左转,右转,掉头
};

// 一批红绿灯快照
message rtt_rg_slices_bkt_t {
    repeated rtt_rg_slices_t bkt = 1;
};