精华内容
下载资源
问答
  • 车路协同技术

    2019-07-29 08:23:52
    车路协同系统:基于无线通信、传感探测等技术进行车路信息获取,通过车车、车路信息交互和共享,并实现车辆和基础设施之间智能协同与配合,达到优化利用系统资源、提高道路交通安全、缓解交通拥堵的目标。
  • 车路协同技术.ppt

    2021-01-12 16:52:53
    车路协同技术.ppt
  • 车路协同讲座ppt.ppt

    2019-11-28 12:20:12
    车路协同讲座
  • 阿里车路协同

    千次阅读 2018-11-01 20:34:34
    阿里无人车的最新进展——从单车智能到车路协同 9 月 6 日,阿里达摩院与交通运输部公路科学研究院(公路院)签署战略合作,成立车路协同联合实验室。 与车路协同相对应的是“单车智能”,这是包括谷歌以及一众...

    阿里无人车的最新进展——从单车智能到车路协同

    单车智能、车路协同

    与车路协同相对应的是“单车智能”,这是包括谷歌以及一众无人驾驶创业公司选择的技术路径。所谓“单车智能”,就是让无人驾驶车辆本身变得更聪明,正确及时地感知、决策、控制,以应对各种复杂路况。但这种技术方案由于自身传感器等的局限,不能达到安全的要求。


    车路协同核心是在打造自动驾驶体系时,由车向路延展。简单来说就像是为自动驾驶车辆开启“上帝视角”,通过在道路的固定位置设置智能感知基站,为无人车在马路上建起“瞭望台”,让自动驾驶车辆从单兵作战转变为有组织有调度的配合战。
    究竟为何要把“路”纳入智能体系?从安全性角度考虑,即便在一辆车上装满传感器,受限于车子的高度,它仍然会存在盲区;此外,感知雷达的精度范围只有几十米,车速较高的情况下有追尾风险。而一旦采用,“瞭望台”可以把自己的视野分享给车,即便车上没有摄像头,它也能预判每条路的实时路况。

    与其说车路协同是无人驾驶更好的解决方案,不如说这是互联网巨头在结合自身云平台优势后,选择的折中路线。通过让道路变得更聪明,从而降低了对车辆的要求,在降低单车成本的同时,也有望让自动驾驶车辆更快上路。协同智能不论是在在感知、决策,还是在控制上都是对单车智能的全面升级。


    阿里布局无人驾驶,抢占物联网入口

    9 月 6 日,阿里达摩院与交通运输部公路科学研究院(公路院)签署战略合作,成立车路协同联合实验室

    阿里巴巴人工智能实验室首席科学家王刚透露,在前期的对比路测试验中,车路协同已经体现出极高的优势。在多次对比路测中,他们设置了可移动假人从障碍物后突然出现的场景,在不开启道路协同的情况下,紧急避让全部失灵,在开启后紧急避让或停车全部成功。
    该实验室未来的研究方向主要结合交通的实际需求,以车路协同技术自动驾驶技术大数据&云控平台基础设施智能化作为主要的研究目标,其中车路协同技术是基础性技术,对其他几个方向有支撑作用。

    事实上,车路协同概念并不是阿里的原创,早在上个世纪50年代,二战后的美国汽车行业就提出“让公路来引导汽车驾驶”。
    不同的是,此前的车路协同重点放在如何通讯上,即研发通讯技术能让路传送信息给车。而阿里更关注感知,他们的方案是定义传送什么样的信息,即路需要精确感知到什么信息,什么样的信息是对车有用的,然后我们可以将不同的信息用已有的通信方案传送给不同的车辆。通俗的说,他们的方案让车“知道“路上发生了什么,而此前的方案则仅仅实现了车与路之间的通信。


    从这些布局可以看出,相比于生产无人驾驶汽车,阿里更看好的是无人车作为未来物联网入口的战略地位。


    感知基站

    阿里巴巴公布的车路协同技术方案的核心技术之一是感知基站,王刚将其大概原理形容为“手机的无线发射基站,可以实现车与路、车与车之间的信息连接点。”但是对于解决方案技术细节,阿里并未做太多公开。

    由于遮挡、可视距离等限制,自动驾驶车辆的传感器不能保证对路面物体的时刻感知。为了克服这一限制,阿里研发了全新的智能设备-车路协同感知基站。它是由多种传感器高效运算单元组成,可以帮车辆进行路线规划和定位的车外大脑。


    车路协同感知基站分布在道路的关键节点,实时感知周围环境并将感知信息发送给车辆。感知基站的工作半径高达 200 米。
    这一基站安装在视野条件较好的高处,如抓拍摄像头、交通信号灯附近。之所以称安装了基站就像是给车开启了“上帝视角”,原因有三:
    1)感知基站视角较高,相比于安装在车上的传感器,可以获得更多信息;
    2)安装在路边的感知基站是静止的,相对于运动中的传感器,识别结果更为精准;
    3)智能感知基站彼此之间互联互通。基于密集的感知网络,车辆可以预知道路上发生了什么,决胜于千里之外。


    借助于感知基站,车辆可以提前感知到原始规划路线上发生的道路堵塞,重新进行道路规划,有效避开交通堵塞。利用感知基站网络提供的信息,车辆还可以智能地识别避让从自动驾驶车辆盲区出现的行人,同时提前感知下一路口的路况。


    智能基站可以理解为,以前是在车上装眼睛,现在我们把这个眼睛和一部分大脑装在路上。车上眼睛能做什么,路上就能做什么事情,而且还能做得更好。它可以对车进行定位,也能帮助我们更新高清地图,这些事情都可以做。


    阿里人工智能实验室负责人浅雪表示,目前感知基站方面还处于第一个阶段,感知基站和自动驾驶实现产品化落地还有很多工作要做。道路的智能化可以降低车的配置,从而降低自动驾驶车辆本身的成本。而车路协同的整体成本,则与基站设置的密度等相关。“基站如何部署、成本如何,我们目前正在讨论,具体信息不便透露。”

    车路协同方案理论上可以有效弥补自动驾驶在安全性和成本方面的不足,但道路与车辆协调配合带来多传感器融合和信号实时传输方面的难度加大,智能驾驶汽车本身的感知与决策问题也仍待解决。实际上想要达到理想效果,对基站感知的准确性、通讯的实时性都有极高要求。



    展开全文
  • 车路协同环境下紧急车辆信号控制优先通行系统实现车路协同环境下紧急车辆信号控制优先通行系统实现
  • V2X 是采用先进的无线通信和新一 代互联网等技术,实现与各交通要素的直接交互,综合实现碰撞预警、安全 预防及通报、辅助驾驶等多种应用; 同时,通过与云端的交互,车辆可以实时 获取全局交通网络的状态并作出...
  • 同研究的关键,本文设计了一种车路协同决策级融合架构,并提出了基于车路系统感知和车载感知的双层轨迹安全校验策略。然后,对车路数据通信模块进行设计,包括通信方案选型和数据交互协议设计,在 Linux 下基于 TCP ...
  • 2020年中国车路协同行业概览.pdf
  • V2X(Vehicle to Everything)车路协同系统是车联网中实现环境感知、信息交互与协同控制的重要关键技术。文 章旨在阐述基于 LTE(Long Term Evolution)-V 及 DSRC(Dedicated Short Range Communication)V2X 车路...
  • 车路协同感知系统坐标统一问题 1 四个坐标 ①小蚂蚁局部坐标 ②小蚂蚁全局坐标 ③路端局部坐标 ④路端全局坐标 默认1,2,3没有问题,或者误差忽略不计。 因为路端没有GPS,因此④存在问题 注: ①所有坐标均为xy,...

    由于路端设备是倾斜的,存在角度问题,需要变换

    【路端局部坐标系】

    1倾角计算

    流程

    1. 获得一帧点云
    2. 剪裁点云,只剩下地面
    3. RANSAC平面拟合
    4. 计算平面与水平面夹角

    1获得一帧点云,保存为pcd

    #include <ros/ros.h>
    #include <sensor_msgs/PointCloud2.h>
    #include <pcl_conversions/pcl_conversions.h>
    #include <pcl/point_cloud.h>
    #include <pcl/point_types.h>
    #include <pcl/io/ply_io.h>
    #include <pcl/visualization/pcl_visualizer.h>
    #include <pcl/filters/voxel_grid.h>
    #include <pcl/io/io.h>
    #include <time.h>
    
     
    int flag=1;
     
    void cloudCallback(const sensor_msgs::PointCloud2 ros_cloud)
    {
        //ROS_INFO("cloud is going");
        pcl::PointCloud<pcl::PointXYZ> pcl_cloud_temp;
        pcl::fromROSMsg(ros_cloud, pcl_cloud_temp);
        if(flag==1)
        {
            pcl::io::savePCDFileASCII ("./road_pcd.pcd", pcl_cloud_temp); //将点云保存到PCD文件中
            flag=0;
            std::cout<<"saved one"<<endl;
        }
    }
    int main(int argc, char **argv)
    { 
        ros::init(argc, argv, "pcd_get");
        ros::NodeHandle n;
        ROS_INFO("begin");
        ros::Subscriber cloud_sub = n.subscribe("/converted_velodyne_points", 50, cloudCallback);
        ros::spin();
        return 0;
    }
    

    2剪裁点云,提取地面

    #include <iostream>
    #include <vector>
    
    #include <boost/shared_ptr.hpp>
    
    #include <pcl/point_types.h>
    #include <pcl/point_cloud.h>
    #include <pcl/io/pcd_io.h>
    #include <pcl/visualization/pcl_visualizer.h>
    
    #include<pcl/filters/passthrough.h>  //直通滤波器头文件
    #include<pcl/filters/voxel_grid.h>  //体素滤波器头文件
    #include<pcl/filters/statistical_outlier_removal.h>   //统计滤波器头文件
    #include <pcl/filters/conditional_removal.h>    //条件滤波器头文件
    #include <pcl/filters/radius_outlier_removal.h>   //半径滤波器头文件
    
    using pcl::visualization::PointCloudColorHandlerGenericField;
    using pcl::visualization::PointCloudColorHandlerCustom;
    using namespace std;
    int main(int argc, char *argv[])
    {
        std::cout<<"cnm"<<endl;
    	//读取
    	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
    	if (pcl::io::loadPCDFile<pcl::PointXYZ>("/home/qm/my_projects/pcl_projects/pcd/road_pcd.pcd", *cloud) == -1)
    	{
    		std::cerr << "open failed!" << std::endl;
    		return -1;
    	}
    
    
    
    
    	//
    	//直通滤波器对点云 x方向进行处理。*/
    	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_x_PassThrough(new pcl::PointCloud<pcl::PointXYZ>);//
    
    	pcl::PassThrough<pcl::PointXYZ> passthrough_x;
    	passthrough_x.setInputCloud(cloud);//输入点云
    
    	passthrough_x.setFilterFieldName("x");//对z轴进行操作
    	passthrough_x.setFilterLimits(-5.0, 5.0);//设置直通滤波器操作范围
    	// passthrough.setFilterLimitsNegative(true);//true表示保留范围内,false表示保留范围外
    	passthrough_x.filter(*cloud_x_PassThrough);//执行滤波,过滤结果保存在 cloud_after_PassThrough
    
    
    
    	//直通滤波器对点云 y方向进行处理。*/
    	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_y_PassThrough(new pcl::PointCloud<pcl::PointXYZ>);//
    
    	pcl::PassThrough<pcl::PointXYZ> passthrough_y;
    	passthrough_y.setInputCloud(cloud_x_PassThrough);//输入点云
    
    	passthrough_y.setFilterFieldName("y");//对z轴进行操作
    	passthrough_y.setFilterLimits(-100, 0.0);//设置直通滤波器操作范围
    	// passthrough.setFilterLimitsNegative(true);//true表示保留范围内,false表示保留范围外
    	passthrough_y.filter(*cloud_y_PassThrough);//执行滤波,过滤结果保存在 cloud_after_PassThrough
    
    	//点保存点云
    	pcl::io::savePCDFileASCII("./road_ground.pcd", *cloud_y_PassThrough);//将点云保存到PCD文件中
    	std::cerr << "Saved" << cloud_y_PassThrough->points.size() << "data points to test_pcd.pcd" << std::endl;
    
    
    
    
    
    
    
    
    	//显示
    	boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
    	viewer->setBackgroundColor(0, 0, 0);
    	viewer->addPointCloud<pcl::PointXYZ>(cloud_y_PassThrough, "sample cloud");
    	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    	viewer->addCoordinateSystem(1.0);
    	viewer->initCameraParameters();
    
    	while (!viewer->wasStopped())
    	{
    		viewer->spinOnce(100);
    		boost::this_thread::sleep(boost::posix_time::microseconds(100000));
    	}
    
    	return 0;
    }
    

    3 RANSAC 点云平面拟合

    注意看看提取的点云是不是真的一个平面
    调整ransac.setDistanceThreshold(0.1);//设定阈值 默认0.3
    越小越精细

    #include <iostream>
    #include <pcl/console/parse.h>
    #include <pcl/io/pcd_io.h>
    #include <pcl/point_types.h>
    #include <pcl/point_cloud.h>
    #include <pcl/sample_consensus/ransac.h>
    #include <pcl/sample_consensus/sac_model_plane.h>
    #include <pcl/visualization/pcl_visualizer.h>
    #include <boost/thread/thread.hpp>
    #include <Eigen/Core>
    
    using namespace std;
    
    int main(int argc, char** argv)
    {
    	pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
    	pcl::PointCloud<pcl::PointXYZ>::Ptr final(new pcl::PointCloud<pcl::PointXYZ>);
    	
    	pcl::io::loadPCDFile<pcl::PointXYZ>("/home/qm/my_projects/pcl_projects/pcd/road_ground.pcd", *cloud);
    	std::cout<<"origin points num:"<<cloud->points.size()<<endl;
    
    	vector<int> inliers;	//用于存放合群点的vector
    
    	pcl::SampleConsensusModelPlane<pcl::PointXYZ>::Ptr model_plane(new pcl::SampleConsensusModelPlane<pcl::PointXYZ>(cloud));
    	pcl::RandomSampleConsensus<pcl::PointXYZ> ransac(model_plane);//定义RANSAC算法模型
    
    	ransac.setDistanceThreshold(0.1);//设定阈值 默认0.3
    	ransac.computeModel();//拟合平面
    
    
    	ransac.getInliers(inliers);//获取合群点
    	double a, b, c, d, A, B, C, D;//a,b,c为拟合平面的单位法向量,A,B,C为重定向后的法向量
    	Eigen::VectorXf coeff;
    	ransac.getModelCoefficients(coeff);//获取拟合平面参数,对于平面ax+by+cz+d=0,coeff分别按顺序保存a,b,c,d
    	cout << "coeff " << coeff[0] << " \t" << coeff[1] << "\t " << coeff[2] << "\t " << coeff[3] << endl;
    	a = coeff[0], b = coeff[1], c = coeff[2], d = coeff[3];
    	//---------------平面法向量定向,与(1,1,1)同向,并输出平面与原点的距离D----------------------
    	if (a + b + c > 0) {
    		A = a;
    		B = b;
    		C = c;
    		D = abs(d);
    	}
    	else {
    		A = -a;
    		B = -b;
    		C = -c;
    		D = abs(d);
    	}
    	cout<<" ABCD:"<<endl;
    	cout << "" << A << ",\t" << "" << B << ",\t" << "" << C << ",\t" << "" << D << ",\t" << endl;
    	pcl::copyPointCloud<pcl::PointXYZ>(*cloud, inliers, *final);
    
    
    	std::cout<<"final points num:"<<final->points.size()<<endl;
    	// pcl::io::savePCDFileASCII("1.11.pcd", *final);
    
    
    
    	//同时显示
    	// boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer("cloud show"));
    	// int v1 = 0;
    	// int v2 = 1;
    	// viewer->createViewPort(0, 0, 0.5, 1, v1);
    	// viewer->createViewPort(0.5, 0, 1, 1, v2);
    	// viewer->setBackgroundColor(0, 0, 0, v1);
    	// viewer->setBackgroundColor(0.05, 0, 0, v2);
    	// //----------------------------------原始点云绿色------------------------------
    	// pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> src_h(cloud, 0, 255, 0);
    	// //--------------------------------平面拟合后的点云----------------------------
    	// pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> after_sac(final, 0, 0, 255);
    	// viewer->setBackgroundColor(0, 0, 0);
    	// viewer->addPointCloud(cloud, src_h, "source cloud", v1);
    	// viewer->addPointCloud(final, after_sac, "target cloud1", v2);
    
    	// while (!viewer->wasStopped())
    	// {
    	// 	viewer->spinOnce(100);
    	// 	boost::this_thread::sleep(boost::posix_time::microseconds(10000));
    	// }
    
    
    	//显示单个
    	boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
    	viewer->setBackgroundColor(0, 0, 0);
    	viewer->addPointCloud<pcl::PointXYZ>(final, "sample cloud");
    	viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    	viewer->addCoordinateSystem(1.0);
    	viewer->initCameraParameters();
    
    	while (!viewer->wasStopped())
    	{
    		viewer->spinOnce(100);
    		boost::this_thread::sleep(boost::posix_time::microseconds(100000));
    	}
    
    	return 0;
    }
    

    4 计算点云平面与地面夹角

    Ax+By+Cz+D=0是一般方程
    法向量就是(A,B,C)

    #include<iostream>
    #include <cmath>
    using namespace std;
    int main (int argc, char *argv[])
    {
        // z=0
        double x1=0;
        double y1=0;
        double z1=1;
    
    
        // -0.0264245*x+0.382563*y+0.923552*z+3.34908=0 第一次
        //-0.0206086,	0.392848,	0.919372,	3.47223,	第二次
        double  x2=-0.0206086;
        double  y2=0.392848;
        double  z2=0.919372;
    
        // double  x2=1;
        // double  y2=0;
        // double  z2=0;
    
        double dz = z2 - z1;
        double dy = y2 - y1;
        double dx = x2 - x1;
        // cmath
        // arccos acos
        // 开根号 sqrt
        double t1=x1*x2+y1*y2+z1*z2;
        double l1=sqrt(x1*x1+y1*y1+z1*z1);
        double l2=sqrt(x2*x2+y2*y2+z2*z2);
    
        double cos_t=t1/(l1*l2);
        double angle_hd=acos(cos_t);
        double angle_jd=angle_hd * 180 / 3.1415926;
        // double angle = atan2( abs(dz), sqrt(dx * dx + dy * dy) );
        cout<<"angle"<<angle_jd<<endl;
        return 0;
    }
    

    5结果与准确性

    量角器也试了,大概就是20°左右一点点。证明OK

    rviz点云

    计算结果

    2 路段感知

    使用yoloact+激光雷达获得目标的

    • 类别
    • 激光雷达坐标系下的xy坐标,三维边界框

    3 坐标变换

    激光雷达坐标系下的xy坐标,转换到路端水平面的坐标

    示意图

    在这里插入图片描述

    x1=x0
    y1=y0cos(a)    //a为倾角
    

    【路端全局坐标系】

    车路协同感知系统坐标统一问题

    1 五个坐标

    ①小蚂蚁局部坐标系v1
    ②小蚂蚁全局坐标v2
    ③路端激光雷达坐标系r1
    ④路端水平坐标系r2
    ⑤路端全局坐标系r3

    其中:
    v1为车端感知,(感知的坐标数据都是在该坐标系下的)
    然后v1转v2(已有),获得路端全局坐标

    r1为车端感知,(感知的坐标数据都是在该坐标系下的)
    然后r1转r2(见下文)
    然后r2转r3(见下文,代码与上面的v1转v2一模一样)

    注:
    ①所有坐标均为xy,不要经纬度,不要z。
    ②全局坐标系原点均为GPS设备定义的xy原点

    2 如何获得路端全局坐标?

    小蚂蚁开到路端激光雷达下方即可,无需正下方,无需垂直。即可获得粗略的路端经纬度,进而得到全局xy坐标

    3 问题

    假设小蚂蚁刚刚好停在路测激光雷达正下方,刚刚好朝向和激光雷达重合,那么转换后同一个交通目标在路端与车端感知结果下应该是重合的,但是不可能刚刚好停到正下方,不可能刚刚好朝向准确,因此。需要计算误差(位置误差,角度误差)
    在这里插入图片描述

    在这里插入图片描述
    默认小蚂蚁的感知结果无误,消除路端误差

    计算偏移x,偏移y,偏转角a

    计算代码

    已知
    1 路端感知到的目标坐标(2个)
    x0=[75.0,82.0]
    y0=[107.0,40.0]

    2 小蚂蚁感知到的目标坐标(2个)
    x1=[12.432667397366075,51.99484522385715]
    y1=[188.46598839415688,133.94228634059948]
    在这里插入图片描述

    求 角度和位移

    0 基础:坐标变换函数(位移和旋转)

    # 顺时针为正,右边,上面为正
    def zb_convert(x,y,jlx=20,jly=5,hd=math.radians(30)):
        hd=-hd
        #平移 jlx jly是要平移的量
        x0=x+jlx
        y0=y+jly
        #旋转 hd是角度
        x1=math.cos(hd)*x0-math.sin(hd)*y0
        y1=math.sin(hd)*x0+math.cos(hd)*y0
        return (x1,y1)
    

    1 计算旋转角

    v1 v2是向量
    结果是角度

    def angle(v1, v2):
        dx1 = v1[2] - v1[0]
        dy1 = v1[3] - v1[1]
        dx2 = v2[2] - v2[0]
        dy2 = v2[3] - v2[1]
        angle1 = math.atan2(dy1, dx1)
        angle1 = int(angle1 * 180/math.pi)
        # print(angle1)
        angle2 = math.atan2(dy2, dx2)
        angle2 = int(angle2 * 180/math.pi)
        # print(angle2)
        if angle1*angle2 >= 0:
            included_angle = abs(angle1-angle2)
        else:
            included_angle = abs(angle1) + abs(angle2)
            if included_angle > 180:
                included_angle = 360 - included_angle
        return included_angle
    

    然后将x1,y1旋转到x11,y11

    2 计算位移

    lx=x0[0]-x11[0]
    ly=y0[0]-y11[0]
    

    然后将x11,y11旋转到x12,y12
    经过检验 x12,y12与x0,y0重合

    算法正确!
    在这里插入图片描述

    4 实战步骤

    在这里插入图片描述

    全部代码

    调参吧,前面都是作废!!
    road_data.txt

    road_angle 20.917188  激光雷达倾斜角
    road_delta_x 10  向左为正    路端偏移x
    road_delta_y 10  向前为正   路端偏移y
    road_delta_angle 90  左转为正  路端偏移角度
    road_jd 88.88     路端经度
    road_wd 77.77   路端纬度
    
    
    #include <iostream>
    #include<sstream>
    #include <ros/ros.h>
    #include<ros/time.h>
    #include <ros/duration.h>
    #include <cmath>
    
    #include <visualization_msgs/Marker.h>
    #include <visualization_msgs/MarkerArray.h>
    
    #include <perception_msgs/ObstacleArray.h>
    #include <perception_msgs/Obstacle.h>
    
    #include"qm_txt/qm_txt.h"
    #include"noval_convert_xy/qm_jwd_to_xy.h"
    
    
    using namespace std;
    # define PI 3.1415926
    
    class tilt_to_horizon_to_global
    {
    private:
      std::string road_tilt_perception_topic_name;
      std::string road_horizon_perception_topic_name;
      std::string road_global_perception_topic_name;
    
      std::string road_data_path;
    
      double road_angle;
    
      double delta_x;
      double delta_y;
      double delta_angle;
    
      double road_jd;
      double road_wd;
    
      qm_jwd_to_xy my_jwd_to_xy;
    
      qm_txt my_txt;
    
      double GPS_x;
      double GPS_y;
    
    
    private:
    	//创建节点句柄
    	ros::NodeHandle nh;
    	//声明订阅器
    	ros::Subscriber sub_road_lidar;
    	//声明发布器
    	ros::Publisher pub_road_horizon;
      ros::Publisher pub_road_global;
    
      ros::Publisher pub_marker_array_horizon;
      ros::Publisher pub_marker_array_global;
      //定时器
      // ros::Timer timer1;
    
    //每一帧的变量
    public:
      visualization_msgs::MarkerArray make_one_empty_markerarray();
      visualization_msgs::Marker make_one_empty_marker_car();
      visualization_msgs::Marker make_one_empty_marker_people();
      perception_msgs::ObstacleArray make_one_empty_ObstacleArray();
      perception_msgs::Obstacle make_one_empty_Obstacle();
      void pub_horizon_markers_from_obs(perception_msgs::ObstacleArray t);
      void pub_global_markers_from_obs(perception_msgs::ObstacleArray t);
    
    public:
    	//构造函数
    	tilt_to_horizon_to_global()
    	{
        //launch 参数赋值
        init_para();
    		//订阅
    		sub_road_lidar = nh.subscribe(road_tilt_perception_topic_name, 1, &tilt_to_horizon_to_global::callback_lidar, this);
    		//发布
    		pub_road_horizon = nh.advertise<perception_msgs::ObstacleArray>(road_horizon_perception_topic_name,1);
        pub_road_global = nh.advertise<perception_msgs::ObstacleArray>(road_global_perception_topic_name,1);
    
        pub_marker_array_horizon = nh.advertise<visualization_msgs::MarkerArray>("road_horizon_markers",1);
        pub_marker_array_global = nh.advertise<visualization_msgs::MarkerArray>("road_global_markers",1);
    
    	};
    
    
      void init_para();
    
      //回调函数
      void callback_lidar(perception_msgs::ObstacleArray t);
      // void o_timer_callback(const ros::TimerEvent& event);
    };
    
    void tilt_to_horizon_to_global::init_para()
    {
    
      ros::param::get("~road_tilt_perception_topic_name", road_tilt_perception_topic_name);
      ros::param::get("~road_horizon_perception_topic_name", road_horizon_perception_topic_name);
      ros::param::get("~road_global_perception_topic_name", road_global_perception_topic_name);
    
      ros::param::get("~road_data_path", road_data_path);
    
    
      my_txt.read_txt(road_data_path);
    
      std::cout<<"*********************"<<endl;
      // cout<<"my_txt.read_result[0][1]:"<<my_txt.read_result[0][1]<<endl;
      istringstream istr_road_angle(my_txt.read_result[0][1]);
      istr_road_angle >> road_angle;  //1234.56789
      cout<<"get road_angle: "<<road_angle<<endl;
      std::cout<<"*********************"<<endl;
    
      std::cout<<"*********************"<<endl;
      istringstream istr_delta_x(my_txt.read_result[1][1]);
      istr_delta_x >> delta_x;  //1234.56789
      cout<<"get delta_x: "<<delta_x<<endl;
      std::cout<<"*********************"<<endl;
    
      std::cout<<"*********************"<<endl;
      istringstream istr_delta_y(my_txt.read_result[2][1]);
      istr_delta_y >> delta_y;  //1234.56789
      cout<<"get delta_y: "<<delta_y<<endl;
      std::cout<<"*********************"<<endl;
    
      std::cout<<"*********************"<<endl;
      istringstream istr_delta_angle(my_txt.read_result[3][1]);
      istr_delta_angle >> delta_angle;  //1234.56789
      cout<<"get delta_angle: "<<delta_angle<<endl;
      std::cout<<"*********************"<<endl;
    
      std::cout<<"*********************"<<endl;
      istringstream istr_road_jd(my_txt.read_result[4][1]);
      istr_road_jd >> road_jd;  //1234.56789
      cout<<"get road_jd: "<<road_jd<<endl;
      std::cout<<"*********************"<<endl;
    
      std::cout<<"*********************"<<endl;
      istringstream istr_road_wd(my_txt.read_result[5][1]);
      istr_road_wd >> road_wd;  //1234.56789
      cout<<"get road_wd: "<<road_wd<<endl;
      std::cout<<"*********************"<<endl;
    
      my_jwd_to_xy.jwd_to_xy(road_jd,road_wd,GPS_x,GPS_y);
      std::cout<<"*********************"<<endl;
      std::cout<<"GPS x "<<GPS_x<<endl;
      std::cout<<"GPS y "<<GPS_y<<endl;
      std::cout<<"*********************"<<endl;
    
    }
    /空msg函数
    visualization_msgs::MarkerArray tilt_to_horizon_to_global::make_one_empty_markerarray()
    {
      visualization_msgs::MarkerArray t;
      return t;
    }
    visualization_msgs::Marker tilt_to_horizon_to_global::make_one_empty_marker_car()
    {
      visualization_msgs::Marker t;
      t.header.frame_id = "laser_link";
      t.header.stamp = ros::Time::now();
      // Set the namespace and id for this marker.  This serves to create a unique ID
      // Any marker sent with the same namespace and id will overwrite the old one
      t.ns = "car";
      t.id = 0;
      // Set the marker type.  Initially this is CUBE, and cycles between that and SPHERE, ARROW, and CYLINDER
      t.type = visualization_msgs::Marker::CUBE;
      // Set the marker action.  Options are ADD, DELETE, and new in ROS Indigo: 3 (DELETEALL)
      t.action = visualization_msgs::Marker::ADD;
      // Set the pose of the marker.  This is a full 6DOF pose relative to the frame/time specified in the header
      t.pose.position.x = 0;
      t.pose.position.y = 0;
      t.pose.position.z = 0;
      t.pose.orientation.x = 0.0;
      t.pose.orientation.y = 0.0;
      t.pose.orientation.z = 0.0;
      t.pose.orientation.w = 0.0;
      // Set the scale of the marker -- 1x1x1 here means 1m on a side
      t.scale.x = 0.0;
      t.scale.y = 0.0;
      t.scale.z = 0.0;
      // Set the color -- be sure to set alpha to something non-zero!
      t.color.r = 0.0f;
      t.color.g = 1.0f;
      t.color.b = 0.0f;
      t.color.a = 1.0;
      t.lifetime = ros::Duration(1);
      return t;
    }
    visualization_msgs::Marker tilt_to_horizon_to_global::make_one_empty_marker_people()
    {
      visualization_msgs::Marker t;
      t.header.frame_id = "laser_link";
      t.header.stamp = ros::Time::now();
      // Set the namespace and id for this marker.  This serves to create a unique ID
      // Any marker sent with the same namespace and id will overwrite the old one
      t.ns = "people";
      t.id = 0;
      // Set the marker type.  Initially this is CUBE, and cycles between that and SPHERE, ARROW, and CYLINDER
      t.type = visualization_msgs::Marker::CYLINDER;
      // Set the marker action.  Options are ADD, DELETE, and new in ROS Indigo: 3 (DELETEALL)
      t.action = visualization_msgs::Marker::ADD;
      // Set the pose of the marker.  This is a full 6DOF pose relative to the frame/time specified in the header
      t.pose.position.x = 0;
      t.pose.position.y = 0;
      t.pose.position.z = 0;
      t.pose.orientation.x = 0.0;
      t.pose.orientation.y = 0.0;
      t.pose.orientation.z = 0.0;
      t.pose.orientation.w = 0.0;
      // Set the scale of the marker -- 1x1x1 here means 1m on a side
      t.scale.x = 0.0;
      t.scale.y = 0.0;
      t.scale.z = 0.0;
      // Set the color -- be sure to set alpha to something non-zero!
      t.color.r = 0.0f;
      t.color.g = 1.0f;
      t.color.b = 0.0f;
      t.color.a = 1.0;
      t.lifetime = ros::Duration(1);
      return t;
    }
    perception_msgs::ObstacleArray tilt_to_horizon_to_global::make_one_empty_ObstacleArray()
    {
      perception_msgs::ObstacleArray t;
      return t;
    }
    perception_msgs::Obstacle tilt_to_horizon_to_global::make_one_empty_Obstacle()
    {
      perception_msgs::Obstacle t;
      t.header.frame_id = "fake";
      t.header.stamp = ros::Time::now();
      t.ns="obstacle";
      t.id=0;
    
      t.label="obstacle";
    
      // 设置标记位姿
      t.pose.position.x = 0;
      t.pose.position.y = 0;
      t.pose.position.z = 0;
      t.pose.orientation.x = 0;
      t.pose.orientation.y = 0;
      t.pose.orientation.z = 0;
      t.pose.orientation.w = 0;
    
      // 设置标记尺寸
      t.scale.x = 0;
      t.scale.y = 0;
      t.scale.z = 0;
    
      t.v_validity=0;
      t.vx=0;
      t.vy=0;
      t.vz=0;
    
      t.a_validity=0;
      t.ax=0;
      t.ay=0;
      t.az=0;
      return t;
    }
    void tilt_to_horizon_to_global::pub_horizon_markers_from_obs(perception_msgs::ObstacleArray obs_array)
    {
      visualization_msgs::MarkerArray tmp_marker_array;
      tmp_marker_array=make_one_empty_markerarray();
      for(int i=0;i<obs_array.obstacles.size();i++)
      {
        visualization_msgs::Marker tmp_marker;
        if(obs_array.obstacles[i].ns=="person")
        {
          tmp_marker=make_one_empty_marker_people();
          tmp_marker.color.r = 255/255;
          tmp_marker.color.g = 0/255;
          tmp_marker.color.b = 0/255;
        }
        else
        {
          tmp_marker=make_one_empty_marker_car();
          tmp_marker.color.r = 0/255;
          tmp_marker.color.g = 255/255;
          tmp_marker.color.b = 127/255;
        }
        //写入obs信息
        tmp_marker.id=i;
        tmp_marker.pose.position.x=obs_array.obstacles[i].pose.position.x;
        tmp_marker.pose.position.y=obs_array.obstacles[i].pose.position.y;
        tmp_marker.scale.x=obs_array.obstacles[i].scale.x;
        tmp_marker.scale.y=obs_array.obstacles[i].scale.y;
        tmp_marker.scale.z=obs_array.obstacles[i].scale.z;
        tmp_marker.pose.orientation.z = obs_array.obstacles[i].pose.orientation.z;
        tmp_marker.pose.orientation.w = obs_array.obstacles[i].pose.orientation.w;
        //
        tmp_marker_array.markers.push_back(tmp_marker);
      }
      pub_marker_array_horizon.publish(tmp_marker_array);
    }
    void tilt_to_horizon_to_global::pub_global_markers_from_obs(perception_msgs::ObstacleArray obs_array)
    {
      visualization_msgs::MarkerArray tmp_marker_array;
      tmp_marker_array=make_one_empty_markerarray();
      //减掉gps_x,否则看不到
      for(int i=0;i<obs_array.obstacles.size();i++)
      {
        visualization_msgs::Marker tmp_marker;
        if(obs_array.obstacles[i].ns=="person")
        {
          tmp_marker=make_one_empty_marker_people();
          tmp_marker.color.r = 255/255;
          tmp_marker.color.g = 0/255;
          tmp_marker.color.b = 0/255;
        }
        else
        {
          tmp_marker=make_one_empty_marker_car();
          tmp_marker.color.r = 0/255;
          tmp_marker.color.g = 255/255;
          tmp_marker.color.b = 127/255;
        }
        //写入obs信息
        tmp_marker.id=i+500;
        tmp_marker.pose.position.x=obs_array.obstacles[i].pose.position.x-GPS_x;
        tmp_marker.pose.position.y=obs_array.obstacles[i].pose.position.y-GPS_y;
        tmp_marker.scale.x=obs_array.obstacles[i].scale.x;
        tmp_marker.scale.y=obs_array.obstacles[i].scale.y;
        tmp_marker.scale.z=obs_array.obstacles[i].scale.z;
        tmp_marker.pose.orientation.z = obs_array.obstacles[i].pose.orientation.z;
        tmp_marker.pose.orientation.w = obs_array.obstacles[i].pose.orientation.w;
        //
        tmp_marker_array.markers.push_back(tmp_marker);
      }
      pub_marker_array_global.publish(tmp_marker_array);
    }
    /空msg函数
    
    
    /回调函数
    void tilt_to_horizon_to_global::callback_lidar(perception_msgs::ObstacleArray obs_array_lidar)
    {
      //##############################激光雷达——>水平
      perception_msgs::ObstacleArray obs_array_horizon;
      obs_array_horizon=obs_array_lidar;
      for(int i=0;i<obs_array_horizon.obstacles.size();i++)
      {
        //修改xyz参数
        double tmp_x=obs_array_horizon.obstacles[i].pose.position.x;
        double tmp_y=obs_array_horizon.obstacles[i].pose.position.y;
        double tmp_hd=PI/180*road_angle;
        double tmp_xx;
        double tmp_yy;
        //坐标变换
        tmp_xx=tmp_x;
        tmp_yy=tmp_y*acos(tmp_hd);
        // tmp_xx=acos(tmp_hd)*tmp_x-asin(tmp_hd)*tmp_y;
        // tmp_yy=asin(tmp_hd)*tmp_x+acos(tmp_hd)*tmp_y;
    
        //替换掉原有的xy
        obs_array_horizon.obstacles[i].pose.position.x = tmp_xx;
        obs_array_horizon.obstacles[i].pose.position.y = tmp_yy;
      }
      pub_road_horizon.publish(obs_array_horizon);
      pub_horizon_markers_from_obs(obs_array_horizon);
      //##############################激光雷达——>水平
    
      //##############################水平——>全局
      perception_msgs::ObstacleArray obs_array_global;
      obs_array_global=obs_array_horizon;
      for(int i=0;i<obs_array_global.obstacles.size();i++)
      {
    
        double tmp_x=obs_array_global.obstacles[i].pose.position.x;
        double tmp_y=obs_array_global.obstacles[i].pose.position.y;
    
        double tmp_delta_hd=PI/180*delta_angle;
        double tmp_xx;
        double tmp_yy;
        //坐标变换
        tmp_xx=cos(tmp_delta_hd)*tmp_x-sin(tmp_delta_hd)*tmp_y;
        tmp_yy=sin(tmp_delta_hd)*tmp_x+cos(tmp_delta_hd)*tmp_y;
        // cout<<"delta_angle: "<<delta_angle<<endl;
        // cout<<"tmp_delta_hd: "<<tmp_delta_hd<<endl;
        // cout<<"acos(tmp_delta_hd): "<<cos(tmp_delta_hd)<<endl;
        // cout<<"asin(tmp_delta_hd): "<<sin(tmp_delta_hd)<<endl;
        // tmp_xx=tmp_x;
        // tmp_yy=tmp_y;
    
        //替换掉原有的xy
        obs_array_global.obstacles[i].pose.position.x = tmp_xx+GPS_x+delta_x;
        obs_array_global.obstacles[i].pose.position.y = tmp_yy+GPS_y+delta_y;
      }
      pub_road_global.publish(obs_array_global);
      pub_global_markers_from_obs(obs_array_global);
      //##############################水平——>全局
    }
    int main(int argc, char **argv)
    {
        ros::init(argc, argv, "tilt_to_horizon_to_global");
        ros::NodeHandle nh("~");
    
        tilt_to_horizon_to_global a;
    
        ros::spin();
        return 0;
    }
    
    
    展开全文
  • 腾讯5G车路协同创新应用白皮书
  • 针对现有的城市道路车流检测方法的不足,利用定向天线构建了一种基于车路协同的十字路口车流检测系统。首先,在讨论车流数据的采集、处理方法的基础上,基于车路协同技术设计了一种车流量判定方法;然后,通过分析...
  • 2020年中国车路协同行业精品报告.pdf
  • 5G低时延高可靠的网络切片在车联网行业得到广泛关注,车路协同各场景的发展演进也体现了5G应用正逐步深化。从5G灵活的网络定制能力入手,分析了车路协同发展过程以及各业务场景对网络性能的需求,并基于典型的车路...
  • 在梳理城市交通控制随交通信息进步发展脉络的基础上,结合车路协同环境下交通信息采集的特点,综述分析单点控制、协调控制的研究现状,进一步总结了车路协同环境下城市交通控制的发展机遇和挑战。指出车路协同环境下...
  • 新基建下的自动驾驶:单车智能和车路协同之争.pdf
  • 对智能交通业务的发展趋势、车路协同技术及系统要求以及国内外发展现状进行了介绍;同时重点阐述了智能网联交通体系之车路协同云管边端架构方案,介绍了中心云、交通专网/电信网络、边缘云、车载/路侧终端协同的“云...
  • 车路协同的应用场景

    千次阅读 2019-10-10 17:11:17
    车路协同是基于无线通信、传感探测等技术进行车路信息获取,通过车车、车路信息交互和共享,并实现车辆和基础设施之间智能协同与配合达到优化利用系统资源、提高道路交通安全、缓解交通拥堵的目标。 车路协同实际上...

    车路协同是基于无线通信、传感探测等技术进行车路信息获取,通过车车、车路信息交互和共享,并实现车辆和基础设施之间智能协同与配合达到优化利用系统资源、提高道路交通安全、缓解交通拥堵的目标。

    车路协同实际上是把单车智能的部分成本转移到政府部门,由政府部门来使道路“智能化”,从而降低智能网联汽车传感器的配置要求,使其成本降低,加速普及。从具体场景上,有远期和近期的场景。远期的是面向自动驾驶的场景探索。近期场景是主要围绕车联网V2X的应用。

    (车路协同应用场景)

    典型的车路协同应用场景

    1. 盲点警告:当驾驶员试图换道但盲点处有车辆时,盲点系统会给予驾驶员警告;
    2. 前撞预警:当前面车辆停车或行驶缓慢而本车没有采取制动措施时,给予驾驶员警告;
    3. 电子紧急制动灯:当前方车辆由于某种原因紧急制动,而后方车辆因没有察觉而无采取制动措施时会给予驾驶员警告;
    4. 交叉口辅助驾驶:当车辆进入交叉口处于危险状态时给予驾驶员以警告,如障碍物挡住驾驶员视线而无法看到对向车流;
    5. 禁行预警:在可通行区域,试图换道但对向车道有车辆行驶时给予驾驶员警告;
    6. 违反信号或停车标志警告:车辆处于即将闯红灯或停车线危险状态时,驾驶员会收到车载设备发来的视觉、触觉或声音警告;
    7. 弯道车速预警:当车辆速度比弯道预设车速高时,系统会提示驾驶员减速或者采取避险措施;
    8. 道路交通状况提示:驾驶员会实时收到有关前方道路、天气和交通状况的最新信息,如道路事故、道路施工、路面湿滑程度、绕路行驶、交通拥堵、天气、停车限制和转向限制等。
    9. 车辆作为交通数据采集终端:车载设备传输信息给路测设备,此信息经路测设备处理变为有效、需要的数据;
    10. 匝道控制:根据主路和匝道的交通时变状况实时采集、传输数据来优化匝道控制;
    11. 信号配时:收集并分析交叉口车辆实际行驶速度及停车起步数据,使信号的实时控制更加有效。如果将实时数据处理时间提高10%,每年延误时间可减少170万小时,节省110万加仑汽油以及减少9600吨CO2排放;
    12. 专用通道管理:通过使用附近的或平行车道可平衡交通需求,也可使用控制策略,如当前方发生事故时可选择换向行驶;改变匝道配时方案;利用信息情报板发布信息,诱导驾驶员选择不同的路径;
    13. 交通系统状况预测:实时监测交通运输系统运行状况,为交通系统有效运行提供预测数据,包括旅行时间、停车时间、延误时间等;提供交通状况信息,包括道路控制信息、道路粗糙度、降雨预测、能见度和空气质量;提供交通需求信息,如车流量等。

    链接: 一文看懂车路协同的应用场景在哪里.

    展开全文
  • 车路协同关键技术研究--牵头申请单位:中国科学院合肥物质科学研究院 联合申请单位:长安大学 中国科学技术大学 奇瑞汽车股份有限公司
  • 基于车路协同的营运车辆交叉口危险报警系统性能要求和测试规程
  • 车路协同-智慧出行(智慧交通解决方案),精品一级
  • 车路协同也叫做V2X技术,车辆对车辆(V2V)、车辆对基础设施(V2I)、车辆对云(V2N)和车辆对行人(V2P)统称为V2X,是未来智能交通ITS基础性关键技术之一。V2X的两个核心单元为智能网联车载单元(OBU)和智能网联路侧单元...
  • 智能车路协同系统浅析

    千次阅读 2019-06-05 20:00:15
    写在前面的话:文章内容来源于但不限于网络、书籍、个人心得体会等,意在总结和方便各位同行快速参考,...智能车路协同系统即IVICS(Intelligent Vehicle Infrastructure Cooperative Systems),简称车路协同系统,是...
  • 2020年中国车路协同行业概览精品报告2020.pdf
  • 为面向未来自动驾驶技术的应用,研究车路协同技术(Vehicle-to-Infrastructure,V2I)与自适应巡航控制(Adaptive Cruise Control,ACC)技术结合下的车辆,在经过信号灯控制交叉口的通行特征。基于HELLY跟驰模型,...
  • 车路协同和智慧能源

    2020-12-30 16:06:06
    这是个好消息,也有利于我们推动车路协同项目。 未来的汽车一定是基于电能的,而其他能源形式可以先转化为电能,所以,电池和电池管理系统对未来的汽车很重要,从这个角度看,车里的人其实可以看作是电池,直接或者...
  • 无人驾驶技术中的车路协同技术和自适应巡航控制 (Adaptive Cruise Control,ACC) 技术为缓解交叉口处的交通拥堵和提高节能减排水平带来了新的契机。ACC 车辆可以通过车载检测设备和传感器技术等实时获取自身与前车的...
  • 车路协同通信(匿名)证书管理技术规范,v2x
  • 车路协同和商务交通

    2020-12-28 16:28:12
    商务活动中的面对面(face-to-face)沟通是不可替代的,在“活体传真”还没实现前,物理世界的交通还是必须的,从这个角度看,会有巨大的商业利益去推动交通的升级,这是为什么我会看好车路协同的首要原因。...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 364
精华内容 145
关键字:

车路协同