精华内容
下载资源
问答
  • 自动汽车档位说明及图解(转)

    千次阅读 2011-12-18 12:15:12
    自动汽车档位说明及图解(转) R ( Reverse):倒档 N ( Neutrial):空挡 ...D ( Drive):前进 ...【】自动汽车档位图解 或许有很多人不太了解自动汽车每个档位的用途
    自动挡汽车档位说明及图解(转) 
    


    R ( Reverse):倒档

    N ( Neutrial):空挡

    D ( Drive):前进挡

    2 ( Second gear):1-2档切换,缓坡

    1 ( First gear):严重堵车,陡坡

    P ( Parking):驻车

    【图】自动挡汽车档位图解


    或许有很多人不太了解自动挡汽车每个档位的用途和使用方法,我们用自动挡汽车档位图解来说明每一个自动档的实际作用,自动挡汽车有P档,R档,N档,D档,3档,2档和1档(L档)(如图所示),每个档位都有其不同的用途,在汽车的行驶过程中,我们需要时常更换档位来控制汽车,理解了自动挡汽车档位操作技巧以后才能够更熟练地驾驶汽车。

    1档说明:1档也是一些车型的L档,这是一个陡坡挡,汽车爬坡或者阻很大的情况下使用,在用1档的时候汽车的速度低但是蛮力非常大。

    2档说明:2挡也是一个前进的变速挡,波箱(变速箱)可以在1挡、2挡之间变换,只要把波箱档杆放到在2挡的位置上,汽车就会从1
    挡的速度中起步前进,速度变快的时候波箱就会自动跳到2挡上面去。汽车在上坡或者下坡中可以使用2挡,这样能够保持汽车的速度在上下坡同样的稳定。

    D档说明:这是前进挡,汽车前进行驶中使用的档位。大部分的自动档汽车D档位上面设计了1挡到高挡排序,有的是2挡到高挡排序的,开车的时候只要把变速拨杆放在D挡上面汽车的速度就会由你的油门来控制。

    N档说明:N档是空挡,如果将变速档杆放置在N挡上的话,汽车引擎就会和变速器之间的动力传递系统分开。空挡一般是在短暂的停车中使用。
    自动挡汽车档位图解

    P档说明:在停车的时侯需要把汽车档位放到这个位置上,p档是利用了汽车内部设计来控制汽车的转动系统,可以让汽车在倾斜的地面上都不会移动。如果我们需要把汽车摆放在一个位置上停下来很长时间,就应该拉好手刹再把杆位推到P档的位置上去。必须要注意的一点:汽车一定要在停止的状态下才可以用P挡。自动档汽车上还装有空挡启动的开关,可以让汽车只可以在P档或N挡才能点火发动汽车机,这样可以防止汽车在停止状态下启动的时候把档位误放到了其他的变速档上使汽车突然向前窜出去的情况。
    R档说明:这个是倒挡,我们在倒车的时候才会用得上。一般需要按下变速档上面的保险按钮装置才可将变速杆摆放到R挡上面。重点提醒您,在汽车前进的状态下不能够使用R档,必须要在停止的时候才可以使用。


    自动档车的开法
     首先,自动档一般都有P,R,N,D,3,2,1这些档位。并请牢记:
      P,停车档
      R,倒车档
      N,空档
      D,行车档
      3,2,1指强制把变速器限制在某一档以下,比如3就是把变速器强制限制在3档以下。
      好了,记住这些,很重要的。如果你知道停车,倒车,行驶,中性这些词英文怎么说,相信比较容易记住那些档位的符号。
    自动档车的开法之初级:
      首先,推不动档位杆时千万别用力,99%以上的可能是你做错了什么。比如,SO车的杆下面有一拉杆,拉上它才能从P档拉出或推入P档。在Polo上,是拇指位置的按钮,需要按下。千万注意,设这机关是为了防止误操作,什么行驶中推入R档或P档这些万分危险的动作!

      1. 停车时必须挂P档并拉手刹。这里停车是指较长时间停放,人可能离开车辆。
      2. 发动机只有在P和N两个档位可以点火。而且,因为第一点,停车后重新启动时,必定在P档。一般发动机点火前也无法挂其他档。
      正确的点火动作:
      2.1.
    把钥匙转1(或2)格;仪表盘上许多灯亮,此时车内的电脑开始自检(相当于PC的启动),同时,油泵开始工作。几秒钟以后,各灯熄灭。根据车的不同,有的灯点火以后才会熄灭。

      2.2. 踩下刹车,点火。
      2.3. 等发动机怠速下降到正常转速,水温表指针开始动以后,踩下刹车,挂D档,松手刹。
      2.4. 松刹车,走。
      上面点火过程同样适用于手动档的车,只是手动档的车必须踩离合点火。
      如果你认为环保或热车烧掉的一点点汽油比发动机寿命更重要,请跳过热车这一步。
      3. 和电脑游戏一样,踩油门加速,踩刹车减速。
      4. 遇见红灯或其他原因需要短时间停一停,踩刹车保持车静止。松刹车起步。
      5. 长时间停车,比如在铁路道口等火车通过,或者清楚地知道这个红灯时间很长;见第一点。
      (一个她转的文章:停止时间长时最好换入N位,并拉紧手制动。因为选挡杆在行驶位置上,自动变速器汽车一般都有微弱的行驶趋势,长时间踩住制动等于强行制止这种趋势,使得变速器油温升高,油液容易变质。尤其在空调器工作、发动机怠速较高的情况下更为不利。---长时间停车到底放P还是N好像从来没有争论清楚,新浪那里我看见吵了快两年,尤其是去年夏天,争论的不可开交,最后也没结论。反正我放P档,前轮后轮一起锁,再说,设计上停车就是P,反正没坏处。)

      6. 从D档到P档或R档,或者从R档挂到D档之前(车库里可能需要这么做),请确认车已经完全停下。
      


    自动档车的开法之中级:
      首先,许多自动档往往加速有延迟。当你踩下油门时,发动机转速上升很快,但加速不快,这一般在半秒到一秒之间。然后,加速度迅速上升,显得后劲很足。灵活掌握这一点,避免在市区刚加速就刹车;或者在高速上超车时万事具备,只差加速度的窘境。

      1. 没事别用N档。只有当:
       1.1. 行驶中熄火,赶紧推进空挡重新点火,点着以后推进D档开往修理厂。
       1.2.发动机怎么也打不着,需要别的车用拖车绳或者硬连接牵引的时候。挂N档。
       1.3.
    千万别象手动车一样空档溜车,除非你认为省那一点油钱比安全!!!和变速器的寿命重要。   曾经在新浪见过一位拆过自动变速器的DX的文章,和手动变速器不同,如果你推到N档,里面许多类似离合器的连接要断开。磨损比手动变速器推空档大许多。

      (一个她转的文章:有些驾驶员为了节油,在高速行驶或下坡时将选挡杆扳到N位滑行,这很容易烧坏变速器,因为这时变速器输出轴转速很高,而发动机却在怠速运转,油泵供油不足,润滑状况恶化,易烧坏变速器。 ---专业)
      2.
    在行驶时,如果你松油门,变速器往往会认为你想进入经济(或曰省油)模式,这时,可能的话,变速器会自动升一档。但是,变速器绝对不会象出租车司机那样时速40已经到5档了。所以,可能的话,注意一下一般变速器在什么时候升档。比如SO,正常时,如果在速度略大于20,40时松油门,会升档。在市区道路,灵活使用油门升档会降低油耗。

      3. 在高速公路上超车时,手动档的技巧之一就是降一档。自动档也可以实现这个功能,只是不那么直接。
       3.1. 先加速,或确定你车的速度和对方差不多或略快。需要的话变道。
       3.2. 轻踩油门,松油门。
       3.3. 重复一遍3.2.的动作。
       3.4. 猛地踩下油门,注意,猛踩油门。你就会体验到发动机的吼声和推背感。爽!
      我的经验是,原来的速度太慢的话,要么这个功能用不出来,要么即使降了档,超着也费劲。
    建议平时在没什么车的路上练习练习,避免到时候动作变形,油门是踩下去了,档位没降。
    现在一般好的自动变速器都有记忆、学习功能,开的时间长了,你的习惯会被它接受,并体现到换档的动作里去的。
      4. 前面讲过,1,2,3档是指变速器档位被强制限制在XX档以下。这和手动档的概念不同,呵呵,胖的老师批评得对。
       4.1.
    在上长、陡的坡道时,如果你挂在D档,你可能会觉得变速器忙着换档,一会升,一会降的。这时很伤变速器。应该刹车*边停下,挂1,2或3档然后启动。具体挂那个档要看你的具体情况了。比如一般手排车2档可以上去的坡,自动变速器一直在忙,那么放在2档上面应该没错。

       4.2.
    在下长、陡的坡道时,如果你挂在D档,你可能需要一直用刹车控制车速;如果长时间频繁使用刹车,刹车可能因为过热而效率下降,这很危险;还有,许多山路没有铺柏油,石子路猛踩刹车更危险,即使有ABS。虽然Polo的前后盘刹散热比较好,但用发动机控制车速并辅以刹车还是开这种路比较稳妥的方法。刹车*边停下,挂1,2或3档然后启动。上面一样,参考手动档车的档位决定到底用几档。

       4.3.
    注意,千万不要在行驶中把档从D推到1,2,3中的如何一个。如果你的变速器处于高档位,强行推到低档位,呵呵,我不用说,杀鸡一样的声音会让你心疼,郁闷一阵的。如果变速器损坏,那可属于中修,4~5数的费用那!毕竟,PST以下级别的车好象都没装手/自一体变速器。

      (一个她转的文章:但是从D位换入S位或L位时,车速不能高于相应的升挡车速,否则发动机会强烈振动,使变速器油温急剧上升,甚至会损坏变速器。---专业,问题是很多时候难以判断,所以稳妥一点吧!自己血汗钱买的车)

      5.
    前面说过,许多DX开手动档的车时喜欢通过使用空档滑行来省油,虽说理论上这不是好习惯,但要是我开手排车,我也这么干。自动档不可以这么干确实让人不爽,但自动档的车有另外一点有趣的特点:行驶中松油门,车开始减速。到大约45~50的时候,车速下降明显减慢,可以以几乎匀速运行很长距离。这时油耗也很低。灵活使用这个特点,也可以取得和空档溜车近似的效果,而且没丧失动力,何乐不为那?当然,右脚还是应该处于时刻可以在第一时间踩下刹车的状态。

      6.
    说道弯道,我想还是保守一点好,先粗粗地判断你可以以什么速度通过这个弯而稳定地保持对车的控制。在进弯之前把车速降低,降低到你判断的速度,最好慢于这个速度。进弯就尽量不要踩刹车了。保持车速,如果速度慢了就稍微加一点油门。进弯别太快!!看见没有,几乎每个立交桥的弯道隔离栏或边上的水泥墙上都有一道道别的车碰、擦的痕迹。

    (转自:森林人论坛_汽车之家)http://club.autohome.com.cn/bbs/thread-c-285-6418033-1.html


    展开全文
  • 本田思域自动车型的档位有P、N、R 、D/S。挂挡方法如下。 ①D:前进档位,按住档把侧边按键,踩住刹车可挂入此档。 ②S:即运动档,在需要大扭矩的情况下使用。在D档位置再往后拉动档把即可完成档位挂入。解除S...

    本田思域自动挡车型的档位有P、N、R 、D/S。挂挡方法如下。

    ①D:前进档位,按住档把侧边按键,踩住刹车可挂入此档。
    
    ②S:即运动档,在需要大扭矩的情况下使用。在D档位置再往后拉动档把即可完成档位挂入。解除S档,需要在此时位置往后拉动档把。 此过程不再需要踩刹车
    
    ③N:空档,又名怠速档。按住侧键,上推档把。
    
    ④R:倒车档,如果在N档位置,继续上推档把。
    
    ⑤P:驻车档,长按档位侧键旁边的“P”按键。
    
    ⑥手动模式:在“D”档位置,将档杆往右推。往上推加档,往下拉减档。
    

    本田思域换挡操作技巧

    1、换挡拨片的使用

    刹车踏板先踩死,换入“D”档,而往右边推动档位把手。这时开始就能利用换挡拨片进行手动加减档,“+”拨片代表加档,“-”拨片代表降档。手动模式虽然繁琐一些,不过可以精确控制合适转速与扭矩时的档位切换。

    ①上坡:坡道路段需要比平时更大的扭矩支撑,建议用“D-”降速升扭。如果发现动力充沛,应该用“D+”进行升档以保护变速箱与发动机。如果动力还是不够,可以使用S档运动模式。
    
    ②下坡:应该使用“D+”升至2/3档,发动机牵制可以防止由于长时间刹车而造成刹车片发热失效。1档扭矩太大,一般23档已经可达到不错的牵制效果。同样如果遇到车辆越溜越快的情况,也要通过“D-”对车辆进行减档控制。
    
    展开全文
  • 找挡板最终程序

    2021-01-30 16:30:39
    } /***** 点到直线的距离:P到AB的距离*****/ //P为线外一点,AB为线段两端点,有正负,点在左边为负,右边为正 float getDist_P2L_zhengfu(CvPoint pointP, CvPoint pointA, CvPoint pointB) { //求直线方程 ...
    /******************************************************************
    程序说明放置挡板,为了保证挡板不超过误差,
    更新时间:8月19日18点
    更新时间:8月20日16点
    *******************************************************************/
    
    #include "Dangban.h"
    extern VideoCapture cap_up;
    extern VideoCapture cap_down;
    extern Mat imgOriginal_up, imgOriginal_down;//用于缓存图像
    
    extern int G_threshold_down;
    extern int G_threshold_up;
    
    //RGB转HSV
    void RGB2HSV(double red, double green, double blue, double& hue, double& saturation, double& intensity)
    {
    
    	double r, g, b;
    	double h, s, i;
    
    	double sum;
    	double minRGB, maxRGB;
    	double theta;
    
    	r = red / 255.0;
    	g = green / 255.0;
    	b = blue / 255.0;
    
    	minRGB = ((r<g) ? (r) : (g));
    	minRGB = (minRGB<b) ? (minRGB) : (b);
    
    	maxRGB = ((r>g) ? (r) : (g));
    	maxRGB = (maxRGB>b) ? (maxRGB) : (b);
    
    	sum = r + g + b;
    	i = sum / 3.0;
    
    	if (i<0.001 || maxRGB - minRGB<0.001)
    	{
    		h = 0.0;
    		s = 0.0;
    	}
    	else
    	{
    		s = 1.0 - 3.0*minRGB / sum;
    		theta = sqrt((r - g)*(r - g) + (r - b)*(g - b));
    		theta = acos((r - g + r - b)*0.5 / theta);
    		if (b <= g)
    			h = theta;
    		else
    			h = 2 * 3.1415926 - theta;
    		if (s <= 0.01)
    			h = 0;
    	}
    
    	hue = (int)(h * 180 / 3.1415926);
    	saturation = (int)(s * 100);
    	intensity = (int)(i * 100);
    }
    //
    ///***** 求两点间距离*****/
    //float getDistance(CvPoint pointO, CvPoint pointA)
    //{
    //	float distance;
    //	distance = powf((pointO.x - pointA.x), 2) + powf((pointO.y - pointA.y), 2);
    //	distance = sqrtf(distance);
    //	return distance;
    //}
    
    //原点到直线的距离
    //输入一堆直线,返回直线到坐标原点的距离
    vector <float> get_0_distance(vector<Vec4i> lines)
    {
    	vector <float> diatance;
    
    	for (unsigned int i = 0; i < lines.size(); i++)
    	{
    		double k = (double)(lines[i][1] - lines[i][3]) / (double)(lines[i][0] - lines[i][2]);//斜率
    		double b = (double)lines[i][1] - (double)(lines[i][0])* k; //截距
    		double diatance_temp = fabs(b / sqrt(1 + k*k));
    		diatance.push_back(diatance_temp);
    	}
    	return diatance;
    
    }
    
    /***** 点到直线的距离:P到AB的距离*****/
    //P为线外一点,AB为线段两个端点,有正负,点在左边为负,右边为正
    float getDist_P2L_zhengfu(CvPoint pointP, CvPoint pointA, CvPoint pointB)
    {
    	//求直线方程
    	float A = 0, B = 0, C = 0;
    	A = pointA.y - pointB.y;
    	B = pointB.x - pointA.x;
    	C = pointA.x*pointB.y - pointA.y*pointB.x;
    	//代入点到直线距离公式
    	float distance = 0;
    
    
    	if (pointP.x>(-(B*pointP.y + C) / A))
    	{//点在线右边
    		distance = ((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    	}
    	else
    	{//点在线左边
    		distance = -((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    	}
    	return distance;
    }
    
    
    /***** 点到直线的距离:P到AB的距离*****/
    //P为线外一点,剩下三个参数为直线一般式参数,0为横挡板,1为竖挡板
    float getDist_P2L_zhengfu_2(CvPoint pointP, float Param_A1, float Param_A2, float Param_A3,int mode)
    {
    	//求直线方程
    	float A = 0, B = 0, C = 0;
    	A = Param_A1;
    	B = Param_A2;
    	C = Param_A3;
    	//代入点到直线距离公式
    	float distance = 0;
    	if (mode == 0)//横挡板判断上下
    	{
    		if (pointP.y>(-(A*pointP.x + C) / B))
    		{//点在线上面
    			distance = ((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    		}
    		else
    		{//点在线下面
    			distance = -((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    		}
    	}
    	else  //竖挡板判断左右
    	{
    		if (pointP.x>(-(B*pointP.y + C) / A))
    		{//点在线右边
    			distance = ((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    		}
    		else
    		{//点在线左边
    			distance = -((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    		}
    
    	}
    
    	return distance;
    }
    
    
    //输入一堆直线,返回每条直线与水平直线的角度,为弧度
    vector <float> get_lines_arctan(vector<Vec4i> lines)
    {
    	float k = 0; //直线斜率
    	vector <float> lines_arctan;//直线斜率的反正切值
    	for (unsigned int i = 0; i<lines.size(); i++)
    	{
    
    		k = (double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率
    		lines_arctan.push_back(atan(k));
    	}
    	return lines_arctan;
    }
    
    /***** 点到一堆直线的距离:P到lines的距离*****/
    vector <float> getDist_P2L_yibanshi(Point2f pointP, vector<Vec4i> lines)
    {
    	//求直线方程
    	Point2f pointA, pointB;
    	vector <float>  distance;
    	for (unsigned int i = 0; i < lines.size(); i++)
    	{
    
    		pointA.x = (float)lines[i][0];
    		pointA.y = (float)lines[i][1];
    		pointB.x = (float)lines[i][2];
    		pointB.x = (float)lines[i][3];
    
    		float A = 0, B = 0, C = 0;
    		A = pointA.y - pointB.y;
    		B = pointB.x - pointA.x;
    		C = pointA.x*pointB.y - pointA.y*pointB.x;
    		//代入点到直线距离公式
    		float distance_temp;
    		distance_temp = ((float)abs(A*pointP.x + B*pointP.y + C)) / ((float)sqrtf(A*A + B*B));
    
    		distance.push_back(distance_temp);
    	}
    	return distance;
    }
    
    
    
    //输入一堆直线,返回每条直线的斜率和截距
    //Vec2f为2个点的float,参照存储直线的数据结构
    vector <Point2d> get_lines_fangcheng(vector<Vec4i> lines)
    {
    	double k = 0; //直线斜率
    	double b = 0; //直线截距
    	vector <Point2d> lines_fangcheng;//
    
    	for (unsigned int i = 0; i<lines.size(); i++)
    	{
    
    		k = (double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率// -3.1415926/2-----+3.1415926/2
    		b = (double)lines[i][1] - k * (double)lines[i][0]; //求出直线的截距
    		lines_fangcheng.push_back(Point2d(k, b));
    	}
    
    	return lines_fangcheng;
    }
    
    
    //填充
    void fillHole(const Mat srcBw, Mat &dstBw)
    {
    	Size m_Size = srcBw.size();
    	Mat Temp = Mat::zeros(m_Size.height + 2, m_Size.width + 2, srcBw.type());//延展图像
    	srcBw.copyTo(Temp(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)));
    
    	cv::floodFill(Temp, Point(0, 0), Scalar(255, 255, 255));//填充区域
    
    	Mat cutImg;//裁剪延展的图像
    	Temp(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)).copyTo(cutImg);
    
    	dstBw = srcBw | (~cutImg);
    }
    
    
    
    
    //输入一堆直线,返回每条直线的一般式方程
    //Vec2f为2个点的float,参照存储直线的数据结构
    vector <float> get_lines_yibanshi_fangcheng(vector<Vec4i> lines)
    {
    	//1.分别求角点0、1与角点2、3所对应的两根直线
    	//vector <vector<float>> fangcheng_PARAM;
    	vector<float> fangcheng_temp;
    
    	for (unsigned int i = 0; i < lines.size(); i++)
    	{
    		float A0 = 0, B0 = 0, C0 = 0;
    		A0 = (float)(lines[i][1] - lines[i][3]);
    		if ((lines[i][1] - lines[i][3]) == 0)
    		{
    			A0 = 0.0001;
    		}
    		B0 = (float)(lines[i][2] - lines[i][0]);
    		if ((lines[i][2] - lines[i][0]) == 0)
    		{
    			B0 = 0.0001;
    		}
    		C0 = (float)(lines[i][0] * lines[i][3] - lines[i][1] * lines[i][2]);
    		if (C0 == 0)
    		{
    			C0 = 0.0001;
    		}
    		/*	if ((lines[i][2] - lines[i][0]) == 0)
    		{
    		B0 =0.001;
    		if (A0>0)
    		{
    		C0 =-fabs( (float)(lines[i][0] * lines[i][3] - lines[i][1] * lines[i][2]));
    		}
    		else
    		{
    		C0 = fabs((float)(lines[i][0] * lines[i][3] - lines[i][1] * lines[i][2]));
    		}
    
    		}
    		else
    		{
    		B0 = (float)(lines[i][2] - lines[i][0]);
    		C0 = (float)(lines[i][0] * lines[i][3] - lines[i][1] * lines[i][2]);
    		}
    		*/
    
    		//A0 = (float)(Connor[0].y - Connor[1].y);
    		//B0 = (float)(Connor[1].x - Connor[0].x);
    		//C0 = (float)(Connor[0].x*Connor[1].y - Connor[0].y*Connor[1].x);
    		fangcheng_temp.push_back(A0);
    		fangcheng_temp.push_back(B0);
    		fangcheng_temp.push_back(C0);
    
    		//	fangcheng_PARAM.push_back(fangcheng_temp);
    
    	}
    	return fangcheng_temp;
    }
    
    
    
    
    /*******************************************************************************************
    *函数功能 : 输入两条直线(每条直线以斜率和截距确定),返回两直线夹角,0为弧度,1为角度(不能计算垂直直线)
    *输入参数 : line_1_k为一条直线斜率,line_2_k为另一条直线斜率,aaa为0则为弧度,反之则为角度
    *返 回 值 : float型弧度或者角度,有正负,为直线2相对于直线1的角度
    *编写时间 : 2018.8.5
    *作    者 : 毛哥
    ********************************************************************************************/
    float get_lines_arctan(float line_1_k, float line_2_k, int aaa)
    {
    	if (aaa == 0)
    	{
    		float tan_k = 0; //直线夹角正切值
    		float lines_arctan;//直线斜率的反正切值
    		tan_k = (line_2_k - line_1_k) / (1 + line_2_k*line_1_k); //求直线夹角的公式
    		lines_arctan = atan(tan_k);
    		return lines_arctan;
    	}
    	else
    	{
    		float tan_k = 0; //直线夹角正切值
    		float lines_arctan;//直线斜率的反正切值
    		tan_k = (line_2_k - line_1_k) / (1 + line_2_k*line_1_k); //求直线夹角的公式
    		lines_arctan = atan(tan_k)* 180.0 / 3.1415926;
    
    		return lines_arctan;
    	}
    }
    
    
    /*******************************************************************************************
    *函数功能 : 输入两条直线(输入一般式三个参数),返回两直线夹角,0为弧度
    *输入参数 : Param_A1、Param_B1、Param_C1 \Param_2、Param_B2、Param_C2输入一般式三个参数
    *返 回 值 : double 型角度,有正负,为直线2相对于直线1的角度
    *编写时间 : 2018.8.6
    *作    者 : 毛哥
    ********************************************************************************************/
    double get_lines_yibanshi_arctan(double Param_A1, double Param_B1, double Param_C1, double Param_A2, double Param_B2, double Param_C2)
    {
    
    	double tan_k = 0; //直线夹角正切值
    	double lines_arctan;//直线斜率的反正切值
    	double line_1_k = 0;
    	double line_2_k = 0;
    
    	//	tan_k = (line_2_k - line_1_k) / (1 + line_2_k*line_1_k); //求直线夹角的公式
    
    	if (fabs(Param_B1) > 0.00001 && fabs(Param_B2) > 0.00001)
    	{
    		line_1_k = -Param_A1 / Param_B1;
    		line_2_k = -Param_A2 / Param_B2;
    
    		//若两直线垂直,即k1k2 = -1,此时夹角为90°;
    		if (line_1_k*line_2_k != -1)
    		{
    			tan_k = (line_2_k - line_1_k) / (1 + line_2_k*line_1_k); //求直线夹角的公式
    			//tan_k = (Param_A1*Param_A2 + Param_B1*Param_B2) / (sqrt(Param_A1*Param_A1 + Param_B1*Param_B1)*sqrt(Param_A2*Param_A2 + Param_B2*Param_B2));
    			lines_arctan = atan(tan_k)* 180.0 / 3.1415926;;
    		}
    	}
    	else if (Param_B1 < 0.00001&& Param_B2>0.00001)
    	{
    
    		tan_k = -Param_A2 / Param_B2;
    		lines_arctan = atan(tan_k);
    		lines_arctan = (3.1415926 / 2 - lines_arctan)* 180.0 / 3.1415926;
    	}
    	else if (Param_B1 > 0.00001&&Param_B2 < 0.00001)
    	{
    
    		tan_k = -Param_A1 / Param_B1;
    		lines_arctan = atan(tan_k);
    		lines_arctan = (lines_arctan - 3.1415926 / 2)* 180.0 / 3.1415926;
    
    	}
    	else
    	{
    		lines_arctan = 0;
    	}
    	return lines_arctan;
    }
    
    
    
    
    
    
    //输入一直线的两个端点,返回该直线的一般式方程
    vector <float> get_lines_yibanshi_fangcheng_2(Point2f Point_A, Point2f Point_B)
    {
    	//1.分别求角点0、1与角点2、3所对应的两根直线
    	//vector <vector<float>> fangcheng_PARAM;
    	vector<float> fangcheng_temp;
    	float A0 = 0, B0 = 0, C0 = 0;
    
    	//A0 = (float)(lines[i][1] - lines[i][3]);
    	//B0 = (float)(lines[i][2] - lines[i][0]);
    	//C0 = (float)(lines[i][0] * lines[i][3] - lines[i][1] * lines[i][2]);
    
    	A0 = (float)(Point_A.y - Point_B.y);
    	B0 = (float)(Point_B.x - Point_A.x);
    	C0 = (float)(Point_A.x*Point_B.y - Point_A.y*Point_B.x);
    	fangcheng_temp.push_back(A0);
    	fangcheng_temp.push_back(B0);
    	fangcheng_temp.push_back(C0);
    
    	//fangcheng_PARAM.push_back(fangcheng_temp);
    
    	return fangcheng_temp;
    }
    
    
    /***** 7、输入A,B,C,画出线在dstImage*****/
    void draw_line_1(float A, float B, float C, Mat dstImage)
    {
    	//Ax+By+C=0
    	float y0, y1, x0, x1;
    	if (B == 0)
    	{
    		B = 0.001;
    	}
    	if (A == 0)
    	{
    		A = 0.001;
    	}
    	float k = 0, b = 0;
    	k = -A / B;
    	b = -C / B;
    	y0 = k * 0.0 + b;
    	y1 = k * 800.0 + b;
    	x0 = (0.0 - b) / k;
    	x1 = (600.0 - b) / k;
    
    	vector<Point> draw_point;
    	if (y0 >= 0 && y0 <= 600)
    	{
    		Point p;
    		p.x = 0;
    		p.y = y0;
    		draw_point.push_back(p);
    	}
    	if (y1 >= 0 && y1 <= 600)
    	{
    		Point p;
    		p.x = 800;
    		p.y = y1;
    		draw_point.push_back(p);
    	}
    	if (x0 >= 0 && x0 <= 800)
    	{
    		Point p;
    		p.x = x0;
    		p.y = 0;
    		draw_point.push_back(p);
    	}
    	if (x1 >= 0 && x1 <= 800)
    	{
    		Point p;
    		p.x = x1;
    		p.y = 600;
    		draw_point.push_back(p);
    	}
    	if (draw_point.size() >= 2)
    	{
    		line(dstImage, draw_point[0], draw_point[1], Scalar(0, 0, 255), 2, LINE_AA);
    	}
    }
    /*******************************************************************************************
    *函数功能 : 找每个轮廓的中心坐标
    *输入参数 :轮廓或者凸包
    *返 回 值 : 点向量
    *编写时间 : 2018.8.9
    *作    者 : 毛哥
    ********************************************************************************************/
    vector< Point2f> find_lunkuo_zhongxin(vector<vector<Point>> dangban_RectContours)
    {
    
    	vector<Point2f> zhongxin_zuobiao;
    	/// 计算矩
    	vector<Moments> mu(dangban_RectContours.size());
    	for (int i = 0; i < dangban_RectContours.size(); i++)
    	{
    		mu[i] = moments(dangban_RectContours[i], false);
    	}
    	///  计算中心矩:
    	vector<Point2f> mc(dangban_RectContours.size());
    	for (int i = 0; i < dangban_RectContours.size(); i++)
    	{
    		mc[i] = Point2f(mu[i].m10 / mu[i].m00, mu[i].m01 / mu[i].m00);
    		zhongxin_zuobiao.push_back(mc[i]);
    	}
    
    	return	zhongxin_zuobiao;
    
    }
    
    /*函数功能:求两条直线交点*/
    /*输入:两条Vec4i类型直线*/
    /*返回:Point2f类型的点*/
    Point2f getCrossPoint(Vec4i LineA, Vec4i LineB)
    {
    	double ka, kb;
    	Point2f crossPoint;
    	if ((LineA[2] - LineA[0]) != 0)
    	{
    		ka = (double)(LineA[3] - LineA[1]) / (double)(LineA[2] - LineA[0]); //求出LineA斜率
    		kb = (double)(LineB[3] - LineB[1]) / (double)(LineB[2] - LineB[0]); //求出LineB斜率
    
    
    		crossPoint.x = (ka*LineA[0] - LineA[1] - kb*LineB[0] + LineB[1]) / (ka - kb);
    		crossPoint.y = (ka*kb*(LineA[0] - LineB[0]) + ka*LineB[1] - kb*LineA[1]) / (ka - kb);
    	}
    
    
    	return crossPoint;
    }
    //两点之间距离
    float getDistance_1(CvPoint pointO, CvPoint pointA)
    {
    	float distance;
    	distance = powf((pointO.x - pointA.x), 2) + powf((pointO.y - pointA.y), 2);
    	distance = sqrtf(distance);
    	return distance;
    }
    
    
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头拟合出横着或者竖着的直线(大体)
    *输入参数 : 图片,0为横着,1为竖着
    *返 回 值 : 单条直线的ABC值,
    *编写时间 : 2018.8.12
    *作    者 : 毛哥
    ********************************************************************************************/
    vector <float> nihe_zhixian_dantiao(int flag)
    {
    
    	vector <float> fangcheng_PARAM_1;
    	vector <float> fangcheng_PARAM_final;
    
    	double Param_A1[4] = { 0 };
    	double Param_B1[4] = { 0 };
    	double Param_C1[4] = { 0 };
    	int lvbo = 0;
    
    	Mat frame_2;
    	while (1)
    	{
    
    		frame_2 = imgOriginal_up;
    		Mat srcImg1, midImage, dstImage;//临时变量和目标图的定义
    
    		int width = frame_2.cols; //宽
    		int height = frame_2.rows;
    		Mat	image_copy_C3;
    
    	 if (flag == 0)//横着
    		{
    			Rect rect(0, frame_2.rows*0.3, frame_2.cols, frame_2.rows*(0.95 - 0.3));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    		}
    		else //竖着
    		{
    			Rect rect(frame_2.cols*0.075, frame_2.rows*0.2, frame_2.cols*(0.875 - 0.075), frame_2.rows*(0.83 - 0.2));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    
    		}
    		//从img中按照rect进行切割,此时修改image_cut时image中对应部分也会修改,因此需要copy  
    
    		midImage = Mat::zeros(image_copy_C3.size(), CV_8UC3);
    
    
    		//再次通过找轮廓,然后拟合出直线,通过斜率滤除剩下四条数线(或横线),然后通过长度滤除挡板的边缘直线,剩下白色过道的直线方程,一切问题得到解决。
    
    
    		cvtColor(image_copy_C3, srcImg1, CV_BGR2GRAY);//灰度化
    		//【3】srcImage取大于阈值119的那部分
    		srcImg1 = srcImg1 > G_threshold_up;
    
    		//namedWindow("二值化的图", 0);
    		//imshow("二值化的图", srcImg1);
    
    		//	midImage=findMaxContouns(srcImg1);
    		/*******  检测直线优化 开始 ****************************************************************/
    
    
    
    		/*****************************用找轮廓代替边缘检测************************************************/
    		vector<vector<Point>>contours_1, RectContours; //轮廓
    		findContours(srcImg1, contours_1, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    
    		if (contours_1.size() == 0)
    		{
    			cout << "警告:没有在裁剪后的图片里找到轮廓(第二次找轮廓)" << endl;
    			continue;
    		}
    		if (contours_1.size() > 0)//如果没有找到轮廓退出
    		{
    			vector<float> length(contours_1.size());
    			for (int i = 0; i < contours_1.size(); i++)
    			{//历遍所有的轮廓
    				length[i] = arcLength(contours_1[i], true);
    			}
    			if (contours_1.size() == 0)
    			{
    				cout << "警告:没有(第一次找轮廓)" << endl;
    				continue;
    			}
    			for (int i = 0; i < contours_1.size(); i++)
    			{
    				Scalar color = (255, 255, 255);//白色线画轮廓
    				drawContours(midImage, contours_1, i, color, 1, 8);//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    			}
    		}
    
    
    		cvtColor(midImage, midImage, CV_BGR2GRAY);//灰度化
    		midImage = midImage>20;
    		vector<Vec4i> lines, lines_final;//定义一个矢量结构lines用于存放得到的线段矢量集合
    		HoughLinesP(midImage, lines, 1, CV_PI / 180, 95, 40, 60);
    		if (lines.size() == 0)
    		{
    			cout << "没有检测到直线" << endl;
    			continue;
    		}
    		/*******  检测直线优化 结束 ****************************************************************/
    		cvtColor(midImage, dstImage, COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图
    		//画出挡板中轴线
    		//cout << "\n共检测到原始  直线" << lines.size() << "条" << endl;
    		//【4】依次计算出直线长度
    		float  zhixian_changdu;
    		float to_0_distance;
      	for (size_t i = 0; i < lines.size(); i++)
    	  	{
    
    			Vec4i l = lines[i];
    			to_0_distance = getDist_P2L_zhengfu(CvPoint(0, 0), Point(l[0], l[1]), Point(l[2], l[3]));
    			zhixian_changdu = getDistance_1(Point(l[0], l[1]), Point(l[2], l[3]));
    
    		//	cout << "\n直线长度为" << zhixian_changdu << endl;
    		//	cout << "到原点的距离" << to_0_distance << endl;
    			//画出原始直线
    			line(image_copy_C3, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 255, 0), 2, LINE_AA);
    			float line_k;
    			int a;
    			a = lines[i][2] - lines[i][0];
    			if (flag == 0)//横着
    			{
    				if (fabs((double)(lines[i][2] - lines[i][0])) > 0.0001)
    				{
    					line_k = (double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率
    				//	cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 120 && fabs(line_k)<0.6&&fabs(to_0_distance)>20)
    					{
    						lines_final.push_back(lines[i]);
    
    					}
    
    				}
    
    			}
    			else //竖着
    			{
    				if (fabs((double)(lines[i][2] - lines[i][0])) != 0)
    				{
    					line_k = (double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率
    				//	cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu >80 && fabs(to_0_distance)>30/* && (lines[i][1]<100 || lines[i][3]<100) */ && fabs(line_k)>1.7)
    					{
    						lines_final.push_back(lines[i]);
    
    					}
    					else if (fabs(line_k) > 30 && zhixian_changdu >60 && to_0_distance>110)
    					{
    						lines_final.push_back(lines[i]);
    
    					}
    				}
    				else
    				{
    					if (zhixian_changdu>60 && fabs(to_0_distance)>110 /*&& (lines[i][1] < 100 || lines[i][3] < 100)*/)
    					{
    						lines_final.push_back(lines[i]);
    					}
    				}
    
    			}
    		}
    		//namedWindow("直线未滤除前", 0);
    		//imshow("直线未滤除前", image_copy_C3);
    		//waitKey(1);
    		float A_Proportion, B_Proportion, C_Proportion;
    		//最终只能检测出两条直线
    		int zhixian_geshu = lines_final.size();
    		cout << "共有" << zhixian_geshu << "条直线进来了" << endl;
    		if (lines_final.size() >= 2)
    		{
    			//先求最终直线的方程的三个参数 A_top, B_bottom
    			fangcheng_PARAM_1 = get_lines_yibanshi_fangcheng(lines_final);
    			//将相同直线过滤为一条
    			if (lines_final.size() >= 3)
    			{
    				for (int j = 0; j <zhixian_geshu - 1; j++)
    				{
    					for (int k = j + 1; k <zhixian_geshu; k++)
    					{
    						A_Proportion = fangcheng_PARAM_1[j + 0] / fangcheng_PARAM_1[k + 0];
    						B_Proportion = fangcheng_PARAM_1[j + 1] / fangcheng_PARAM_1[k + 1];
    						C_Proportion = fangcheng_PARAM_1[j + 2] / fangcheng_PARAM_1[k + 2];
    
    						if ((A_Proportion > 0.75&&A_Proportion<1.3) && (B_Proportion>0.7 && B_Proportion<1.3) && (C_Proportion>0.7 && C_Proportion < 1.4))
    						{
    							cout << "第 " << j << "条直线" << "和" << k << "条直线相同" << endl;
    
    							fangcheng_PARAM_1[j + 0] = (fangcheng_PARAM_1[j + 0] + fangcheng_PARAM_1[k + 0]) / 2;
    							fangcheng_PARAM_1[j + 1] = (fangcheng_PARAM_1[j + 1] + fangcheng_PARAM_1[k + 0]) / 2;
    							fangcheng_PARAM_1[j + 2] = (fangcheng_PARAM_1[j + 2] + fangcheng_PARAM_1[k + 0]) / 2;
    
    						}
    					}
    				}
    			}
    
    			//【4】依次在图中绘制出每条线段
    			for (size_t i = 0; i < lines_final.size(); i++)
    			{
    				Vec4i l = lines_final[i];
    				line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 255, 0), 1, LINE_AA);
    			}
    
    
    	
    			//	滤波
    			Param_A1[3] = Param_A1[2];
    			Param_A1[2] = Param_A1[1];
    			Param_A1[1] = Param_A1[0];
    
    			Param_B1[3] = Param_B1[2];
    			Param_B1[2] = Param_B1[1];
    			Param_B1[1] = Param_B1[0];
    
    			Param_C1[3] = Param_C1[2];
    			Param_C1[2] = Param_C1[1];
    			Param_C1[1] = Param_C1[0];
    
    			Param_A1[0] = ((fabs(fangcheng_PARAM_1[0]) + fabs(fangcheng_PARAM_1[3])) / 2.0) * (fangcheng_PARAM_1[0] / fabs(fangcheng_PARAM_1[0]));
    			Param_B1[0] = ((fabs(fangcheng_PARAM_1[1]) + fabs(fangcheng_PARAM_1[4])) / 2.0) *(fangcheng_PARAM_1[1] / fabs(fangcheng_PARAM_1[1]));
    			Param_C1[0] = ((fabs(fangcheng_PARAM_1[2]) + fabs(fangcheng_PARAM_1[5])) / 2.0) *(fangcheng_PARAM_1[2] / fabs(fangcheng_PARAM_1[2]));
    
    
    			Param_A1[0] = 0.6* Param_A1[0] + 0.2* Param_A1[1] + 0.1* Param_A1[2] + 0.1* Param_A1[3];
    			Param_B1[0] = 0.6* Param_B1[0] + 0.2* Param_B1[1] + 0.1* Param_B1[2] + 0.1* Param_B1[3];
    			Param_C1[0] = 0.6* Param_C1[0] + 0.2* Param_C1[1] + 0.1* Param_C1[2] + 0.1* Param_C1[3];
    
    			float a1_bizhi;
    			if (Param_A1[0] != 0)
    			{
    				a1_bizhi = Param_A1[1] / Param_A1[0];
    			}
    			else
    			{
    				a1_bizhi = 1;
    			}
    
    			float a2_bizhi = Param_B1[1] / Param_B1[0];
    			float a3_bizhi = Param_C1[1] / Param_C1[0];
    
    			if ((a1_bizhi>0.9 || a1_bizhi<1.1) && (a2_bizhi>0.9 || a2_bizhi<1.1) && (a3_bizhi>0.9 || a3_bizhi<1.1))
    			{
    				lvbo++;
    
    			}
    			else /*if (lvbo>0)*/
    			{
    				lvbo=0;
    			}
    
    			if (lvbo>10)
    			{
    				fangcheng_PARAM_final.push_back(Param_A1[0]);
    				fangcheng_PARAM_final.push_back(Param_B1[0]);
    				fangcheng_PARAM_final.push_back(Param_C1[0]);
    				cout << "已拟合出直线方程" << endl;
    				draw_line_1(Param_A1[0], Param_B1[0], Param_C1[0], dstImage);
    				namedWindow("【检测直线效果图】", 0);//参数为零,则可以自由拖动
    				imshow("【检测直线效果图】", dstImage);
    				waitKey(1);
    
    				break;
    			}
    
    
    
    			/***** 7、输入A,B,C,画出线在dstImage*****/
    
    
    		}
    		else
    		{
    			//如果没有正确找到直线,就返回-1,函数外边再判断
    		//	cout << "没有正确的找到最终的两条直线" << endl;
    			continue;
    
    		}
    	}
    
    	return fangcheng_PARAM_final;
    }
    
    
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头找横竖两条直线交点
    *输入参数 : 图片
    *返 回 值 : 点向量,如果直线没有正确检测到,返回0,0点,方便后面判断
    *编写时间 : 2018.8.12
    *作    者 : 毛哥
    ********************************************************************************************/
    Point2f nihe_jiaodian()
    {
    	Point2f final_jiaodian;
    	vector <float>	fangcheng_PARAM_1, fangcheng_PARAM_2;
    	double Param_A1, Param_B1, Param_C1;//过道直线
    	double Param_A2, Param_B2, Param_C2;//挡板中轴线
    
    	fangcheng_PARAM_1 = nihe_zhixian_dantiao(0);
    
    	Param_A1 = fangcheng_PARAM_1[0];
    	Param_B1 = fangcheng_PARAM_1[1];
    	Param_C1 = fangcheng_PARAM_1[2];
    
    	fangcheng_PARAM_2 = nihe_zhixian_dantiao(1);
    	Param_A2 = fangcheng_PARAM_2[0];
    	Param_B2 = fangcheng_PARAM_2[1];
    	Param_C2 = fangcheng_PARAM_2[2];
    
    	final_jiaodian.y = (Param_A1*Param_C2 + Param_A2*Param_C1) / (Param_A2*Param_B1 - Param_A1*Param_B2);
    	final_jiaodian.x = (Param_C1 - Param_B1*final_jiaodian.y) / Param_A1;
    
    	//画出来
    	//circle(image, final_jiaodian, 2, Scalar(0, 0, 255), -1, 8);
    	return final_jiaodian;
    }
    
    
    
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头放置横着的挡板,此时顶部摄像头已经找到
    *输入参数 :第一个参数是 0为横着,1为竖着,第一个参数是 1为第一块挡板,2为第二块挡板,
    *返 回 值 : 单条直线的ABC值,
    *编写时间 : 2018.8.12
    *作    者 : 毛哥
    ********************************************************************************************/
    void Put_dangban(int hengshu, int yier)
    {
    	double Param_A1, Param_B1, Param_C1;//过道直线
    	double Param_A2, Param_B2, Param_C2;//挡板中轴线
    	//vector <float>	fangcheng_PARAM_1 = nihe_zhixian_dantiao(hengshu);
    	vector <float>	fangcheng_PARAM_1 = getVHlineParam(hengshu);
    
    	Param_A1 = fangcheng_PARAM_1[0];
    	Param_B1 = fangcheng_PARAM_1[1];
    	Param_C1 = fangcheng_PARAM_1[2];
    
    		if (yier == 1)
    		{
    			Send_to_K60(10, 0, 0);//将第一块挡板放在悬空位置(离地2cm)
    			Sleep(1200);
    
    		}
    		else
    		{
    			Send_to_K60(11, 0, 0);//将第二块挡板放在悬空位置(离地2cm)
    			Sleep(2000);
    		}
    
    
    
    
    
    	//实时找红色挡板
    	//printf("\n\n\t\t\t  实时找红色挡板开始\n");
    
    	int jiaodu_jishu = 0;
    	Mat frame_2;
    
    	while (1)
    	{
    
    		Mat srcImage0;
    
    
    		frame_2 = imgOriginal_up;
    
    		int width = frame_2.cols;
    		int height = frame_2.rows;
    
    		Mat image_cut;      //从img中按照rect进行切割,此时修改image_cut时image中对应部分也会修改,因此需要copy  
    		Mat image_copy_C3;   //clone函数创建新的图片 彩色
    
    		if (hengshu == 0)//横着
    		{
    			Rect rect(0, frame_2.rows*0.3, frame_2.cols, frame_2.rows*(0.95 - 0.3));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    		}
    		else //竖着
    		{
    			Rect rect(frame_2.cols*0.075, frame_2.rows*0.2, frame_2.cols*(0.875 - 0.075), frame_2.rows*(0.83 - 0.2));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    		}
    
    		int x, y;
    		double B = 0.0, G = 0.0, R = 0.0, H = 0.0, S = 0.0, V = 0.0;
    		int width1 = image_copy_C3.cols * 3;
    		int height1 = image_copy_C3.rows;
    		for (x = 0; x < height1; x++)
    		{
    			uchar* data = image_copy_C3.ptr<uchar>(x);//获取第i行的首地址
    			for (y = 0; y < width1; y += 3)
    			{
    				B = data[y];
    				G = data[y + 1];
    				R = data[y + 2];
    				RGB2HSV(R, G, B, H, S, V);
    				//红色范围,范围参考的网上。可以自己调
    			//	if ((H >= 286 && H <= 360 || H >= 0 && H <= 20) && (S >= 0 && S <= 360) && (V>0 && V < 360))
    				if ((H >= 270 && H <= 360 || H >= 0 && H <= 20) && (S >= 0 && S <= 360) && (V>0 && V < 360))
    					data[y] = data[y + 1] = data[y + 2] = 255;
    				else data[y] = data[y + 1] = data[y + 2] = 0;
    			}
    		}
    		Mat vec_rgb;
    		cvtColor(image_copy_C3, vec_rgb, CV_BGR2GRAY);//灰度化
    		//【3】srcImage取大于阈值119的那部分
    		vec_rgb = vec_rgb > 120;
    
    
    		//namedWindow("hsv空间图像", 0);
    		//imshow("hsv空间图像", vec_rgb);
    		//waitKey(1);
    
    		//Mat element = getStructuringElement(MORPH_ELLIPSE, Size(2 * 1 + 1, 2 * 1 + 1), Point(1, 1));
    		Mat element1 = getStructuringElement(MORPH_ELLIPSE, Size(2 * 3 + 1, 2 * 3 + 1), Point(3, 3));
    		//	Mat element1 = getStructuringElement(MORPH_RECT, Size(45, 45));
    		dilate(vec_rgb, vec_rgb, element1);//膨胀
    		/*namedWindow("膨胀", 0);
    		imshow("膨胀", vec_rgb);
    		waitKey(1);*/
    
    		erode(vec_rgb, vec_rgb, element1);//腐蚀
    		/*namedWindow("腐蚀", 0);
    		imshow("腐蚀", vec_rgb);
    		waitKey(1);*/
    
    		vector<vector<Point>>contours, max_contours; //轮廓
    		vector<Vec4i> hierarchy;//分层
    		Mat drawing_text = Mat::zeros(vec_rgb.size(), CV_8UC3);
    		findContours(vec_rgb, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    		if (contours.size() == 0)
    		{
    			cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    
    			continue;
    		}
    		//	cout << "第一次找轮廓结束,共找到轮廓:" << contours.size() << " 条" << endl;
    
    		vector<vector<Point>> hull(contours.size());//用于存放凸包
    		vector<float> length(contours.size());
    		vector<float> Area_contours(contours.size()), Area_hull(contours.size()), Rectangularity(contours.size()), circularity(contours.size());
    
    		vector< Point2f>  lunkuo_zhongxin_first;
    		lunkuo_zhongxin_first = find_lunkuo_zhongxin(contours);
    
    
    		int Xmin = (int)(vec_rgb.cols * 0);
    		int Xmax = (int)(vec_rgb.cols);
    		int Ymin = (int)(vec_rgb.rows * 0);
    		int Ymax = (int)(vec_rgb.rows);
    
    		for (int i = 0; i < contours.size(); i++)
    		{//历遍所有的轮廓
    
    			length[i] = arcLength(contours[i], true);
    
    			//cout << "轮廓长度为" << length[i] << endl;
    
    			if (length[i] >5 && lunkuo_zhongxin_first[i].x>Xmin&&lunkuo_zhongxin_first[i].x<Xmax&&lunkuo_zhongxin_first[i].y>Ymin&&lunkuo_zhongxin_first[i].y<Ymax)
    			{//通过长度匹配滤除小轮廓
    				convexHull(Mat(contours[i]), hull[i], false);//把凸包找出来
    				max_contours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    			}
    		}
    		if (max_contours.size() == 0)
    		{
    			cout << "警告:y有红色物体,但是可能没有红色挡板,或者红色挡板被遮挡严重" << endl;
    
    			continue;
    		}
    
    		//将线连接起来
    		vector<Point2f> zhongxin_zuobiao;
    		zhongxin_zuobiao = find_lunkuo_zhongxin(max_contours);
    		if (zhongxin_zuobiao.size() >= 2)
    		{
    			for (int i = 0; i < zhongxin_zuobiao.size() - 1; i++)
    			{
    				for (int j = i + 1; j < zhongxin_zuobiao.size(); j++)
    				{
    					float dis_juxin = getDistance_1(zhongxin_zuobiao[i], zhongxin_zuobiao[j]);
    					if (dis_juxin <65)
    					{
    						line(vec_rgb, zhongxin_zuobiao[i], zhongxin_zuobiao[j], Scalar(255), 4, LINE_AA);
    					}
    
    				}
    			}
    
    		}
    		//namedWindow("连接直线后", 0);
    		//imshow("连接直线后", vec_rgb);
    		//waitKey(1);
    
    
    		Mat vec_rgb1;
    
    		dilate(vec_rgb, vec_rgb1, element1);//膨胀
    		namedWindow("膨胀1", 0);
    		imshow("膨胀1", vec_rgb1);
    		waitKey(1);
    
    		erode(vec_rgb1, vec_rgb1, element1);//腐蚀
    		//namedWindow("腐蚀1", 0);
    		//imshow("腐蚀1", vec_rgb1);
    		//waitKey(1);
    
    		//第二次找轮廓
    		vector<vector<Point>>contours_1, RectContours; //轮廓
    		Mat drawing_1 = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));
    		Mat  	dstImage = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));   //clone函数创建新的图片 
    		findContours(vec_rgb, contours_1, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    
    		if (contours_1.size() == 0)
    		{
    			cout << "警告:没有在裁剪后的图片里找到轮廓(第二次找轮廓)" << endl;
    			continue;
    		}
    
    		//cout << "第二次找轮廓结束,共找到轮廓:" << contours_1.size() << " 条" << endl;
    		//cout << "第二次找轮廓结束" << endl;
    
    		vector< Point2f> lunkuo_zhongxin1, lunkuo_zhongxin_temp_first;
    
    		lunkuo_zhongxin_temp_first = find_lunkuo_zhongxin(contours_1);
    
    
    		if (contours_1.size() > 0)//如果没有找到轮廓退出
    		{
    			vector<vector<Point>> hull(contours_1.size());//用于存放凸包
    			vector<float> length(contours_1.size());
    
    			for (int i = 0; i < contours_1.size(); i++)
    			{//历遍所有的轮廓
    
    				length[i] = arcLength(contours_1[i], true);
    
    				if (length[i] >170 && lunkuo_zhongxin_temp_first[i].x>120 && lunkuo_zhongxin_temp_first[i].x<190 && lunkuo_zhongxin_temp_first[i].y>20 && lunkuo_zhongxin_temp_first[i].y<130)
    				{//通过长度匹配滤除小轮廓
    					convexHull(Mat(contours_1[i]), hull[i], false);//把凸包找出来
    
    					RectContours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    
    				}
    
    			}
    			//	cout << "已找到裁剪后的新凸包" << endl;
    
    			if (RectContours.size() == 0)
    			{
    
    				cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    				continue;
    			}
    
    
    
    			lunkuo_zhongxin1 = find_lunkuo_zhongxin(RectContours);
    
    
    
    			for (int i = 0; i < RectContours.size(); i++)
    			{
    				Scalar color = (255, 255, 255);//白色线画轮廓
    				drawContours(drawing_1, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    				drawContours(dstImage, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    
    
    				//画圆形
    			}
    
    			cvtColor(drawing_1, drawing_1, CV_BGR2GRAY);//灰度化
    			//【3】srcImage取大于阈值119的那部分
    			drawing_1 = drawing_1 > 20;
    		}
    
    
    
    
    		/*******  检测直线优化 开始 ****************************************************************/
    
    
    		Mat vec_rgb2;
    		vector<Vec4i> lines1, lines_final;//定义一个矢量结构lines用于存放得到的线段矢量集合
    
    		//	Canny(drawing_1, vec_rgb2, cannyThreshold, cannyThreshold * factor);
    		HoughLinesP(drawing_1, lines1, 1, CV_PI / 180, 35, 30, 30);
    
    		if (lines1.size() == 0)
    		{
    			cout << "红色挡板直线数量为零" << endl;
    			continue;
    		}
    
    		//【4】依次计算出直线长度
    		float  zhixian_changdu;
    		for (size_t i = 0; i < lines1.size(); i++)
    		{
    			Vec4i l = lines1[i];
    			zhixian_changdu = getDistance_1(Point(l[0], l[1]), Point(l[2], l[3]));
    
    			//cout << "\n红色挡板直线长度为" << zhixian_changdu << endl;
    
    			//画出原始直线
    			line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 255, 0), 1, LINE_AA);
    			float line_k = 0;
    			int a;
    			a = lines1[i][2] - lines1[i][0];
    
    			if (hengshu == 0)//横着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					//cout << "\n红色挡板直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 /*&& fabs(line_k)<1*/)
    					{
    						lines_final.push_back(lines1[i]);
    
    					}
    
    				}
    
    			}
    			else //竖着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.0001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					//cout << "\n红色挡板直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 && fabs(line_k)>0.7)
    					{
    						lines_final.push_back(lines1[i]);
    
    					}
    
    				}
    				else
    				{
    					if (zhixian_changdu>40)
    					{
    						lines_final.push_back(lines1[i]);
    					}
    				}
    			}
    		}
    
    		//namedWindow("挡板直线", 0);
    		//imshow("挡板直线", drawing_1);
    		//waitKey(2);
    
    
    		vector <float> fangcheng_PARAM_1;
    
    
    		//最终只能检测出两条直线
    		int zhixian_geshu = lines_final.size();
    		//	cout << "共有" << zhixian_geshu << "条直线进来了" << endl;
    		float line_k[4] = { 0 };
    		float line_b[4] = { 0 };
    		if (lines_final.size() == 0)
    		{
    			cout << "红色挡板最终直线数量为零" << endl;
    			continue;
    		}
    
    		if (lines_final.size() >= 1)
    		{
    			int a, b = 0;
    			for (size_t i = 0; i < lines_final.size(); i++)
    			{
    				float line_k_temp;
    
    				a = lines_final[i][2] - lines_final[i][0];
    				//	cout << "参数为: " << a << endl;
    				if (fabs((double)(lines_final[i][2] - lines_final[i][0])) > 0.001)
    				{
    					b++;
    					line_k_temp = (double)(lines_final[i][3] - lines_final[i][1]) / (double)(lines_final[i][2] - lines_final[i][0]); //求出直线的斜率
    					//	cout << "\n最终直线的斜率为\n" << line_k_temp << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    
    					line_k[0] = line_k_temp + line_k[0];
    
    				}
    				else
    				{
    					line_k[0] = 1000;
    					//曹,直线是个直的
    					//	line_k = 8000;
    
    
    				}
    
    
    			}
    			line_k[3] = line_k[2];
    			line_k[2] = line_k[1];
    			line_k[1] = line_k[0];
    
    			//line_b[3] = line_b[2];
    			//line_b[2] = line_b[1];
    			//line_b[1] = line_b[0];
    
    			line_k[0] = line_k[0] / b;
    			if (fabs(line_k[1] / line_k[0]) >10)//去抖动
    			{
    				line_k[0] = line_k[1];
    			}
    
    			line_k[0] = 0.6* line_k[0] + 0.2* line_k[1] + 0.1* line_k[2] + 0.1* line_k[3];
    
    			//line_b[0] = lunkuo_zhongxin1[0].y - lunkuo_zhongxin1[0].x*line_k[0];
    			//line_b[0] = 0.35* line_b[0] + 0.3* line_b[1] + 0.25* line_b[2] + 0.1* line_b[3];
    			//
    			if (fabs(line_k[0])<50)
    			{
    				Param_A2 = -line_k[0];
    				Param_B2 = 1;
    				Param_C2 = line_k[0] * lunkuo_zhongxin1[0].x - lunkuo_zhongxin1[0].y;
    			}
    			else
    			{
    				Param_A2 = -line_k[0];
    				Param_B2 = 0.0001;
    				Param_C2 = line_k[0] * lunkuo_zhongxin1[0].x - lunkuo_zhongxin1[0].y;
    			}
    
    
    
    			//Pt2.x = lunkuo_zhongxin1[0].x + 50;
    			//Pt2.y = 50 * line_k[0] + lunkuo_zhongxin1[0].y;
    			//	line(drawing_1, lunkuo_zhongxin1[0], Pt2, Scalar(0, 0, 255), 4, LINE_AA);
    			draw_line_1(Param_A2, Param_B2, Param_C2, dstImage);
    			draw_line_1(Param_A1, Param_B1, Param_C1, dstImage);
    
    		}
    
    
    		float theta, shuiping_diatance;
    
    
    		//fangcheng_PARAM_2 = get_lines_yibanshi_fangcheng_2((Point2f)lunkuo_zhongxin1[0], (Point2f)Pt2);
    
    		//Param_A2 = fangcheng_PARAM_2[0];
    		//Param_B2 = fangcheng_PARAM_2[1];
    		//Param_C2 = fangcheng_PARAM_2[2];
    
    
    		/***** 7、输入A,B,C,画出线在dstImage*****/
    
    		//最终求夹角(旋转误差)和平移误差
    		//两直线夹角,挡板相对于白色过道的夹角,因此白色过道直线斜率为第一个参数
    		theta = get_lines_yibanshi_arctan(Param_A1, Param_B1, Param_C1, Param_A2, Param_B2, Param_C2);
    
    		//点到直线距离
    		//P为线外一点,AB为线段两个端点
    		shuiping_diatance = getDist_P2L_zhengfu_2(lunkuo_zhongxin1[0], Param_A1, Param_B1, Param_C1,1);
    
    
    		cout << "\n最终结果\n挡板中轴线和白色过道中轴线夹角为: " << theta << " 度" << endl;
    		cout << "挡板中点与白色过道中轴线误差为: " << shuiping_diatance << endl;
    
    		//namedWindow("直线未滤除前", 0);
    		//imshow("直线未滤除前", image_copy_C3);
    		//waitKey(1);
    
    		namedWindow("【挡板夹角和位移示意图】", 0);//参数为零,则可以自由拖动
    		imshow("【挡板夹角和位移示意图】", dstImage);
    		waitKey(1);
    		float error1 = 0, error2 = 0;
    		error1 = theta*1.3;
    		error2 = shuiping_diatance*1.4;//目标行数,291
    		error1 = error1 > 127 ? 127 : error1;
    		error1 = error1 < -127 ? -127 : error1;
    		error2 = error2 > 127 ? 127 : error2;
    		error2 = error2 < -127 ? -127 : error2;
    
    		if (fabs(error1) < 1 && fabs(error2) <1.5)
    		{
    			Send_to_K60(12 , 0 , 0);
    			jiaodu_jishu++;
    			if (jiaodu_jishu>6)
    			{
    				Send_to_K60(13, 0, 0);//将挡板放下并归右边位置
    				Sleep(1000);
    				cout << "\n放置挡板成功" << endl;
    				break;
    			}
    		}
    		else
    		{
    			Send_to_K60(12, (int)error1, (int)error2);
    			if (jiaodu_jishu>0)
    			jiaodu_jishu--;
    		}
    	
    	}
    
    }
    
    
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头放置横着的挡板,此时顶部摄像头已经找到
    *输入参数 :第一个参数是 0为横着,1为竖着,第一个参数是 1为第一块挡板,2为第二块挡板,
    *返 回 值 : 单条直线的ABC值,
    *编写时间 : 2018.8.12
    *作    者 : 毛哥
    ********************************************************************************************/
    void Put_dangban_heng(int hengshu, int yier)
    {
    	double Param_A1, Param_B1, Param_C1;//过道直线
    	double Param_A2, Param_B2, Param_C2;//挡板中轴线
    	//vector <float>	fangcheng_PARAM_1 = nihe_zhixian_dantiao(hengshu);
    	vector <float>	fangcheng_PARAM_1 = getVHlineParam(hengshu);
    
    	Param_A1 = fangcheng_PARAM_1[0];
    	Param_B1 = fangcheng_PARAM_1[1];
    	Param_C1 = fangcheng_PARAM_1[2];
    
    
    
    	Send_to_K60(14, 0, 0);//将横挡板第一块挡板放在悬空位置(离地2cm)
    	Sleep(2000);
    
    
    	//实时找红色挡板
    	//printf("\n\n\t\t\t  实时找红色挡板开始\n");
    
    	int jiaodu_jishu = 0;
    	Mat frame_2;
    	while (1)
    	{
    
    		Mat srcImage0;
    
    
    		frame_2 = imgOriginal_up;
    		int width = frame_2.cols;
    		int height = frame_2.rows;
    
    	  Mat image_copy_C3;   //clone函数创建新的图片 彩色
    
    		if (hengshu == 0)//横着
    		{
    			Rect rect(0, frame_2.rows*0.3, frame_2.cols, frame_2.rows*(0.95 - 0.3));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    		}
    		else //竖着
    		{
    			Rect rect(frame_2.cols*0.075, frame_2.rows*0.2, frame_2.cols*(0.875 - 0.075), frame_2.rows*(0.83 - 0.2));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    
    		}
    
          	int x=0, y=0;
    		double B = 0.0, G = 0.0, R = 0.0, H = 0.0, S = 0.0, V = 0.0;
    		int width1 = image_copy_C3.cols * 3;
    		int height1 = image_copy_C3.rows;
    		for (x = 0; x < height1; x++)
    		{
    			uchar* data = image_copy_C3.ptr<uchar>(x);//获取第i行的首地址
    			for (y = 0; y < width1; y += 3)
    			{
    				B = data[y];
    				G = data[y + 1];
    				R = data[y + 2];
    				RGB2HSV(R, G, B, H, S, V);
    				//红色范围,范围参考的网上。可以自己调
    				if ((H >= 286 && H <= 360 || H >= 0 && H <= 20) && (S >= 0 && S <= 360) && (V>0 && V < 360))
    					data[y] = data[y + 1] = data[y + 2] = 255;
    				else data[y] = data[y + 1] = data[y + 2] = 0;
    			}
    		}
    		Mat vec_rgb;
    		cvtColor(image_copy_C3, vec_rgb, CV_BGR2GRAY);//灰度化
    		//【3】srcImage取大于阈值119的那部分
    		vec_rgb = vec_rgb > 120;
    
    		Mat element1 = getStructuringElement(MORPH_ELLIPSE, Size(2 * 3 + 1, 2 * 3 + 1), Point(3, 3));
    		//	Mat element1 = getStructuringElement(MORPH_RECT, Size(45, 45));
    		dilate(vec_rgb, vec_rgb, element1);//膨胀
    	
    		/*namedWindow("膨胀", 0);
    		imshow("膨胀", vec_rgb);
    		waitKey(1);*/
    
    		erode(vec_rgb, vec_rgb, element1);//腐蚀
    		/*namedWindow("腐蚀", 0);
    		imshow("腐蚀", vec_rgb);
    		waitKey(1);*/
    
    		vector<vector<Point>>contours, max_contours; //轮廓
    		vector<Vec4i> hierarchy;//分层
    		Mat drawing_text = Mat::zeros(vec_rgb.size(), CV_8UC3);
    		findContours(vec_rgb, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    		if (contours.size() == 0)
    		{
    			cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    
    			continue;
    		}
    		//	cout << "第一次找轮廓结束,共找到轮廓:" << contours.size() << " 条" << endl;
    
    		vector<vector<Point>> hull(contours.size());//用于存放凸包
    		vector<float> length(contours.size());
    		vector<float> Area_contours(contours.size()), Area_hull(contours.size()), Rectangularity(contours.size()), circularity(contours.size());
    
    		vector< Point2f>  lunkuo_zhongxin_first;
    		lunkuo_zhongxin_first = find_lunkuo_zhongxin(contours);
    
    
    		int Xmin = (int)(vec_rgb.cols * 0);
    		int Xmax = (int)(vec_rgb.cols);
    		int Ymin = (int)(vec_rgb.rows * 0);
    		int Ymax = (int)(vec_rgb.rows);
    
    		for (int i = 0; i < contours.size(); i++)
    		{//历遍所有的轮廓
    
    			length[i] = arcLength(contours[i], true);
    
    			//cout << "轮廓长度为" << length[i] << endl;
    
    			if (length[i] >5 && lunkuo_zhongxin_first[i].x>Xmin&&lunkuo_zhongxin_first[i].x<Xmax&&lunkuo_zhongxin_first[i].y>Ymin&&lunkuo_zhongxin_first[i].y<Ymax)
    			{//通过长度匹配滤除小轮廓
    				convexHull(Mat(contours[i]), hull[i], false);//把凸包找出来
    				max_contours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    			}
    		}
    		if (max_contours.size() == 0)
    		{
    			cout << "警告:y有红色物体,但是可能没有红色挡板,或者红色挡板被遮挡严重" << endl;
    
    			continue;
    		}
    
    		//将线连接起来
    		vector<Point2f> zhongxin_zuobiao;
    		zhongxin_zuobiao = find_lunkuo_zhongxin(max_contours);
    		if (zhongxin_zuobiao.size() >= 2)
    		{
    			for (int i = 0; i < zhongxin_zuobiao.size() - 1; i++)
    			{
    				for (int j = i + 1; j < zhongxin_zuobiao.size(); j++)
    				{
    					float dis_juxin = getDistance_1(zhongxin_zuobiao[i], zhongxin_zuobiao[j]);
    					if (dis_juxin <65)
    					{
    						line(vec_rgb, zhongxin_zuobiao[i], zhongxin_zuobiao[j], Scalar(255), 4, LINE_AA);
    					}
    
    				}
    			}
    
    		}
    		//namedWindow("连接直线后", 0);
    		//imshow("连接直线后", vec_rgb);
    		//waitKey(1);
    
    
    		Mat vec_rgb1;
    
    		dilate(vec_rgb, vec_rgb1, element1);//膨胀
    		namedWindow("膨胀1", 0);
    		imshow("膨胀1", vec_rgb1);
    		waitKey(1);
    
    		erode(vec_rgb1, vec_rgb1, element1);//腐蚀
    		//namedWindow("腐蚀1", 0);
    		//imshow("腐蚀1", vec_rgb1);
    		//waitKey(1);
    
    		//第二次找轮廓
    		vector<vector<Point>>contours_1, RectContours; //轮廓
    		Mat drawing_1 = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));
    		Mat  	dstImage = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));   //clone函数创建新的图片 
    		findContours(vec_rgb, contours_1, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    
    		if (contours_1.size() == 0)
    		{
    			cout << "警告:没有在裁剪后的图片里找到轮廓(第二次找轮廓)" << endl;
    			continue;
    		}
    
    		//cout << "第二次找轮廓结束,共找到轮廓:" << contours_1.size() << " 条" << endl;
    		//cout << "第二次找轮廓结束" << endl;
    
    		vector< Point2f> lunkuo_zhongxin1, lunkuo_zhongxin_temp_first;
    
    		lunkuo_zhongxin_temp_first = find_lunkuo_zhongxin(contours_1);
    
    
    
    		if (contours_1.size() > 0)//如果没有找到轮廓退出
    		{
    			vector<vector<Point>> hull(contours_1.size());//用于存放凸包
    			vector<float> length(contours_1.size());
    
    			for (int i = 0; i < contours_1.size(); i++)
    			{//历遍所有的轮廓
    
    				length[i] = arcLength(contours_1[i], true);
    
    				if (length[i] >170 && lunkuo_zhongxin_temp_first[i].x>0 && lunkuo_zhongxin_temp_first[i].x<140)
    				{//通过长度匹配滤除小轮廓
    					convexHull(Mat(contours_1[i]), hull[i], false);//把凸包找出来
    
    					RectContours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    
    				}
    
    			}
    			//	cout << "已找到裁剪后的新凸包" << endl;
    
    			if (RectContours.size() == 0)
    			{
    
    				cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    				continue;
    			}
    
    
    			lunkuo_zhongxin1 = find_lunkuo_zhongxin(RectContours);
    
    			if (lunkuo_zhongxin1.size() != 1)
    			{
    
    				cout << "警告:有两个红色挡板" << endl;
    				continue;
    			}
    
    
    			for (int i = 0; i < RectContours.size(); i++)
    			{
    				Scalar color = (255, 255, 255);//白色线画轮廓
    				drawContours(drawing_1, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    				drawContours(dstImage, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    
    
    				//画圆形
    			}
    
    			cvtColor(drawing_1, drawing_1, CV_BGR2GRAY);//灰度化
    			//【3】srcImage取大于阈值119的那部分
    			drawing_1 = drawing_1 > 20;
    		}
    
    
    
    
    		/*******  检测直线优化 开始 ****************************************************************/
    
    
    		Mat vec_rgb2;
    		vector<Vec4i> lines1, lines_final;//定义一个矢量结构lines用于存放得到的线段矢量集合
    
    		//	Canny(drawing_1, vec_rgb2, cannyThreshold, cannyThreshold * factor);
    		HoughLinesP(drawing_1, lines1, 1, CV_PI / 180, 35, 30, 30);
    
    		if (lines1.size() == 0)
    		{
    			cout << "直线数量为零" << endl;
    			continue;
    		}
    
    		//【4】依次计算出直线长度
    		float  zhixian_changdu;
    		for (size_t i = 0; i < lines1.size(); i++)
    		{
    			Vec4i l = lines1[i];
    			zhixian_changdu = getDistance_1(Point(l[0], l[1]), Point(l[2], l[3]));
    
    			//cout << "\n直线长度为" << zhixian_changdu << endl;
    
    			//画出原始直线
    			line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 255, 0), 1, LINE_AA);
    			float line_k = 0;
    			int a;
    			a = lines1[i][2] - lines1[i][0];
    			if (hengshu == 0)//横着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					//cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 /*&& fabs(line_k)<1*/)
    					{
    						lines_final.push_back(lines1[i]);
    					}
    				}
    			}
    			else //竖着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 && fabs(line_k)>0.7)
    					{
    						lines_final.push_back(lines1[i]);
    					}
    				}
    				else
    				{
    					if (zhixian_changdu>40)
    					{
    						lines_final.push_back(lines1[i]);
    					}
    				}
    			}
    		}
    		vector <float> fangcheng_PARAM_1;
    		//最终只能检测出两条直线
    		int zhixian_geshu = lines_final.size();
    		float line_k[4] = { 0 };
    		float line_b[4] = { 0 };
    		if (lines_final.size() == 0)
    		{
    			cout << "最终直线数量为零" << endl;
    			continue;
    		}
    
    		if (lines_final.size() >= 1)
    		{
    			int a, b = 0;
    			for (size_t i = 0; i < lines_final.size(); i++)
    			{
    				float line_k_temp;
    
    				a = lines_final[i][2] - lines_final[i][0];
    			
    				if (fabs((double)(lines_final[i][2] - lines_final[i][0])) > 0.001)
    				{
    					b++;
    					line_k_temp = (double)(lines_final[i][3] - lines_final[i][1]) / (double)(lines_final[i][2] - lines_final[i][0]); //求出直线的斜率
    					//	cout << "\n最终直线的斜率为\n" << line_k_temp << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					line_k[0] = line_k_temp + line_k[0];
    
    				}
    				else
    				{
    					line_k[0] = 1000;
    					//曹,直线是个直的
    					//	line_k = 8000;
    				}
    			}
    			line_k[3] = line_k[2];
    			line_k[2] = line_k[1];
    			line_k[1] = line_k[0];
    
    			line_k[0] = line_k[0] / (float)b;
    			if (fabs(line_k[1] / line_k[0]) >8)//去抖动
    			{
    				line_k[0] = line_k[1];
    			}
    
    			line_k[0] = 0.6* line_k[0] + 0.2* line_k[1] + 0.1* line_k[2] + 0.1* line_k[3];
    			Param_A2 = -line_k[0];
    			Param_B2 = 1;
    			Param_C2 = line_k[0] * lunkuo_zhongxin1[0].x - lunkuo_zhongxin1[0].y;	
    			draw_line_1(Param_A2, Param_B2, Param_C2, dstImage);
    			draw_line_1(Param_A1, Param_B1, Param_C1, dstImage);
    
    		}
    
    
    		float theta=0.0, shuiping_diatance=0.0;
    
    		/***** 7、输入A,B,C,画出线在dstImage******/
    		//最终求夹角(旋转误差)和平移误差
    		//两直线夹角,挡板相对于白色过道的夹角,因此白色过道直线斜率为第一个参数
    		theta = get_lines_yibanshi_arctan(Param_A1, Param_B1, Param_C1, Param_A2, Param_B2, Param_C2);
    
    		//点到直线距离
    		//P为线外一点,AB为线段两个端点
    		shuiping_diatance = getDist_P2L_zhengfu_2(lunkuo_zhongxin1[0], Param_A1, Param_B1, Param_C1,0);
    
    
    		cout << "\n最终结果\n挡板中轴线和白色过道中轴线夹角为: " << theta << " 度" << endl;
    		cout << "挡板中点与白色过道中轴线误差为: " << -shuiping_diatance << endl;
    
    		namedWindow("【挡板夹角和位移示意图】", 0);//参数为零,则可以自由拖动
    		imshow("【挡板夹角和位移示意图】", dstImage);
    		waitKey(1);
    		float error1, error2;
    		error1 = theta;
    		error2 =-shuiping_diatance*1.5;//目标行数,291
    	
    		error1 = error1 > 127 ? 127 : error1;
    		error1 = error1 < -127 ? -127 : error1;
    		error2 = error2 > 127 ? 127 : error2;
    		error2 = error2 < -127 ? -127 : error2;
    
    
    
    		if (fabs(error1) < 1.1 && fabs(error2) <1.5)
    		{
    			jiaodu_jishu++;
    			if (jiaodu_jishu>5)
    			{
    				Send_to_K60(13, 0, 0);//将挡板放下并归右边位置
    				Sleep(2000);
    				cout << "\n放置第一块挡板成功" << endl;
    				break;
    			}
    
    		}
    		else if (jiaodu_jishu>0)
    		{
    			jiaodu_jishu--;
    		}
    		
    		Send_to_K60(12, (int)error1, (int)error2);
    	}
    
    	Sleep(1000);
    
    	Send_to_K60(15, 0, 0);//将将横挡板第二块挡板放在悬空位置(离地2cm)
    	Sleep(2000);
    	Sleep(1000);
    	jiaodu_jishu = 0;
    	while (1)
    	{
    
    		Mat srcImage0;
    
    
    		Mat	frame_2 = imgOriginal_up;
    		int width = frame_2.cols;
    		int height = frame_2.rows;
    
    		Mat image_cut;      //从img中按照rect进行切割,此时修改image_cut时image中对应部分也会修改,因此需要copy  
    		Mat image_copy_C3;   //clone函数创建新的图片 彩色
    
    		if (hengshu == 0)//横着
    		{
    			Rect rect(0, frame_2.rows*0.3, frame_2.cols, frame_2.rows*(0.95 - 0.3));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    		}
    		else //竖着
    		{
    			Rect rect(frame_2.cols*0.075, frame_2.rows*0.2, frame_2.cols*(0.875 - 0.075), frame_2.rows*(0.83 - 0.2));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			Mat	image_cut = Mat(frame_2, rect);
    			image_copy_C3 = image_cut.clone();   //clone函数创建新的图片 
    
    		}
    		int x, y;
    		double B = 0.0, G = 0.0, R = 0.0, H = 0.0, S = 0.0, V = 0.0;
    		int width1 = image_copy_C3.cols * 3;
    		int height1 = image_copy_C3.rows;
    		for (x = 0; x < height1; x++)
    		{
    			uchar* data = image_copy_C3.ptr<uchar>(x);//获取第i行的首地址
    			for (y = 0; y < width1; y += 3)
    			{
    				B = data[y];
    				G = data[y + 1];
    				R = data[y + 2];
    				RGB2HSV(R, G, B, H, S, V);
    				//红色范围,范围参考的网上。可以自己调
    				if ((H >= 286 && H <= 360 || H >= 0 && H <= 20) && (S >= 0 && S <= 360) && (V>0 && V < 360))
    					data[y] = data[y + 1] = data[y + 2] = 255;
    				else data[y] = data[y + 1] = data[y + 2] = 0;
    			}
    		}
    		Mat vec_rgb;
    		cvtColor(image_copy_C3, vec_rgb, CV_BGR2GRAY);//灰度化
    		//【3】srcImage取大于阈值119的那部分
    		vec_rgb = vec_rgb > 120;
    
    
    		//Mat element = getStructuringElement(MORPH_ELLIPSE, Size(2 * 1 + 1, 2 * 1 + 1), Point(1, 1));
    		Mat element1 = getStructuringElement(MORPH_ELLIPSE, Size(2 * 3 + 1, 2 * 3 + 1), Point(3, 3));
    		//	Mat element1 = getStructuringElement(MORPH_RECT, Size(45, 45));
    		dilate(vec_rgb, vec_rgb, element1);//膨胀
    		/*namedWindow("膨胀", 0);
    		imshow("膨胀", vec_rgb);
    		waitKey(1);*/
    
    		erode(vec_rgb, vec_rgb, element1);//腐蚀
    		/*namedWindow("腐蚀", 0);
    		imshow("腐蚀", vec_rgb);
    		waitKey(1);*/
    
    		vector<vector<Point>>contours, max_contours; //轮廓
    		vector<Vec4i> hierarchy;//分层
    		Mat drawing_text = Mat::zeros(vec_rgb.size(), CV_8UC3);
    		findContours(vec_rgb, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    		if (contours.size() == 0)
    		{
    			cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    
    			continue;
    		}
    		vector<vector<Point>> hull(contours.size());//用于存放凸包
    		vector<float> length(contours.size());
    		vector<float> Area_contours(contours.size()), Area_hull(contours.size()), Rectangularity(contours.size()), circularity(contours.size());
    
    //		vector< Point2f>  lunkuo_zhongxin_first;
    	//	lunkuo_zhongxin_first = find_lunkuo_zhongxin(contours);
    
    
    		//int Xmin = (int)(vec_rgb.cols * 0);
    		//int Xmax = (int)(vec_rgb.cols);
    		//int Ymin = (int)(vec_rgb.rows * 0);
    		//int Ymax = (int)(vec_rgb.rows);
    
    		for (int i = 0; i < contours.size(); i++)
    		{//历遍所有的轮廓
    
    			length[i] = arcLength(contours[i], true);
    
    			//cout << "轮廓长度为" << length[i] << endl;
    
    			if (length[i] >5 /*&& lunkuo_zhongxin_first[i].x>Xmin&&lunkuo_zhongxin_first[i].x<Xmax&&lunkuo_zhongxin_first[i].y>Ymin&&lunkuo_zhongxin_first[i].y<Ymax*/)
    			{//通过长度匹配滤除小轮廓
    				convexHull(Mat(contours[i]), hull[i], false);//把凸包找出来			
    				max_contours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    			}
    		}
    		if (max_contours.size() == 0)
    		{
    			cout << "警告:y有红色物体,但是可能没有红色挡板,或者红色挡板被遮挡严重" << endl;
    
    			continue;
    		}
    
    		//将线连接起来
    		vector<Point2f> zhongxin_zuobiao;
    		zhongxin_zuobiao = find_lunkuo_zhongxin(max_contours);
    		if (zhongxin_zuobiao.size() >= 2)
    		{
    			for (int i = 0; i < zhongxin_zuobiao.size() - 1; i++)
    			{
    				for (int j = i + 1; j < zhongxin_zuobiao.size(); j++)
    				{
    					float dis_juxin = getDistance_1(zhongxin_zuobiao[i], zhongxin_zuobiao[j]);
    					if (dis_juxin < 65)
    					{
    						line(vec_rgb, zhongxin_zuobiao[i], zhongxin_zuobiao[j], Scalar(255), 4, LINE_AA);
    					}
    
    				}
    			}
    
    		}
    		//namedWindow("连接直线后", 0);
    		//imshow("连接直线后", vec_rgb);
    		//waitKey(1);
    
    
    		Mat vec_rgb1;
    
    		dilate(vec_rgb, vec_rgb1, element1);//膨胀
    		namedWindow("膨胀1", 0);
    		imshow("膨胀1", vec_rgb1);
    		waitKey(1);
    
    		erode(vec_rgb1, vec_rgb1, element1);//腐蚀
    		//namedWindow("腐蚀1", 0);
    		//imshow("腐蚀1", vec_rgb1);
    		//waitKey(1);
    
    		//第二次找轮廓
    		vector<vector<Point>>contours_1, RectContours; //轮廓
    		Mat drawing_1 = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));
    		Mat  	dstImage = Mat(vec_rgb.size(), CV_8UC3, Scalar(0, 0, 0));   //clone函数创建新的图片 
    		findContours(vec_rgb, contours_1, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);//找轮廓
    
    		if (contours_1.size() == 0)
    		{
    			cout << "警告:没有在裁剪后的图片里找到轮廓(第二次找轮廓)" << endl;
    			continue;
    		}
    
    		vector< Point2f> lunkuo_zhongxin_temp, lunkuo_zhongxin1;
    		lunkuo_zhongxin_temp = find_lunkuo_zhongxin(contours_1);
    		if (contours_1.size() > 0)//如果没有找到轮廓退出
    		{
    			vector<vector<Point>> hull(contours_1.size());//用于存放凸包
    			vector<float> length(contours_1.size());
    
    			for (int i = 0; i < contours_1.size(); i++)
    			{//历遍所有的轮廓
    
    				length[i] = arcLength(contours_1[i], true);
    
    				if (length[i] >170 && lunkuo_zhongxin_temp[i].x>190 && lunkuo_zhongxin_temp[i].x<305)
    				{//通过长度匹配滤除小轮廓
    					convexHull(Mat(contours_1[i]), hull[i], false);//把凸包找出来
    					RectContours.push_back(hull[i]);//把提取出来的方框导入到新的轮廓组
    				}
    			}
    			//	cout << "已找到裁剪后的新凸包" << endl;
    
    			if (RectContours.size() == 0)
    			{
    				cout << "警告:没有红色挡板(第一次找轮廓)" << endl;
    				continue;
    			}
    
    			lunkuo_zhongxin1 = find_lunkuo_zhongxin(RectContours);
    			if (lunkuo_zhongxin1.size() != 1)
    			{
    				cout << "警告:有两个红色挡板" << endl;
    				continue;
    			}
    
    			for (int i = 0; i < RectContours.size(); i++)
    			{
    				Scalar color = (255, 255, 255);//白色线画轮廓
    				drawContours(drawing_1, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    				drawContours(dstImage, RectContours, i, color, 1, 8, hierarchy, 0, Point());//根据轮廓点集contours_poly和轮廓结构hierarchy画出轮廓
    				//画圆形
    			}
    
    			cvtColor(drawing_1, drawing_1, CV_BGR2GRAY);//灰度化
    			//【3】srcImage取大于阈值119的那部分
    			drawing_1 = drawing_1 > 20;
    		}
    
    		/*******  检测直线优化 开始 ****************************************************************/
    
    		Mat vec_rgb2;
    		vector<Vec4i> lines1, lines_final;//定义一个矢量结构lines用于存放得到的线段矢量集合
    
    		//	Canny(drawing_1, vec_rgb2, cannyThreshold, cannyThreshold * factor);
    		HoughLinesP(drawing_1, lines1, 1, CV_PI / 180, 35, 30, 30);
    
    		if (lines1.size() == 0)
    		{
    			cout << "直线数量为零" << endl;
    			continue;
    		}
    
    		//	cout << "canny边缘检测阈值为:" << cannyThreshold << endl;
    
    		/*******  检测直线优化 结束 ****************************************************************/
    
    		//	cout << "\n共检测到原始  直线" << lines1.size() << "条" << endl;
    
    
    		//【4】依次计算出直线长度
    		float  zhixian_changdu;
    		for (size_t i = 0; i < lines1.size(); i++)
    		{
    			Vec4i l = lines1[i];
    			zhixian_changdu = getDistance_1(Point(l[0], l[1]), Point(l[2], l[3]));
    
    			//cout << "\n直线长度为" << zhixian_changdu << endl;
    
    			//画出原始直线
    			line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 255, 0), 1, LINE_AA);
    			float line_k = 0;
    			int a;
    			a = lines1[i][2] - lines1[i][0];
    			//	cout << "参数为: " << a << endl;
    
    
    
    
    			if (hengshu == 0)//横着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					//cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 /*&& fabs(line_k)<1*/)
    					{
    						lines_final.push_back(lines1[i]);
    
    					}
    
    				}
    
    			}
    			else //竖着
    			{
    				if (fabs((double)(lines1[i][2] - lines1[i][0])) > 0.001)
    				{
    					line_k = (double)(lines1[i][3] - lines1[i][1]) / (double)(lines1[i][2] - lines1[i][0]); //求出直线的斜率
    					//cout << "\n直线的斜率为\n" << line_k << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					if (zhixian_changdu > 40 && fabs(line_k)>0.7)
    					{
    						lines_final.push_back(lines1[i]);
    
    					}
    
    				}
    				else
    				{
    					if (zhixian_changdu>40)
    					{
    						lines_final.push_back(lines1[i]);
    					}
    				}
    			}
    		}
    
    		//namedWindow("挡板直线", 0);
    		//imshow("挡板直线", drawing_1);
    		//waitKey(2);
    
    
    		vector <float> fangcheng_PARAM_1;
    
    
    		//最终只能检测出两条直线
    		int zhixian_geshu = lines_final.size();
    		//	cout << "共有" << zhixian_geshu << "条直线进来了" << endl;
    		float line_k[4] = { 0 };
    		float line_b[4] = { 0 };
    		if (lines_final.size() == 0)
    		{
    			cout << "最终直线数量为零" << endl;
    			continue;
    		}
    
    		if (lines_final.size() >= 2)
    		{
    			int a, b = 0;
    			for (size_t i = 0; i < lines_final.size(); i++)
    			{
    				float line_k_temp;
    
    				//a = lines_final[i][2] - lines_final[i][0];
    				//	cout << "参数为: " << a << endl;
    				if (fabs((double)(lines_final[i][2] - lines_final[i][0])) > 0.001)
    				{
    					b++;
    					line_k_temp = (double)(lines_final[i][3] - lines_final[i][1]) / (double)(lines_final[i][2] - lines_final[i][0]); //求出直线的斜率
    					//	cout << "\n最终直线的斜率为\n" << line_k_temp << endl;
    					//斜率k以及b很接近的保留一条,两根直线应该是距离恒定的(一个比较稳定的范围)
    					//通过直线长度滤除,只剩下两条最长的,斜率要大于45度的直线
    					line_k[0] = line_k_temp + line_k[0];
    
    				}
    				else
    				{
    					line_k[0] = 70;
    					//曹,直线是个直的
    					//	line_k = 8000;
    				}
    
    
    			}
    			line_k[3] = line_k[2];
    			line_k[2] = line_k[1];
    			line_k[1] = line_k[0];
    
    			line_k[0] = line_k[0] / b;
    			line_k[0] = 0.6* line_k[0] + 0.2* line_k[1] + 0.1* line_k[2] + 0.1* line_k[3];
    
    			Param_A2 = -line_k[0];
    			Param_B2 = 1;
    			Param_C2 = line_k[0] * lunkuo_zhongxin1[0].x - lunkuo_zhongxin1[0].y;
    
    			draw_line_1(Param_A2, Param_B2, Param_C2, dstImage);
    			draw_line_1(Param_A1, Param_B1, Param_C1, dstImage);
    
    		}
    
    
    		float theta, shuiping_diatance;
    
    
    		/***** 7、输入A,B,C,画出线在dstImage*****/
    
    		//最终求夹角(旋转误差)和平移误差
    		//两直线夹角,挡板相对于白色过道的夹角,因此白色过道直线斜率为第一个参数
    		theta = get_lines_yibanshi_arctan(Param_A1, Param_B1, Param_C1, Param_A2, Param_B2, Param_C2);
    
    		//点到直线距离
    		//P为线外一点,AB为线段两个端点
    		shuiping_diatance = getDist_P2L_zhengfu_2(lunkuo_zhongxin1[0], Param_A1, Param_B1, Param_C1,0);
    
    
    		cout << "\n最终结果\n挡板中轴线和白色过道中轴线夹角为: " << theta << " 度" << endl;
    		cout << "挡板中点与白色过道中轴线误差为: " << shuiping_diatance << endl;
    
    		//namedWindow("直线未滤除前", 0);
    		//imshow("直线未滤除前", image_copy_C3);
    		//waitKey(1);
    
    		namedWindow("【挡板夹角和位移示意图】", 0);//参数为零,则可以自由拖动
    		imshow("【挡板夹角和位移示意图】", dstImage);
    
    		//waitKey(1);
    		int error1 = 0, error2 = 0;
    		error1 = theta;
    
    		error2 = shuiping_diatance;//目标行数,291
    
    		//	error2 = 0;//目标行数,291
    		error1 = error1 > 127 ? 127 : error1;
    		error1 = error1 < -127 ? -127 : error1;
    		error2 = error2 > 127 ? 127 : error2;
    		error2 = error2 < -127 ? -127 : error2;
    
    
    		Send_to_K60(12, error1, error2);
    
    		if (fabs((double)error1) < 1 && fabs((double)error2) <1.5)
    		{
    			jiaodu_jishu++;
    			if (jiaodu_jishu>5)
    			{
    				Send_to_K60(13, 0, 0);//将挡板放下并归右边位置		
    				cout << "\n放置挡板成功" << endl;
    				Sleep(1000);
    				break;
    			}
    		}
    		else if (jiaodu_jishu>0)
    		{
    			jiaodu_jishu--;
    		}
    	}
    
    }
    
    
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头放置横着或者竖着的挡板前的定位
    *输入参数 : 第一个参数为目标数字第二个参数是 0为横着,1为竖着,第三个参数是 1为第一块挡板,2为第二块挡板,
    *返 回 值 : 单条直线的ABC值,如果没有正确找到直线,就返回-1,函数外边再判断
    *编写时间 : 2018.8.13
    *作    者 : 毛哥(参考叶少及姚总)
    ********************************************************************************************/
    void Dangban_dingwei(int num_obj, int mode, int cishu)
    {
    	//if (num_obj<10)
    	//{
    	//	Dangban_DingWei_Single_Num(num_obj, mode, cishu);
    	//}
    	//else
    	//{
    	//	Dangban_DingWei_Double_Num(num_obj, mode, cishu);
    	//}
    
    }
    /*******************************************************************************************
    *函数功能 : 输入二值化图像,提取横竖线并拟合求出交点
    *输入参数 : 二值化图像
    *返 回 值 : 交点坐标
    *编写时间 : 2018.8.15
    *作    者 : Biger姚
    ********************************************************************************************/
    Point findCrossPoint(Mat img)
    {
    	Point CrossPoint;
    	vector<vector<Point>> contours;
    	vector<Vec4i>hierarchy;
    	Mat midImage, dstImage;
    	dstImage = findMaxContouns(img);
    	cvtColor(dstImage, midImage, COLOR_BGR2GRAY);
    	midImage = midImage > 2;
    	vector<Vec2f> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    	HoughLines(midImage, lines, 1, CV_PI / 180, 50);
    	if (lines.size() > 0)
    	{//横竖线分类 求出两条横竖线后求交点
    		vector<Vec2f> lines_h;//定义一个矢量结构lines用于存放得到的线段矢量集合
    		vector<Vec2f> lines_v;//定义一个矢量结构lines用于存放得到的线段矢量集合
    		float rho_min_h = 10000, rho_max_h = -10000, rho_min_v = 10000, rho_max_v = -10000;
    		float theta_sum_v = 0, theta_sum_h = 0;
    		float theta;
    		float rho_h, theta_h, rho_v, theta_v;
    		Point pt1, pt2, pt3, pt4;
    		double a, b;
    		double x0, y0;
    		//#pragma omp parallel for
    		for (int i = 0; i < lines.size(); i++)
    		{
    			theta = lines[i][1];
    			if (theta >= 2.355 || theta <= 0.785)lines_v.push_back(lines[i]);//shu
    			else if (theta >= 0.785&&theta <= 2.355)lines_h.push_back(lines[i]);//heng
    		}
    		/*heng*/
    		for (size_t i = 0; i < lines_h.size(); i++)
    		{
    			rho_h = lines_h[i][0], theta_h = lines_h[i][1];
    			theta_sum_h += theta_h;
    			/*a = cos(theta_h), b = sin(theta_h);
    			x0 = a*rho_h, y0 = b*rho_h;
    			pt1.x = cvRound(x0 + 1000 * (-b));
    			pt1.y = cvRound(y0 + 1000 * (a));
    			pt2.x = cvRound(x0 - 1000 * (-b));
    			pt2.y = cvRound(y0 - 1000 * (a));
    			line(src, pt1, pt2, Scalar(0, 0, 0), 2, LINE_AA);*/
    			if (rho_h >= rho_max_h)rho_max_h = rho_h;
    			if (rho_h <= rho_min_h)rho_min_h = rho_h;
    		}
    		rho_h = (rho_max_h + rho_min_h) / 2;
    		theta_h = theta_sum_h / lines_h.size();
    		a = cos(theta_h), b = sin(theta_h);
    		x0 = a*rho_h, y0 = b*rho_h;
    		pt1.x = cvRound(x0 + 1000 * (-b));
    		pt1.y = cvRound(y0 + 1000 * (a));
    		pt2.x = cvRound(x0 - 1000 * (-b));
    		pt2.y = cvRound(y0 - 1000 * (a));
    		//line(src, pt1, pt2, Scalar(0, 0, 255), 2, LINE_AA);
    
    		//shu
    		for (size_t i = 0; i < lines_v.size(); i++)
    		{
    			rho_v = lines_v[i][0], theta_v = lines_v[i][1];
    			if (theta_v<0.6)
    			{
    				theta_sum_v += theta_v;
    				theta_sum_v += CV_PI;
    			}
    			else  theta_sum_v += theta_v;
    			/*a = cos(theta_v), b = sin(theta_v);
    			x0 = a*rho_v, y0 = b*rho_v;
    			pt3.x = cvRound(x0 + 1000 * (-b));
    			pt3.y = cvRound(y0 + 1000 * (a));
    			pt4.x = cvRound(x0 - 1000 * (-b));
    			pt4.y = cvRound(y0 - 1000 * (a));
    			line(src, pt3, pt4, Scalar(0, 0, 0), 2, LINE_AA);*/
    			if (rho_v < 0)rho_v = -rho_v;
    			if (rho_v >= rho_max_v)rho_max_v = rho_v;
    			if (rho_v <= rho_min_v)rho_min_v = rho_v;
    		}
    		rho_v = (rho_max_v + rho_min_v) / 2;
    		theta_v = theta_sum_v / lines_v.size();
    		if (theta_v > CV_PI)theta_v -= CV_PI;
    		else rho_v = -rho_v;
    		a = cos(theta_v), b = sin(theta_v);
    		x0 = a*rho_v, y0 = b*rho_v;
    		pt3.x = cvRound(x0 + 1000 * (-b));
    		pt3.y = cvRound(y0 + 1000 * (a));
    		pt4.x = cvRound(x0 - 1000 * (-b));
    		pt4.y = cvRound(y0 - 1000 * (a));
    		//line(src, pt3, pt4, Scalar(0, 0, 255), 2, LINE_AA);
    
    		/*求直线交点*/
    		if (lines_v.size()>0 && lines_h.size() && lines_v.size())
    		{
    			float a1, b1, a2, b2;
    
    			if (pt1.x != pt2.x)a1 = (float)(pt1.y - pt2.y) / (float)(pt1.x - pt2.x);
    			else a1 = 1000;
    			b1 = (float)pt1.y - a1*(float)pt1.x;
    
    			if (pt3.x != pt4.x)a2 = (float)(pt3.y - pt4.y) / (float)(pt3.x - pt4.x);
    			else a2 = 1000;
    			b2 = (float)pt3.y - a2*(float)pt3.x;
    			CrossPoint.x = (b1 - b2) / (a2 - a1);
    			CrossPoint.y = a1 * (float)CrossPoint.x + b1;
    		}
    	}
    	return CrossPoint;
    }
    /*******************************************************************************************
    *函数功能 : 用于顶部摄像头放置横着或者竖着的挡板前的定位
    *输入参数 : 第一个参数 0为横着,1为竖着
    *返 回 值 : 无
    *编写时间 : 2018.8.15
    *作    者 : Biger姚
    ********************************************************************************************/
    void  CrossLocate(int mode)
    {
    	Mat srcImage = Mat::zeros(240, 320, CV_8UC1);
    	Rect rect(80, 50, 160, 190);//前两个参数:原图中开始裁剪的坐标 后两个参数:矩形的列和行
    	Mat src, img;
    	Point center, target;
    	if (mode == 0)
    	{
    		target.x = 88;   //88
    		target.y = 104;  //104
    	}
    	else
    	{
    		target.x = 84;
    		target.y = 149;
    	}
    	int error_x, error_y;
    	error_x = 0;
    	error_y = 0;
    	while (true)
    	{
    		Forward_flag = 3;
    		img = imgOriginal_up;
    		img = img(rect);
    		img.copyTo(src);//复制原图用于显示
    		Mat imgHSV;
    		cvtColor(img, imgHSV, COLOR_BGR2HSV);
    		int iLowH_1 = 0;//红色的H:0-20,160-180
    		int iHighH_1 = 20;
    		int iLowH_2 = 140;//红色的H:0-20,160-180
    		int iHighH_2 = 180;
    		int iLowS = 0;
    		int iHighS = 255;
    		int iLowV = 0;
    		int iHighV = 255;
    		Mat imgThresholded1(img.size(), CV_8UC1, cv::Scalar(0));
    		Mat imgThresholded2(img.size(), CV_8UC1, cv::Scalar(0));
    		inRange(imgHSV, Scalar(iLowH_1, iLowS, iLowV), Scalar(iHighH_1, iHighS, iHighV), imgThresholded1); //Threshold the image
    		inRange(imgHSV, Scalar(iLowH_2, iLowS, iLowV), Scalar(iHighH_2, iHighS, iHighV), imgThresholded2); //Threshold the image
    		Mat imgThresholded_add;
    		addWeighted(imgThresholded1, 1, imgThresholded2, 1, 0, imgThresholded_add);
    		cvtColor(img, srcImage, CV_BGR2GRAY);
    		addWeighted(imgThresholded_add, 1, srcImage, 1, 0, srcImage);
    		srcImage = srcImage > 120;//改为全局变量
    		//输入二值化原图 找十字交点
    		center = findCrossPoint(srcImage);
    		//画出中心
    		circle(src, center, 10, Scalar(0, 0, 255), FILLED);
    		/*namedWindow("【结果】", 0);
    		imshow("【结果】", src);
    		waitKey(1);*/
    		error_x = -(target.x - center.x) / 2.8;//让右边数字移到右边
    		error_y = (target.y - center.y) / 2.8;
    		if (error_x > 10 || error_x<-10)
    		{
    			error_y = 0;
    		}
    		error_x = error_x > 120 ? 120 : error_x;
    		error_x = error_x < -120 ? -120 : error_x;
    		error_y = error_y > 120 ? 120 : error_y;
    		error_y = error_y < -120 ? -120 : error_y;
    		static int break_cnt = 0;
    		if (error_x>-3 && error_x<3 && error_y>-2 && error_y<2)
    		{
    			break_cnt++;
    			Send_to_K60(16, 0, 0);
    			Sleep(10);
    			if (break_cnt>8)
    			{
    				break_cnt = 0;
    				break;
    			}
    		}
    		else 
    		{
    			Send_to_K60(Forward_flag, error_x, error_y);
    			if (break_cnt > 0)
    			{
    				break_cnt--;
    			}
    		
    		}
    
    	
    	}
    	Send_to_K60(16, 0, 0);
    }
    
    /*******************************************************************************************
    *函数功能 : 放置挡板前目标数字为个位数的定位,有横竖和第一块第二块之分
    *输入参数 : 第一个参数为目标数字,第二个参数是 0为横着,1为竖着,第三个参数是 1为第一块挡板,2为第二块挡板,
    *返 回 值 : 空
    *编写时间 : 2018.8.13
    *作    者 : 毛哥(参考叶少及姚总)
    ********************************************************************************************/
    void Dangban_DingWei_Single_Num(int num_obj, int mode, int cishu)
    {
    
    	int flag_finish = 0;
    
    	Forward_flag = 3;
    	int Finish_cnt = 0;
    	int error1 = 0, error2 = 0, text = 0;
    	//目标数字及目标数字隔壁的
    	int num_obj_units = num_obj;//个位
    	int num_obj_1 = num_obj + 1;//必须是两位数
    	int num_obj_units_1 = num_obj_1;//个位
    
    	//int pic_name = 0;
    	//char str1[2000];
    	Mat srcImage0;
    	for (int i = 0; i < 6; i++)
    	{//取几帧图像缓冲
    		cap_up >> srcImage0;
    	}
    	Mat srcImage = Mat::zeros(600, 800, CV_8UC3);
    	Point Put_obj;
    	if (mode == PUT_CHESS)
    	{
    		Put_obj.x = 386;
    		Put_obj.y = 347;
    	}
    	else if (mode == PUT_BLOCK_H)
    	{
    		Put_obj.x = 386;
    		Put_obj.y = 140;
    	}
    	else if (mode == PUT_BLOCK_V)
    	{
    		Put_obj.x = 175;
    		Put_obj.y = 369;
    	}
    	while (1)
    	{
    		Point center_obj;
    		//clock_t start = clock();
    
    		Forward_flag = 3;
    		//cap_up >> srcImage0;
    		srcImage0 = imgOriginal_up;
    		if (!srcImage0.empty())
    		{
    			//imshow("原图0", srcImage0);
    			Mat drawing(srcImage.size(), CV_8UC3, cv::Scalar(0));
    			resize(srcImage0, srcImage, srcImage.size());
    			cvtColor(srcImage, srcImage, CV_BGR2GRAY);
    			srcImage = srcImage > G_threshold_up;//二值化
    
    			vector<Vec2f>lines = findHoughLines(srcImage);
    			vector<float> V_line = find_V_Lines(lines);
    			float angle = 0;
    			draw_line(V_line[0], V_line[1], V_line[2], drawing);
    			if (lines.size()>0)
    			{
    				angle = cvFastArctan(V_line[1], V_line[0]);
    			}
    			if (angle>90)
    			{
    				angle = angle - 180;
    			}
    			angle = angle * 2;
    			srcImage = Spin_Img(srcImage, angle);//车身倾斜旋转图像以识别数字
    
    			vector<Min_Rect> Doubt_num_decade, Doubt_num_units;
    			vector<Min_Rect> Doubt_num_decade_1, Doubt_num_units_1;
    
    			vector<Min_Rect>Doubt_numRect = Find_Doubt_NumRect(srcImage);//各种滤波找怀疑是数字框的矩形框
    
    			if (Doubt_numRect.size()>0)
    			{
    				for (int i = 0; i < Doubt_numRect.size(); i++)
    				{
    					int num = number_identify(Doubt_numRect[i].Pic, SVM_params_UP);
    
    					if (num == num_obj_units)
    					{//识别数字滤波(个位)
    						Doubt_num_units.push_back(Doubt_numRect[i]);
    					}
    
    					if (num == num_obj_units_1)
    					{//识别隔壁数字(个位)
    						Doubt_num_units_1.push_back(Doubt_numRect[i]);
    					}
    				}
    			}
    			int flag_1 = 0;
    			if (Doubt_num_units.size()>0)
    			{//在怀疑是数字的方框里找最可能是需要的,得到目标坐标
    				float dis_min = 100000, dis = 0;
    				for (size_t i = 0; i < Doubt_num_units.size(); i++)
    				{
    					Point temp_center;
    					temp_center = Doubt_num_units[i].center;
    					dis = getDistance(Point(386, 401), temp_center);
    					if (dis<dis_min&&dis<400)
    					{
    						dis_min = dis;
    						center_obj = temp_center;
    						flag_1 = 1;
    						计算是否符合机械臂可抓取的范围
    						//float holder_Dis = getDistance(center_obj, holder_center);
    						//int theta = cvFastArctan((float)(holder_center.x - center_obj.x), (float)(holder_center.y - center_obj.y));
    						//if (holder_Dis>holder_radius - dia&&holder_radius + dia)
    						//{//可以抓取
    						//	Send_to_K60(0, 0, 0);
    						//	Sleep(50);
    						//	Send_to_K60(7, -theta, 0);
    						//	flag_finish++;
    						//}
    						//else
    						//{//计算运动目标
    						//	Put_obj.x = holder_center.x - (float)(holder_radius)*sin(theta*0.0174);
    						//	Put_obj.y = holder_center.y - (float)(holder_radius)*cos(theta*0.0174);
    						//}
    						circle(drawing, center_obj, 5, Scalar(0, 255, 0), FILLED, LINE_AA);
    					}
    				}
    				if (flag_finish>10)
    				{//如果判断可以放,break出while1
    					break;
    				}
    				error1 = (Put_obj.x - center_obj.x);//让右边数字移到右边
    				error2 = (Put_obj.y - center_obj.y);
    				error1 = error1 > 120 ? 120 : error1;
    				error1 = error1 < -120 ? -120 : error1;
    				error2 = error2 > 120 ? 120 : error2;
    				error2 = error2 < -120 ? -120 : error2;
    			}
    			if (flag_1 == 0 && Doubt_num_units_1.size()>0)
    			{//在怀疑是数字的方框里找最可能是需要的,得到目标坐标(隔壁数字)
    				float dis_min = 100000, dis = 0;
    				for (size_t i = 0; i < Doubt_num_units_1.size(); i++)
    				{
    					Point temp_center;
    					temp_center = Doubt_num_units_1[i].center;
    					dis = getDistance(Point(386, 401), temp_center);
    					if (dis<dis_min&&dis<400)
    					{
    						dis_min = dis;
    						center_obj = temp_center;
    						circle(drawing, center_obj, 5, Scalar(0, 0, 255), FILLED, LINE_AA);
    					}
    				}
    				error1 = -(800 - center_obj.x);//让右边数字移到右边
    				error2 = (401 - center_obj.y);
    				error1 = error1 > 120 ? 120 : error1;
    				error1 = error1 < -120 ? -120 : error1;
    				error2 = error2 > 120 ? 120 : error2;
    				error2 = error2 < -120 ? -120 : error2;
    			}
    
    			cout << "放置挡板定位error1为:" << error1 << endl;
    			cout << "放置挡板定位error2为:" << error2 << endl;
    			cout << "Forward_flag为:" << (int)Forward_flag << endl;
    
    
    			if (error1>30 || error1<-30)
    			{
    				error2 = 0;
    			}
    			if (center_obj.x == 0 && center_obj.y == 0)
    			{
    				error1 = -10;
    				error2 = -10;
    			}
    			Send_to_K60(Forward_flag, error1, error2);
    			//imshow("drawing1", drawing);
    			//imshow("原图", srcImage);
    			waitKey(1);
    		}
    	}
    
    	cout << "放置挡板定位成功" << endl;
    }
    
    
    //放挡板,必须是两位数
    //第一个参数是数字,第二个参数是竖着还是横着0为横着,1为竖着
    //*flag    4    爪子直立起来的,且有磁性,此时手动往机械臂上放置挡板
    //	*  flag - 4    爪子到了位置,开始放置,发送一次即可
    
    /*******************************************************************************************
    *函数功能 : 放置挡板前目标数字为双数的定位,有横竖和第一块第二块之分
    *输入参数 : 第一个参数为目标数字,第二个参数是 0为横着,1为竖着,第三个参数是 1为第一块挡板,2为第二块挡板,
    *返 回 值 : 单条直线的ABC值,如果没有正确找到直线,就返回-1,函数外边再判断
    *编写时间 : 2018.8.13
    *作    者 : 毛哥(参考叶少及姚总)
    ********************************************************************************************/
    void Dangban_DingWei_Double_Num(int num_obj, int mode, int cishu)
    {
    	int flag_finish = 0;//跳出计数,稳定性
    	Forward_flag = 3;
    	int Finish_cnt = 0;
    	int error1 = 0, error2 = 0, text = 0;
    	//目标数字及目标数字隔壁的
    	int num_obj_decade = num_obj / 10;//十位
    	int num_obj_units = num_obj % 10;//个位
    
    	int num_obj_1 = num_obj + 1;//必须是两位数
    	int num_obj_decade_1 = num_obj_1 / 10;//十位
    	int num_obj_units_1 = num_obj_1 % 10;//个位
    
    	Mat srcImage0;
    	Mat srcImage = Mat::zeros(600, 800, CV_8UC3);
    	Point Put_obj;
    
    	if (mode == PUT_CHESS)
    	{
    		Put_obj.x = 386;
    		Put_obj.y = 347;
    	}
    	else if (mode == PUT_BLOCK_H)//0为水平,已经调好(8月14日)
    	{
    		Put_obj.x = 198;
    		Put_obj.y = 158;
    	}
    	else if (mode == PUT_BLOCK_V)//1为竖直,已经调好(8月13日)
    	{
    		Put_obj.x = 200;
    		Put_obj.y = 270;
    	}
    
    	while (1)
    	{
    		Point center_obj;
    		//clock_t start = clock();
    
    		Forward_flag = 3;
    		srcImage0 = imgOriginal_up;
    		if (!srcImage0.empty())
    		{
    			//imshow("原图0", srcImage0);
    
    			Mat drawing(srcImage.size(), CV_8UC3, cv::Scalar(0));
    			resize(srcImage0, srcImage, srcImage.size());
    			cvtColor(srcImage, srcImage, CV_BGR2GRAY);
    			srcImage = srcImage > G_threshold_up;//二值化
    
    			vector<Vec2f>lines = findHoughLines(srcImage);
    			vector<float> V_line = find_V_Lines(lines);
    			float angle = 0;
    			draw_line(V_line[0], V_line[1], V_line[2], drawing);
    			if (lines.size() > 0)
    			{
    				angle = cvFastArctan(V_line[1], V_line[0]);
    			}
    			if (angle > 90)
    			{
    				angle = angle - 180;
    			}
    			angle = angle * 2;
    			//计算出角度后旋转图片
    			srcImage = Spin_Img(srcImage, angle);
    
    			vector<Min_Rect> Doubt_num_decade, Doubt_num_units;
    			vector<Min_Rect> Doubt_num_decade_1, Doubt_num_units_1;
    
    			//bug1,如果当前数字位置有
    			vector<Min_Rect>Doubt_numRect = Find_Doubt_NumRect(srcImage);//各种滤波找怀疑是数字框的矩形框
    
    			if (Doubt_numRect.size()>0)
    			{
    				for (int i = 0; i < Doubt_numRect.size(); i++)
    				{
    					int num = number_identify(Doubt_numRect[i].Pic, SVM_params_UP);
    					if (num == num_obj_decade)
    					{//识别数字滤波(十位)
    						Doubt_num_decade.push_back(Doubt_numRect[i]);
    					}
    					if (num == num_obj_units)
    					{//识别数字滤波(个位)
    						Doubt_num_units.push_back(Doubt_numRect[i]);
    					}
    					if (num == num_obj_decade_1)
    					{//识别隔壁数字(十位)
    						Doubt_num_decade_1.push_back(Doubt_numRect[i]);
    					}
    					if (num == num_obj_units_1)
    					{//识别隔壁数字(个位)
    						Doubt_num_units_1.push_back(Doubt_numRect[i]);
    					}
    				}
    			}
    			int flag_1 = 0;
    			if (Doubt_num_decade.size()>0 && Doubt_num_units.size()>0)
    			{//在怀疑是数字的方框里找最可能是需要的,得到目标坐标
    				vector<Min_Rect>Doubt_num_obj(2);
    				float dis_min = 100000, dis = 0;
    				for (int i = 0; i < Doubt_num_decade.size(); i++)
    				{
    					for (int j = 0; j < Doubt_num_units.size(); j++)
    					{
    						if (Doubt_num_decade[i].center.x<Doubt_num_units[j].center.x)
    						{//dis为两中心点距离,center与目标点的距离加权
    							Point temp_center;
    							temp_center.x = (Doubt_num_decade[i].center.x + Doubt_num_units[j].center.x) / 2;
    							temp_center.y = (Doubt_num_decade[i].center.y + Doubt_num_units[j].center.y) / 2;
    							dis = getDistance(Doubt_num_decade[i].center, Doubt_num_units[j].center)
    								+ getDistance(Point(386, 347), temp_center);
    							if (dis<dis_min&&dis<400)
    							{//如果可以找到目标数字中心
    								dis_min = dis;
    								Doubt_num_obj[0] = Doubt_num_decade[i];
    								Doubt_num_obj[1] = Doubt_num_units[j];
    								center_obj = temp_center; //数字中心
    								flag_1 = 1;
    								circle(drawing, center_obj, 5, Scalar(255, 0, 0), FILLED, LINE_AA);
    								//计算是否符合机械臂可抓取的范围
    								//float holder_Dis = getDistance(center_obj, holder_center);
    								//int theta = cvFastArctan((float)(holder_center.x - center_obj.x), (float)(holder_center.y - center_obj.y));
    								//if (holder_Dis>holder_radius - dia&&holder_radius + dia)
    								//{//可以抓取
    								//	Send_to_K60(0, 0, 0);
    								//	Sleep(50);
    								//	Send_to_K60(7, -theta, 0);
    								//	flag_finish++;
    								//}
    								//else
    								//{//计算运动目标
    								//	Put_obj.x = holder_center.x - (float)(holder_radius)*sin(theta*0.0174);
    								//	Put_obj.y = holder_center.y - (float)(holder_radius)*cos(theta*0.0174);
    								//}
    							}
    						}
    					}
    				}
    
    				//error1 = (int)((365.0 - (float)center_obj.x) / 1.6);//1.6这个系数刚好,电压8.2V左右
    				//error2 = (int)((136.0 - (float)center_obj.y) / 1.0);//1.0这个系数刚好
    
    				error1 = -(float)(Put_obj.x - center_obj.x) / 8.0;//让右边数字移到右边
    				error2 = (float)(Put_obj.y - center_obj.y) / 8.0;
    				error1 = error1 > 120 ? 120 : error1;
    				error1 = error1 < -120 ? -120 : error1;
    				error2 = error2 > 120 ? 120 : error2;
    				error2 = error2 < -120 ? -120 : error2;
    			}
    			if (flag_1 == 0 && Doubt_num_decade_1.size()>0 && Doubt_num_units_1.size()>0)
    			{//在怀疑是数字的方框里找最可能是需要的,得到目标坐标(隔壁数字)
    				vector<Min_Rect>Doubt_num_obj(2);
    				float dis_min = 100000, dis = 0;
    				for (int i = 0; i < Doubt_num_decade_1.size(); i++)
    				{
    					for (int j = 0; j < Doubt_num_units_1.size(); j++)
    					{
    						if (Doubt_num_decade_1[i].center.x<Doubt_num_units_1[j].center.x)
    						{//dis为两中心点距离,center与目标点的距离加权
    							Point temp_center;
    							temp_center.x = (Doubt_num_decade_1[i].center.x + Doubt_num_units_1[j].center.x) / 2;
    							temp_center.y = (Doubt_num_decade_1[i].center.y + Doubt_num_units_1[j].center.y) / 2;
    							dis = getDistance(Doubt_num_decade_1[i].center, Doubt_num_units_1[j].center)
    								+ getDistance(Point(386, 347), temp_center);
    							if (dis<dis_min&&dis<400)
    							{
    								dis_min = dis;
    								Doubt_num_obj[0] = Doubt_num_decade_1[i];
    								Doubt_num_obj[1] = Doubt_num_units_1[j];
    								center_obj = temp_center;
    								circle(drawing, center_obj, 5, Scalar(255, 0, 0), FILLED, LINE_AA);
    							}
    						}
    					}
    				}
    				error1 = -(800 - center_obj.x);//让右边数字移到右边
    				error2 = (Put_obj.y - center_obj.y);
    				error1 = error1 > 120 ? 120 : error1;
    				error1 = error1 < -120 ? -120 : error1;
    				error2 = error2 > 120 ? 120 : error2;
    				error2 = error2 < -120 ? -120 : error2;
    
    				//目标 放棋子:center:x=386,y=347
    				//目标 放挡板:center:x=386,y=149
    			}
    			//cout << "放置挡板定位error1为:" << error1 << endl;
    			//cout << "放置挡板定位error2为:" << error2 << endl;
    			//cout << "Forward_flag为:" << (int)Forward_flag << endl;
    
    
    			if (error1>30 || error1<-30)
    			{
    				error2 = 0;
    			}
    			if (center_obj.x == 0 && center_obj.y == 0)
    			{
    				error1 = -25;
    				error2 = -25;
    			}
    			if (error1<7 && error2<7 && error1>-7 && error2>-7)
    			{
    				Forward_flag = 16;
    				flag_finish++;
    				//	cout << "Finish_cnt为:" << Finish_cnt << endl;
    				if (flag_finish>5)
    				{
    					break;
    				}
    			}
    			else
    			{
    				flag_finish = 0;
    
    			}
    
    
    			Send_to_K60(Forward_flag, error1, error2);
    			//imshow("drawing1", drawing);
    			//imshow("原图", srcImage);
    			waitKey(1);
    		}
    	}
    	//放下
    	cout << "放置挡板定位成功" << endl;
    }
    
    
    
    /*找最大的轮廓*/
    Mat findMaxContouns(Mat img)
    {
    	vector<vector<Point>> contours;
    	vector<Vec4i>hierarchy;
    	int row_i, col_i;
    	float row_max = 0.0, col_min = 3.3;
    	findContours(img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
    	Mat dstImage = Mat::zeros(img.size(), CV_8UC3);
    	long int max_l = 0;
    	int max_i = 0;
    	if (contours.size() > 0)
    	{
    		vector<float> length(contours.size());
    		//找最大的轮廓
    #pragma omp parallel for
    		for (int i = 0; i < contours.size(); i++)
    		{
    			length[i] = arcLength(contours[i], true);
    		}
    		for (int i = 0; i < contours.size(); i++)
    		{
    			if (length[i] > max_l)
    			{
    				max_l = length[i];
    				max_i = i;
    			}
    		}
    		drawContours(dstImage, contours, max_i, (0, 0, 255), 1, 8, hierarchy);
    		//imshow("轮廓图", dstImage);
    	}
    	//center = findContunsCenter(contours, max_i);
    	return dstImage;
    }
    /*******************************************************************************************
    *函数功能 : 获取横线或竖线一般式方程参数
    *输入参数 : mode,0横1竖
    *返 回 值 : PARAM 一般式ABC三个参数
    *编写时间 : 2018.8.15
    *作    者 : 姚
    ********************************************************************************************/
    vector <float> getVHlineParam(int mode)
    {
    	int cnt = 0;
    	//vector <float> PARAM;
    	float A = 0, B = 0, C = 0;
    	float filter_A[4] = { 0 }, filter_B[4] = { 0 }, filter_C[4] = { 0 };
    	vector<vector<Point>> contours;
    	vector<Vec4i>hierarchy;
    	Mat midImage, dstImage, img, src, img0;
    	int break_cnt = 0;
    	Point pt1, pt2, pt3, pt4;
    	while (true)
    	{
    		img = imgOriginal_up;
    		if (mode == 0)//横着
    		{
    			Rect rect(0, img.rows*0.3, img.cols, img.rows*(0.95 - 0.3));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			img = img(rect);
    		}
    		else //竖着
    		{
    			Rect rect(img.cols*0.075, img.rows*0.2, img.cols*(0.875 - 0.075), img.rows*(0.83 - 0.2));   //创建一个Rect框,属于cv中的类,四个参数代表x,y,width,height 
    			img = img(rect);
    		}
    		img.copyTo(src);
    		cvtColor(img, img0, COLOR_BGR2GRAY);
    		img0 = img0 > 110;
    		dstImage = findMaxContouns(img0);
    		cvtColor(dstImage, midImage, COLOR_BGR2GRAY);
    		midImage = midImage > 2;
    		vector<Vec2f> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    		HoughLines(midImage, lines, 1, CV_PI / 180, 60);
    		if (lines.size() > 0)
    		{//横竖线分类 求出两条横竖线后求交点
    			vector<Vec2f> lines_h;//定义一个矢量结构lines用于存放得到的线段矢量集合
    			vector<Vec2f> lines_v;//定义一个矢量结构lines用于存放得到的线段矢量集合
    			float rho_min_h = 10000, rho_max_h = -10000, rho_min_v = 10000, rho_max_v = -10000;
    			float theta_sum_v = 0, theta_sum_h = 0;
    			float theta;
    			float rho_h, theta_h, rho_v, theta_v;
    			double a, b;
    			double x0, y0;
    			for (int i = 0; i < lines.size(); i++)
    			{
    				theta = lines[i][1];
    				if (theta >= 2.355 || theta <= 0.785)lines_v.push_back(lines[i]);//shu
    				else if (theta >= 0.785&&theta <= 2.355)lines_h.push_back(lines[i]);//heng
    			}
    			/*heng*/
    			if (mode == 0)
    			{
    				for (size_t i = 0; i < lines_h.size(); i++)
    				{
    					rho_h = lines_h[i][0], theta_h = lines_h[i][1];
    					theta_sum_h += theta_h;
    					/*a = cos(theta_h), b = sin(theta_h);
    					x0 = a*rho_h, y0 = b*rho_h;
    					pt1.x = cvRound(x0 + 1000 * (-b));
    					pt1.y = cvRound(y0 + 1000 * (a));
    					pt2.x = cvRound(x0 - 1000 * (-b));
    					pt2.y = cvRound(y0 - 1000 * (a));
    					line(src, pt1, pt2, Scalar(0, 0, 0), 1, LINE_AA);*/
    					if (rho_h >= rho_max_h)rho_max_h = rho_h;
    					if (rho_h <= rho_min_h)rho_min_h = rho_h;
    				}
    				rho_h = (rho_max_h + rho_min_h) / 2;
    				theta_h = theta_sum_h / lines_h.size();
    				a = cos(theta_h), b = sin(theta_h);
    				x0 = a*rho_h, y0 = b*rho_h;
    				pt1.x = cvRound(x0 + 1000 * (-b));
    				pt1.y = cvRound(y0 + 1000 * (a));
    				pt2.x = cvRound(x0 - 1000 * (-b));
    				pt2.y = cvRound(y0 - 1000 * (a));
    				line(src, pt1, pt2, Scalar(0, 0, 255), 2, LINE_AA);
    
    				filter_A[3] = filter_A[2];
    				filter_B[3] = filter_B[2];
    				filter_C[3] = filter_C[2];
    
    				filter_A[2] = filter_A[1];
    				filter_B[2] = filter_B[1];
    				filter_C[2] = filter_C[1];
    
    				filter_A[1] = filter_A[0];
    				filter_B[1] = filter_B[0];
    				filter_C[1] = filter_C[0];
    
    				filter_A[0] = pt2.y - pt1.y;
    				filter_B[0] = pt1.x - pt2.x;
    				filter_C[0] = pt1.y*(pt2.y - pt1.y) - pt1.x*(pt2.y - pt1.y);
    				if (fabs(filter_A[0] - filter_A[1])<2)
    				{
    					cnt++;
    					A = 0.4*filter_A[0] + 0.3*filter_A[1] + 0.2*filter_A[2] + 0.1*filter_A[3];
    					B = 0.4*filter_B[0] + 0.3*filter_B[1] + 0.2*filter_B[2] + 0.1*filter_B[3];
    					C = 0.4*filter_C[0] + 0.3*filter_C[1] + 0.2*filter_C[2] + 0.1*filter_C[3];
    					if (cnt>8)
    					{
    						break;
    					}
    				}
    				else
    				{
    					if (cnt>0)cnt--;
    				}
    			}
    			else
    			{
    				//shu
    				for (size_t i = 0; i < lines_v.size(); i++)
    				{
    					rho_v = lines_v[i][0], theta_v = lines_v[i][1];
    					if (theta_v<0.6)
    					{
    						theta_sum_v += theta_v;
    						theta_sum_v += CV_PI;
    					}
    					else  theta_sum_v += theta_v;
    					/*a = cos(theta_v), b = sin(theta_v);
    					x0 = a*rho_v, y0 = b*rho_v;
    					pt3.x = cvRound(x0 + 1000 * (-b));
    					pt3.y = cvRound(y0 + 1000 * (a));
    					pt4.x = cvRound(x0 - 1000 * (-b));
    					pt4.y = cvRound(y0 - 1000 * (a));
    					line(src, pt3, pt4, Scalar(0, 0, 0), 1, LINE_AA);*/
    					if (rho_v < 0)rho_v = -rho_v;
    					if (rho_v >= rho_max_v)rho_max_v = rho_v;
    					if (rho_v <= rho_min_v)rho_min_v = rho_v;
    				}
    				rho_v = (rho_max_v + rho_min_v) / 2;
    				theta_v = theta_sum_v / lines_v.size();
    				if (theta_v > CV_PI)theta_v -= CV_PI;
    				else rho_v = -rho_v;
    				a = cos(theta_v), b = sin(theta_v);
    				x0 = a*rho_v, y0 = b*rho_v;
    				pt3.x = cvRound(x0 + 1000 * (-b));
    				pt3.y = cvRound(y0 + 1000 * (a));
    				pt4.x = cvRound(x0 - 1000 * (-b));
    				pt4.y = cvRound(y0 - 1000 * (a));
    				line(src, pt3, pt4, Scalar(0, 0, 255), 2, LINE_AA);
    				filter_A[3] = filter_A[2];
    				filter_B[3] = filter_B[2];
    				filter_C[3] = filter_C[2];
    
    				filter_A[2] = filter_A[1];
    				filter_B[2] = filter_B[1];
    				filter_C[2] = filter_C[1];
    
    				filter_A[1] = filter_A[0];
    				filter_B[1] = filter_B[0];
    				filter_C[1] = filter_C[0];
    
    				filter_A[0] = pt4.y - pt3.y;
    				filter_B[0] = pt3.x - pt4.x;
    				filter_C[0] = pt3.y*(pt4.y - pt3.y) - pt3.x*(pt4.y - pt3.y);
    				if (fabs(filter_A[0] - filter_A[1])<2)
    				{
    					cnt++;
    					A = 0.4*filter_A[0] + 0.3*filter_A[1] + 0.2*filter_A[2] + 0.1*filter_A[3];
    					B = 0.4*filter_B[0] + 0.3*filter_B[1] + 0.2*filter_B[2] + 0.1*filter_B[3];
    					C = 0.4*filter_C[0] + 0.3*filter_C[1] + 0.2*filter_C[2] + 0.1*filter_C[3];
    					if (cnt>8)
    					{
    						break;
    					}
    				}
    				else
    				{
    					if (cnt>0)cnt--;
    				}
    			}
    			namedWindow("图像", 0);
    			imshow("图像", src);
    			waitKey(1);
    		}
    	}
    	vector<float> fangcheng_PARAM;
    	if (mode == 0)
    	{
    		fangcheng_PARAM = get_lines_yibanshi_fangcheng_2(pt1, pt2);
    	}
    	else
    	{
    		fangcheng_PARAM = get_lines_yibanshi_fangcheng_2(pt3, pt4);
    	}
    	return fangcheng_PARAM;
    	//PARAM.push_back(A);
    	//PARAM.push_back(B);
    	//PARAM.push_back(C);
    	//return PARAM;
    }
    
    展开全文
  • 汽车挡风玻璃HUD的示意图: 已使用表面贴装组件来减小电路板尺寸。为了简化布线,显示屏上的数字引脚未映射至MAX7219驱动器IC上的相应引脚。该软件为此留出余地,并相应地调整输出。如果您希望将电路板商业化生产,...
  • 汽车驾驶教程图解

    2012-05-26 08:56:12
     下雨天行驶时使用,档位。  向转向盘方向扳动开关(或按下开关的按钮)清洁液喷出,可将弄脏的汽车窗擦洗干净。空刮会伤害玻璃,所以在刮洗时一定要喷出清洁液。  *危险警示灯(俗称“双闪 开关  按下时...
  • ML系列快速入门各位新手们,可能您刚刚提车路,有没有象下图这样刚一坐驾驶,有点手足无措感觉?别紧张,奔驰ML系列操作...驾驶室示意图1 方向盘换档拨片 2 组合开关 3 仪表盘 4 喇叭 5 换档杆 6 雷达警...

    ML系列快速入门

    各位新手们,可能您刚刚提车路,有没有象下图这样刚一坐驾驶位,有点手足无措

    f2c37fc43129d4f8ce2de9250dce972b.gif感觉?

    e1bc51f55a69301bfdf8f8770f90eb98.png

    别紧张,奔驰ML系列操作可比波音737简单。我们把简简单单几幅图一看,保证快心里有数,开新车路,自信满满。

    c3c69daddb715a6bc5317fc554066ed2.gif

    注:图示是来自美版、加版车,不过99%功能按钮与中版车一样,完全参考没问题。

    驾驶室示意图

    36fb8b10d4b745cd93f35af9ec70c104.png

    1 方向盘换档拨片   2 组合开关   3 仪表盘  4 喇叭   5 换档杆   6 雷达警告显示   7 方控制面板  8 气候控制系统  9 点火开关 启动/停止按钮 10 手动调整方向盘  11 加热方向盘  12 巡航控制杆 13 打开引擎盖 14 车载诊断接口  15 电动驻车制动器  16 照明开关 17 夜景辅助系统

    仪表盘示意图

    47e002c76cd3156057af706646fa18c1.png

    1 分段显示速度表   2 功能显示屏   3 转速表   4 冷却液温度表   5 油量表  6 仪表盘亮度调节 (顺时针:亮,逆时针:暗)

    仪表盘指示灯示意图

    0e3617dec015d9d8fac309d9ad9f5d57.png

    1 光灯  2 行车稳定系统 ESP  3 远光灯  4 电子驻车指示灯(红色) 5 电子驻车警告灯(黄色) 6 车距警告灯  7 转向灯  8 胎压警告灯 9 安全气囊警告灯 SRS  10 安全带未系警告 11 柴油发动机预热指示 13 后雾灯  14 发动机诊断警告  15 储备油量警告  16 行业稳定系统关闭警告灯 ESP? OFF  17 防抱死制动系统警告 ABS  18 制动警告灯(红色)

    功能方向盘示意图

    41344f7606b7cde9a1c9cf2a24899cb1.png

    1 功能显示  2 音频系统  3 开启声控系统  4 拒接或挂断来电,退出电话本;拨打或接听来电,重拨电话;调节音量;静音   5  选择菜单; 选择菜单或滚动列表;确认选择/隐藏显示信息; 返回,关闭声控系统

    中央控制台(部)示意图

    9c04e221f61a5e2a07fd057ff0517330.png

    1 音频/媒体系统  2  座椅加热  3  座椅通风  4 驻车定位系统  5 下坡车速调节  6 危险警告灯(双闪) 7  前排气囊指示  8 ESP电控车辆行驶稳定系统

    注:1、中版车无座椅通风功能

    e7b425ca2967421d14f9bc88bffbb9ad.gif。 2、中间那个圆形“ON”旋钮下面插槽,是插SD存储卡,可以放音乐,酷吧?

    ef466c2e337bede85b321f74db296d05.gif

    中央控制台(下部)示意图

    0566bf9a9b4a54018dbc931143cbe5ec.png

    9 杯架、烟灰缸、点烟器、电源插座  10 音频/媒体控制器 11速档  12陡坡缓降 13自适应悬架调节  14 打开储物箱

    注:ML400豪华还有驾驶模式选择按钮,图没有显示。

    方控制面板示意图

    5c8f71f639a2930759a9630506ae7f91.png

    1 开关左侧阅读灯 2 开启前排车内照明 3 开关后尾厢照明 4 关闭前排车内照明  5 开关右侧阅读灯 6 开关天窗  7 眼镜盒 8 停用车内活动传感器 9 SOS按钮  10 停用防拖车保护 11 车内后视镜

    车门控制面板示意图

    af89f370de8eddf3756756bd8a312d40.png

    1 开门  2 解锁/锁车辆  3 保存座椅、外部后视镜、方向盘设定  4 调节座椅  5  电动调节、打开、折合外部后视镜  6 开关侧窗  7 开关尾门  8 启用/停用后车窗超越控制功能

    行车电脑菜单示意图

    7dd439032b1e52acbaff29ba15018fd4.png

    1 行程菜单  2 导航菜单  3 音频菜单  4 电话菜单  5 辅助菜单  6 保养菜单  7 设置菜单

    车外灯光控制示意图

    f669b05cc071c1de4e67d530e9eb563d.png

    Auto自动头灯模式/日间行车灯   1左侧驻车灯   2右侧驻车灯   3驻车灯、号牌灯、仪表灯  4自动头灯模式/日间行车灯   5光灯/远光灯   6后雾灯

    灯转向灯控制示意图

    79338fbbc37dfeedb66a17308bc81e0e.png

    1 开远光灯 2 右转向灯  3 闪灯   4 左转向灯

    前挡风玻璃雨刮器控制示意图

    a185e13fbba4edf5288b1a3b56362698.png

    1停止挡风雨刮  2慢速间歇刮  3快速间歇刮  4慢速连续刮  5快速连续刮  6刮一次  7用清洗液刮

    后窗雨刮器控制示意图

    89c7b436fe0d6105fb9258bf50a598f8.png

    1后窗雨刮开关   2用清洗液刮   3打开间歇刮   4关闭间歇刮   5用清洗液刮

    空调控制面板示意图

    e3d6bb50794d63f8a71d0e2d968824ba.png

    1 设置左区温度  2 挡风玻璃除雾  3 打开/关闭分区控制功能  4 打开/关闭致冷除湿,打开/关闭余热保温  5 打开/关闭后窗除雾  6 设置右区温度  7 打开/关闭空调内循环模式 8 设置风向  9 调风量  10 调小风量  11 关闭空调 12 设置空调为自动模式

    用后门安全锁防止小孩子在行车中开门

    左右后车门可以通过车门儿童安全锁分别锁,以防止在车辆行驶中小孩子打开后车门导致安全事故。

    后门安全锁锁以后,车门将无法从里面被打开,只能在停车以后从外边用门把手打开。

    da1270e636a4b3573d374f88b0d2bd3f.png

    向拨开关,可以锁后门安全锁。向下拨开关,可以打开后门安全锁。

    用后窗锁防止小孩子开关窗户玻璃被夹伤

    当后排有小孩子时,请注意锁后窗控制。否则,小孩可能会碰到后门后窗开关按钮,打开或关闭玻璃,导致被夹伤。

    3b5eac609cf1d6ed3b141bf12b3021df.png

    按钮1 用来打开或关闭后窗锁。当指示灯2亮时,后窗无法从后排开或关,只能由司机控制。当指示灯2灭时,后排乘客可以操作后排窗户玻璃升降。

    电子怀档使用

    最后,给还不熟悉奔驰怀档朋友们看一个小视频,告诉你怀档有方便

    fca2fd27b0053b6942373211060fb182.gif,但在极端情况下误操作有危险

    42690183db97f9c6820493b37dd76c30.gif

    http://v.youku.com/v_show/id_XNzIyODcyMjY4.html

    关于ML系列中控电脑详细操作指南,可以看手册。因为不是新手路所必需,此处欠奉,抱歉啦。

    c3ef2c9431067b779f9a63926be577e6.gif

    展开全文
  • 相信每一驾驶员都经历过初次上路的忐忑不安,眼盯前方,双手紧握转向盘,身体僵直前倾,远离前车,缓慢前行,起步停车或遇到坡路和堵车时经常熄火等等,这些都是新手的写照,只要稍加留意很容易辨认。客观地讲,...
  • BIOS设置图解

    千次阅读 2014-01-23 17:31:59
    BIOS设置图解之一 MSI H55 系列  2011-01-28 10:44:15| 分类: 其它|举报|字号 订阅 应为很多网友对BIOS还是 不太了解的,所以特地 转一些有用的帖子过来 方便大家参考 有用的朋友请看自己...
  • 苏乐面条机拆修图解

    千次阅读 2020-11-01 22:31:10
    目录苏乐面条机拆修图解前言1 认识苏乐面条机1.1 结构1.1.1 上遮板1.1.2 两侧版1.2.3 承重板1.2.4 地座板1.2.5 零件详图2 拆卸过程2.1 拆二侧面2.2 拆一侧面3 安装 苏乐面条机拆修图解 前言 为什么要写这博客呢?...
  • 《疯狂的程序员》

    万次阅读 2012-10-25 20:46:01
    日子一天一天过去,DAP的进展是越发困难,周总和绝影对这CASE彼此都是心照不宣。直到有一天,周总极其神秘地把绝影叫进办公室,说:“明天,我们一起去南京。” 绝影早就料到自己会去南京,虽然他是一万不想去...
  • 章 渲染管线

    2018-01-30 16:32:35
    给定一三维场景和定位的虚拟摄像机的几何描述,渲染管线是指基于虚拟摄像机看到的(5.1)生成二维图像所需的所有步骤序列。本章主要是理论性的 - 下一章将我们学习使Direct3D进行绘制的理论付诸实践。在我们...
  • 下面给大家准备了一系列的图解汽车文章,结合高清大剖析汽车内部结构,让复杂的原理变得通俗易懂。 您可点击以下链接,直接跳转到你想了解的汽车相关部分信息: 2发动机结构种类解析回...
  • 吉利领克05汽车使用手册用户操作图解驾驶车主车辆说明书pdf电子版下载
  • 路由器桥接(WIFI无线中继)设置及摆放位置图解 WIFI实在好用,但它的波覆盖面小、穿透力很差。我们安装时要考虑波的衍射特点,装在衍射效果最佳的位置(居中,室外可绕,避开密封墙)。确实无法兼顾的地方,我们可...
  • 手动控制变速箱就是手动控制离合和档位,一般会用左脚踩离合,右手控制档位变化;汽车自动根据速度变更档位和离合,就是自动。目前除了追求驾驶体验(跑车)或者降低汽车成本(出租),基本都会考虑自动。自动变速...
  • CVPR 2019期间,专注于AR技术,整合软硬件的人工智能公司亮风台公开大规模单目标跟踪高质量数据集LaSOT,包含超过352万帧手工标注的图片和1400视频,这也是...
  • 电 磁 阀大众609G自动变速器系统电磁阀可分为带两换挡位置的换挡电磁阀(开关电磁阀)和电动压力控制电磁阀(调压电磁阀)。 解 ▼N88、N89为换挡电磁阀,N90、N91、N92、N93、N282、N283为电动压力控制阀。换挡...
  • CentOS 7系统安装配置图解教程 操作系统:CentOS 7.3 备注: CentOS 7.x系列只有64系统,没有32.生产服务器建议安装CentOS-7-x86_64-Minimal-1611.iso版本 一.安装CentOS ... RHEL 6.10系统安装配置图解教程 EL ...
  • 07.CSS第天-浮动

    2019-07-04 14:29:45
    https://mp.csdn.net/media/05_父子盒子关系示意图.png )] ​ 2). 浮动元素与兄弟盒子的关系 在一父级盒子中,如果 前一兄弟盒子 是: 浮动 的,那么 当前盒子 会与前一盒子的顶部对齐; 普通流 ...
  • 12、档位分为PRNDM四个档位,分别是驻车、倒挡、空挡、前进。日系车的档杆波动时按照变速箱上的轨迹做的,其实你无须刻意的做什么,需要什么档位,直接拉着档把往下拉就行,档把会顺着轨迹走,阻力很小。最后...
  • 写在前面的话:因为英语不好,所以看得慢,所以还不如索性按自己的理解简单粗糙翻译一遍,就当是自己的读书笔记了。... 当你需要渲染一三维对象时,模型不仅需要合适的几何形状,还需要有合适的视觉外观。根据...
  • (挂二时关掉左转向灯) ­ ­ 二、停车。开右转向灯,踩刹车,踩到车速10至20码,再踩离合器,等车停稳后做以下动作: ­ 1。拉手制动。 ­ 2。脱空档。 ­ 3。关右转向灯。先抬离合器,后松刹车。 ­ ­ ...
  • (如根据若干url异步加载多张图片,然后在都下载完成后合成一张整) [※※※※]dispatch_barrier_async的作用是什么? [※※※※※]苹果为什么要废弃dispatch_get_current_queue? [※※※※※]以下代码...
  • 请大家脑补一下,把下面这灰度立体化之后,一块一块像地砖一样循环平铺以后,3D渲染出来的连绵起伏的直抵地平线(好吧,直抵远裁剪面)的山脉的壮观效果吧。 2. 可预测随机数和无限宇宙...
  • 包容性设计的具体例子:聋人导向可访问性 Claudia Savina Bianchini, Fabrizio Borgia, and Maria De Marsico 介绍 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 434
精华内容 173
关键字:

手动挡五个档位示意图