在高考数学里，空间直线与平面的平行有关的知识内容和题型，一直是近几年高考命题的热点，成为立体几何重要的基础考点。如何巧妙快速的判定空间直线与平面平行位置关系，如何在平面内寻找一条直线，探索该直线与平面平行等，这些问题一直是常见的热点问题。
  重点考查考生的空间想象能力、计算能力、推理论证能力，以及转化思想的应用。
  跟着包Sir一起来看看动态教辅里是如何来帮助大家学习这一部分知识的吧~
  小编乱入
  1
  互动启思
  
  
  题型1 直线的倾斜角与斜率、直线方程
  引言
  掌握基础知识，养成画图的习惯，培养平面几何的想象能力是解题的关键.
  例题1  经过点M(1，1)且在两坐标轴上截距相等的直线方程为(　　)
  A．x＋y－2＝0
  B．x＋y－1＝0
  C．x＝1或y＝1
  D．x＋y－2＝0或x－y＝0
  互动启思
  
  一点呈析
  答案: D
  解析: 当直线过原点时，满足题意，此时直线方程为
  
  ，即x－y＝0；当直线不过原点时，设直线方程为
  
  ，代入M(1，1)，解得a＝2，所以直线的方程为＋＝1，即x＋y－2＝0.综上所述，所求直线的方程为x＋y－2＝0或x－y＝0.故选
  例题2  已知直线l平分圆C：x2＋y2－6x＋6y＋2＝0的周长，且直线l不经过第三象限，则直线l的倾斜角θ的取值范围为(　　)
  
  互动启思
  
  一点呈析
  答案: A
  解析: 圆C：x2＋y2－6x＋6y＋2＝0的标准方程为(x－3)2＋(y＋3)2＝16，故直线l过圆C的圆心(3，－3)．因为直线l不经过第三象限，所以
  
  ，故选A.
  
  
  题型2 两条直线的位置关系
  引言
  经常会涉及到直线的平行和垂直问题，所以要注意直线平行、垂直的时候，直线的解析式所满足的条件，并且要特别注意不要多解.
  例题1 “m＝－1”是“直线mx＋(2m－1)y＋1＝0和直线3x＋my＋3＝0垂直”的   (　　)
  A．充分不必要条件
  B．必要不充分条件
  C．充要条件
  D．既不充分也不必要条件
  互动启思
  
  一点呈析
  答案：A
  解析：设p：m＝－1；q：直线mx＋(2m－1)y＋1＝0和直线3x＋my＋3＝0垂直．将m＝－1代入两直线方程，它们的斜率之积为－1，故两直线垂直，从而由p可以推出q；但当m＝0时，两直线也垂直，故由q不一定能推出p.因而p是q的充分不必要条件．故选A.
  例题2  已知直线l：
  
  ，M是l上一动点，过M作x轴、y轴的垂线，垂足分别为A，B，则在A，B连线上，且满足
  
  的点P的轨迹方程是             ．
  互动启思
  
  一点呈析
  答案：3x＋2y－4＝0
  解析：设P(x，y)为轨迹上任一点，A(a，0)，B(0，b)．
  ∵
  
  ，∴
  
  ∵点M在直线l上，∴
  
  ，
  整理得3x＋2y－4＝0，
  即3x＋2y－4＝0为点P的轨迹方程．
  2
  知识助攻
  
  
  1.直线的倾斜角和斜率
  (1)直线的倾斜角
  ①定义：平面直角坐标系中，对于一条与x轴相交的直线，把x轴所在的直线绕着交点按 逆 时针方向旋转到和直线重合时所转的 最小正角 α称为直线的倾斜角．规定：直线与x轴平行或重合时，直线的倾斜角为 0° 
  ②范围：倾斜角α的范围是  0°≤α<180°. 
  (2)直线的斜率
  ①定义：
  当直线的倾斜角α≠90°时，直线的倾斜角α的 正切值 叫做这条直线的斜率，常记作k＝ tanα ；
  当直线的倾斜角α＝90°时，直线的斜率 不存在 ．
  ②过两点的直线的斜率公式：
  过两点P1(x1，y1)，P2(x2，y2)(x1≠x2)的直线的斜率公式为k＝
  
  .
  若x1＝x2，则直线P1P2的倾斜角为90°，斜率不存在。
  ③范围：
  直线的斜率的范围为 R                                           .
  敲黑板
  (1)不要忽视“直线的斜率不存在”这一情况．在分析直线的倾斜角和斜率的关系时，要根据正切函数k＝tanα的单调性，如图所示．
  
  (2)由直线的斜率k求倾斜角α的取值范围时，要对应正切函数的图像来确定，并注意图像的不连续性和函数的定义域．如：由－1≤k≤1，得.
  
  
  2. 直线的方程
  (1) 直线的五种形式
  
  (2) 求直线方程常用的方法
  ①根据已知条件，设出适当的直线方程；
  ②把已知条件构造成含待定系数的方程(组)；
  ③求解待定系数；
  ④将求得的系数代入设出的直线方程．
  敲黑板
  若使用斜截式或点斜式设直线方程时，应先讨论斜率k是否存在．同理，在使用截距式前要讨论截距是否存在，是否为0.
  
  
  3.两条直线的位置关系
  (1)两条直线的位置关系
  直线l1：y＝k1x＋b1与l2：y＝k2x＋b2，
  直线l3：A1x＋B1y＋C1＝0与l4：A2x＋B2y＋C2＝0的位置关系如下表：
  
  (2)两条直线的交点坐标
  当两条直线相交时，两直线的方程联立的方程组的解即为交点坐标．
  (3)距离公式
  ①两点间的距离：
  平面上两点P1(x1，y1)，P2(x2，y2)之间的距离公式为|P1P2|＝
  ②点到直线的距离：
  平面上的点P(x0，y0)到直线l：Ax＋By＋C＝0的距离公式为d＝
  ③两条平行直线间的距离：
  直线l1：Ax＋By＋C1＝0与l2：Ax＋By＋C2＝0之间的距离公式为d＝
  
  
  
  4.两条直线平行与垂直的判定及应用
  (1)两条直线平行或垂直的判定方法
  <1>已知两直线的斜率一定存在
  ①两直线平行⇔两直线的斜率相等且在相应坐标轴上的截距不相等；
  ②两直线垂直⇔两直线的斜率之积为－1.
  <2>两直线的斜率可能不存在
  若两直线斜率不存在，当两直线在x轴上的截距不相等时，两直线平行；否则，两直线重合．
  若两直线中有一条直线的斜率不存在，另一条直线的斜率为0，则两直线互相垂直．
  <3>已知两直线的一般方程
  直接应用有关结论判定；也可利用直线方程求出斜率(或判定出斜率不存在)，转化为<1><2>中的情形进行判定．
  (2)两条直线平行与垂直的应用
  
根据直线的位置关系求参数值
  当直线方程中的系数含有参数时，参数的不同取值决定了直线的不同位置，因此应对参数的取值进行分类讨论，一般分为斜率存在和斜率不存在两种情况，再根据不同情况下应满足的关系，列式求解．或直接应用“知识划重点”中l3，l4所满足的条件列式求解．
  敲黑板
  根据位置关系转化为等量关系(不等关系)时，要注意等价性．如两直线平行⇔k1＝k2且b1≠b2(或A1B2－A2B1＝0且A1C2－A2C1≠0)，此时不要只得出k1＝k2(或A1B2－A2B1＝0)．另外，求出参数值时注意代回检验，避免产生增根．
  
根据直线的位置关系求解直线方程
  解答这类题通常有两种方法：
  ①根据l1∥l2⇒k1＝k2，l1⊥l2⇒k1·k2＝－1确定待求直线的斜率，再由点斜式得到直线的方程．
  ②由两直线平行(垂直)的方程特征设出方程，再由待定系数法求解．
  
  
  5.两条直线的交点与距离
  (1)求两直线的交点坐标
  设两条直线的方程为l1：A1x＋B1y＋C1＝0，l2：A2x＋B2y＋C2＝0，则方程组
  
  的解就是两条直线的交点坐标．
  ①若方程组有唯一解，则两条直线 相交 ，此解就是交点的坐标；
  ②若方程组无解，则两条直线 无公共点 ，此时两条直线 平行 ，反之亦成立．
  (2)距离公式的应用
  
求距离
  应用距离公式求解即可．
  敲黑板
  ①求点到直线的距离时，必须把直线方程化为一般式Ax＋By＋C＝0.
  ②求两条平行直线间的距离时，一定要把直线方程中x，y的系数化成一致的．
  
已知距离求有关方程或有关量
  借助距离公式首先建立方程(组)得出参数的值或满足的关系式，然后结合题中其他条件确定方程、点的坐标等．
  敲黑板
  若已知点到直线的距离求直线方程，用一般式可避免讨论．否则，应讨论斜率是否存在．
  
  
  6.对称问题
  (1) 点关于点对称
  若点A(x1，y1)和点B(x2，y2)关于点C(a，b)对称，则由中点坐标公式得
  
  从而可解．
  (2)直线关于点对称
  方法1：根据两对称直线平行，求出已知直线上任一点的对称点，由点斜式可求对称直线的方程；
  方法2：在已知直线上任取两点，分别求出两个对称点，由两点式可求得对称直线的方程.
  (3)点关于直线对称
  若点A(x1，y1)和点B(x2，y2)关于直线l：Ax＋By＋C＝0对称，则满足方程组
  
  进而求解
  (4)直线关于直线对称
  (1)若l1∥l2，l1与l2关于直线l对称，则可利用平行线间距离公式求解；
  (2)若l1∩l2＝A，l1与l2关于直线l对称，且点A在直线l上，求出直线l1上任一点关于直线l的对称点B，由 两点式 可求得对称直线的方程．
  敲黑板
  点关于点的对称是基本问题，也是各种对称问题可转化的最终问题．抓住两点：一是“垂直”，两对称点连线与对称轴垂直；二是“平分”，两对称点连线段的中点在对称轴上．
  声明：以上内容摘自包学习APP_动态教辅《 数学丨动态题型包 》，欢迎来包学习和更多小伙伴一起学习更多知识吧。
  
  
  点击
 
 

 
太阳高度与方向
 
背景
 
本文要解决日常生活中的如下疑问:
 
全球日出的方向角是一样还是不一样？
日出时，太阳的高度角为零度，但方向角又是多少呢？
北半球，春分与秋分那天，日出于正东，但正午太阳又偏正南方，太阳的轨迹又是怎样的？
知道日期与时间，你能预测，太阳的具体位置吗？
 
解答
 
全球日出时，太阳的方向角是一样的，因为太阳光平行的，与地区的纬线圈平面夹角是一样的。意味着太阳的方向角一样。
 
地球的自西向东旋转，可以理解成太阳的自东向西围绕。
 
春分或秋分日，可以看成太阳绕着纬线圈旋转，旋转平面与纬线平面重合。所以可以肯定的是，太阳的轨迹是一个圆弧。 
 那又怎样理解，在正午时太阳偏南方呢？ 
 圆弧有很多种可能画法，可以垂直于当地水平面，也可以与水平面形成一定夹角。
 
为什么会形成夹角呢？ 
 原因是，纬线圈平面并不是一个垂直于当地水平面的平面，除赤道以外，纬线圈与垂直平面有一定倾斜角，所以你看到的太阳，是在一个倾斜平面上作圆周运动。 
 此时，用当地纬度就可以确定倾斜平面，再使用当地时间，就可以定位圆周夹角，就可以确定太阳位置。
 
而对于非春分或秋分日，比如太阳直射北半球的时，情况会复杂一点。 
 对某一纬线圈，阳光是以一个倾角射入的，在地轴的相应交点上， 可以看成太阳在一个圆锥上运动，而纬线上的太阳光与该交点的太阳光方向是一样的，因为平行光的关系， 
 太阳的方位不受观察位置影响，也就是说在纬线上看，太阳也是在一个圆锥上运动。
 
春分或秋分日照示意图： 
 
 
北半球夏日日照示意图： 
 

原理：
 
现实中平行的直线会在照片中交于一点（完全水平的除外)，通过该交点和摄像机位置的连线即可确定摄像头偏离平行线的夹角，可以参考修改为检测小车航线角（偏离车道线的夹角）。
 
 
 效果图： 
 
 
第一版程序（有bug）
 
/**************************************************************************************
通过消失点测量 ：航向角
****************************************************************************************/


#pragma warning(disable:4996)

#include <stdio.h>  
#include <time.h>  
#include <math.h>  
#include <iostream> 
#include <io.h>
#include "windows.h"  
#include "fstream" 

//opencv相关
#include <opencv2/opencv.hpp>  
#include <opencv2/video.hpp>
#include <opencv2/imgproc/imgproc.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv/cv.h>  
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/ml/ml.hpp>  
#include <opencv2/objdetect/objdetect.hpp>//hog特征的c文件

//自己编写的文件
#include "UART.h"
#include "findline.h"
#include "DrawImage.h"//绘制图形
#include "Manipulator_positioning.h" //棋子挡板识别及定位
#include "Number.h"
#include "Locate.h"

using namespace std;
using namespace cv;
using namespace cv::ml;

RNG rng(12345);

using namespace cv;
using namespace std;

RNG g_rng(12345);

/*函数功能：求两条直线交点*/
/*输入：两条Vec4i类型直线*/
/*返回：Point2f类型的点*/
Point2f getCrossPoint(Vec4i LineA, Vec4i LineB)
{
    double ka, kb;
    ka = (double)(LineA[3] - LineA[1]) / (double)(LineA[2] - LineA[0]); //求出LineA斜率
    kb = (double)(LineB[3] - LineB[1]) / (double)(LineB[2] - LineB[0]); //求出LineB斜率

    Point2f crossPoint;
    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;
}

//输入一堆直线，返回每条直线与水平直线的角度，
//aaa为0则为弧度，反之则为角度
vector <float> get_lines_arctan(vector<Vec4i> lines,int aaa)
{
    if (aaa == 0)
    {
     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;
    }
    else
    {
        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((double)atan(k)* (double)180.0 / (double)3.1415926);
        }
        return lines_arctan;
    }
}

//输入一堆直线，返回每条直线的斜率和截距
//Vec2f为2个点的float，参照存储直线的数据结构
vector <Point2f> get_lines_fangcheng(vector<Vec4i> lines)
{
    float k = 0; //直线斜率
    float b = 0; //直线截距
    vector <Point2f> 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(Point2f(k,b));
    }

    return lines_fangcheng;
}

//原点到直线的距离
//输入一堆直线，返回直线到坐标原点的距离
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;

}


/***** 冒泡排序*****/
//输入一堆直线，按斜率排序，返回排序好的直线
vector<Vec4i> Pai_xu(vector<Vec4i> lines)
{ 
    vector<float> lines_temp;
    float t1;
    lines_temp = get_lines_arctan(lines, 1);
    Vec4i t;
    printf("此程序使用冒泡排序法排列无序数列！\n");

    //冒泡排序  
    for (int i = 0; i<lines.size() - 1; i++)//n个数的数列总共扫描n-1次  
    {
        for (int j = 0; j<lines.size() - i - 1; j++)//每一趟扫描到a[n-i-2]与a[n-i-1]比较为止结束  
        {
            if (lines_temp[j]<lines_temp[j + 1])//后一位数比前一位数大的话，就交换两个数的位置（降序）  
            {
                t=lines[j + 1];
                t1 = lines_temp[j + 1];

                lines[j + 1] = lines[j];
                lines_temp[j + 1] = lines_temp[j];

                lines[j] = t;
                lines_temp[j] = t1;
            }
        }   
    }
    return lines;
}





//-----------------------------------【main( )函数】--------------------------------------------
//      描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main()
{   
    //【1】载入原始图和Mat变量定义   
    Mat srcImage = imread("11.jpg");  //工程目录下应该有一张名为1.jpg的素材图
    Mat midImage, dstImage;//临时变量和目标图的定义

    //彩色转灰度
    cv::cvtColor(srcImage, srcImage, CV_BGR2GRAY);
    cv::namedWindow("灰度化", 0);
    imshow("灰度化", srcImage);

    //二值化
    threshold(srcImage, srcImage, 150, 255, THRESH_BINARY);
    cv::namedWindow("二值化", 0);
    imshow("二值化", srcImage);
    //模糊
    cv::blur(srcImage, srcImage, cv::Size(3, 3));
    cv::namedWindow("模糊", 0);
    imshow("模糊", srcImage);

    /*******  检测直线优化 开始 ****************************************************************/
     int cannyThreshold = 80;
    float factor = 2.5;


    vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    //HoughLinesP(midImage, lines, 1, CV_PI / 180, 320, 240, 30);
    Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);
    HoughLinesP(midImage, lines, 1, CV_PI / 180, 300, 200, 50);
    //最多的直线
    while (lines.size() >= 16)
    {
        cannyThreshold += 2;
        Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);


        HoughLinesP(midImage, lines, 1, CV_PI / 180, 50, 100, 100);
    }
    //最少的直线
    while (lines.size() <= 10)
    {
        cannyThreshold -= 2;
        Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);
        HoughLinesP(midImage, lines, 1, CV_PI / 180, 300, 200, 50);
    }

    cout << "canny边缘检测阈值为:" << cannyThreshold << endl;

    Canny(srcImage, midImage,cannyThreshold,cannyThreshold * factor);
    HoughLinesP(midImage, lines, 1, CV_PI / 180, 300, 200, 50);

    /*******  检测直线优化 结束 ****************************************************************/




    //【2】进行边缘检测和转化为灰度图
//  Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测

    cvtColor(midImage, dstImage, COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图

    //【3】进行霍夫线变换
    //vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    //HoughLinesP(midImage, lines, 1, CV_PI / 180, 320, 240, 30);

    printf("\n\n\t\t\t   当前使用的OpenCV版本为" CV_VERSION);
    cout << "\n共检测到原始  直线" << lines.size() << "条" << endl;


    //这里是将检测的线调整到延长至全屏，即射线的效果，其实可以不必这么做 
    for (unsigned int i = 0; i<lines.size(); i++)
    {
        cv::Vec4i v = lines[i];
        lines[i][0] = 0;
        lines[i][1] = ((float)v[1] - v[3]) / (v[0] - v[2])* -v[0] + v[1];
        lines[i][2] = midImage.cols;
        lines[i][3] = ((float)v[1] - v[3]) / (v[0] - v[2])*(midImage.cols - v[2]) + v[3];
    }

    //【4】依次在图中绘制出每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        Vec4i l = lines[i];
        //此句代码的OpenCV2版为：
        //line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, CV_AA);
        //此句代码的OpenCV3版为：
        line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 1, LINE_AA);
    }

    //显示每条直线的角度
    vector <float> lines_arctan;//直线斜率的反正切值,即角度
    lines_arctan = get_lines_arctan(lines,0);//0为弧度,1为角度

    for (unsigned int i = 0; i < lines.size(); i++)
    {
        cout << "检测到的直线弧度" << lines_arctan[i] << endl;
        cout << "检测到的直线角度为：" << lines_arctan[i] *180.0/3.1415926<< endl;
    }

    //显示每条直线的方程
    vector <Point2f> lines_fangcheng;//直线斜率的反正切值
    lines_fangcheng = get_lines_fangcheng(lines);

    for (unsigned int i = 0; i < lines.size(); i++)
    {
        cout << "\n" << endl;
        cout << "检测到的直线斜率为" << lines_fangcheng[i].x << endl;
        cout << "检测到的直线截距为：" << lines_fangcheng[i].y<< endl;
    }

    /****************确定自己在哪两条直线中间，并把这两条直线找出来   开始 *********************************************************************/

    vector<Vec4i> lines_1;//排序后的数组
    vector<Vec4i> lines_2;//两个斜率最大的直线
    printf("此程序使用冒泡排序法排列无序数列！\n");
    lines_1 = Pai_xu(lines);//按斜率排序

    vector <float> lines_arctan1;//直线斜率的反正切值,即角度
    lines_arctan1 = get_lines_arctan(lines_1, 1);//0为弧度,1为角度


    printf("排列好的直线斜率是：\n");
        //输出排列好的数列  
    for (int i = 0; i<lines_1.size(); i++)
        {
        cout << "检测到的直线斜率为:" << lines_arctan1[i]<< " 度"<<endl;
        }

        lines_2.push_back(lines_1[0]);
        lines_2.push_back(lines_1[lines_1.size()-1]);
        for (int i = 0; i < lines_2.size(); i++)
        {
            line(dstImage, Point(lines_2[i][0], lines_2[i][1]), Point(lines_2[i][2], lines_2[i][3]), Scalar(255, 0,0), 2, LINE_AA);
        }



    /****************确定自己在哪两条直线中间，并把这两条直线找出来  结束 *********************************************************************/



    /****************找到消失点  开始 *********************************************************************/

        Point2f Xiaoshidian;//线的交点存储  
        Xiaoshidian = getCrossPoint(lines_2[0], lines_2[1]);//消失点
        float H1 = 44.0;//摄像头高度
        float Dmin = 25;//最短距离
        float Dmax = 250;//最长距离
        float D1 = 29.8;//摄像头坐标与水平面线交点差值

        float Alpha;//俯仰角Αα：阿尔法 Alpha
        float Theta;//垂直视场角 西塔 Theta

        Alpha = atan(Dmin / H1);//俯仰角
        Theta = atan(Dmax / H1) - Alpha;//垂直视场角
        //视场中轴线
        line(dstImage, Point(dstImage.cols / 2,0 ), Point(dstImage.cols / 2, dstImage.rows), Scalar(255, 0, 0), 3, LINE_AA);

        //与直线平行的地方
        line(dstImage, Point(Xiaoshidian.x, Xiaoshidian.y), Point(dstImage.cols / 2, dstImage.rows*(1 + Alpha / Theta)), Scalar(255, 0, 255), 3, LINE_AA);






    /****************找到消失点  开始 *********************************************************************/





    vector<Point2f> corners;//线的交点存储  
    for (unsigned int i = 0; i<lines.size(); i++)
    {
        for (unsigned int j = i + 1; j<lines.size(); j++)
        {
            cv::Point2f pt = getCrossPoint(lines[i], lines[j]);
            if (pt.x >= 0 && pt.y >= 0)
            {
                corners.push_back(pt);
            }
        }
    }

    //【4】依次在图中绘制出角点
    for (size_t i = 0; i < corners.size(); i++)
    {
      circle(dstImage, corners[i], 3, CV_RGB(0, 255, 0), 2);
    }
    //【5】显示原始图  
    namedWindow("【原始图】", 0);//参数为零，则可以自由拖动
    imshow("【原始图】", srcImage);

    //【6】边缘检测后的图 
    namedWindow("【边缘检测后的图】", 0);//参数为零，则可以自由拖动
    imshow("【边缘检测后的图】", midImage);

    //【7】显示效果图  
    namedWindow("【效果图】", 0);//参数为零，则可以自由拖动
    imshow("【效果图】", dstImage);

    waitKey(0);

}




 
第二版程序（优化了很多）8月9日写
 
 
/**************************************************************************************
该程序功能：找航向角，通过消失点找航向角


****************************************************************************************/
/**************************************************************************************
通过消失点测量 ：航向角
****************************************************************************************/


#pragma warning(disable:4996)

#include <stdio.h>  
#include <time.h>  
#include <math.h>  
#include <iostream> 
#include <io.h>
#include "windows.h"  
#include "fstream" 

//opencv相关
#include <opencv2/opencv.hpp>  
#include <opencv2/video.hpp>
#include <opencv2/imgproc/imgproc.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv/cv.h>  
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/ml/ml.hpp>  
#include <opencv2/objdetect/objdetect.hpp>//hog特征的c文件

//自己编写的文件
#include "UART.h"
#include "findline.h"
#include "DrawImage.h"//绘制图形
#include "Manipulator_positioning.h" //棋子挡板识别及定位
#include "Number.h"
#include "Locate.h"

using namespace std;
using namespace cv;
using namespace cv::ml;

RNG rng(12345);

using namespace cv;
using namespace std;

RNG g_rng(12345);

/*函数功能：求两条直线交点*/
/*输入：两条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;
}

//输入一堆直线，返回每条直线与水平直线的角度，
//aaa为0则为弧度，反之则为角度
//
vector <float> get_lines_arctan(vector<Vec4i> lines, int aaa)
{
    if (aaa == 0)
    {
        float k = 0; //直线斜率
        vector <float> lines_arctan;//直线斜率的反正切值

        for (unsigned int i = 0; i<lines.size(); i++)
        {
            if ((lines[i][2] - lines[i][0]) != 0)
            {

                k = -(double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率
                lines_arctan.push_back(atan(k));

            }
            else
            {
                lines_arctan.push_back(8000); //8000表示无穷大
            }
        }
        return lines_arctan;
    }
    else
    {
        float k = 0; //直线斜率
        vector <float> lines_arctan;//直线斜率的反正切值
        for (unsigned int i = 0; i<lines.size(); i++)
        {
            if ((lines[i][2] - lines[i][0]) != 0)
            {
                k = -(double)(lines[i][3] - lines[i][1]) / (double)(lines[i][2] - lines[i][0]); //求出直线的斜率
                lines_arctan.push_back((double)atan(k)* (double)180.0 / (double)3.1415926);
            }
            else
            {
                lines_arctan.push_back(90);
            }       
        }
        return lines_arctan;
    }
}

//输入一堆直线，返回每条直线的斜率和截距
//Vec2f为2个点的float，参照存储直线的数据结构
//如果直线未垂直的话，返回斜率和截距都为8000
vector <Point2f> get_lines_fangcheng(vector<Vec4i> lines)
{
    float k = 0; //直线斜率
    float b = 0; //直线截距
    vector <Point2f> lines_fangcheng;//直线斜率的反正切值

    for (unsigned int i = 0; i<lines.size(); i++)
    {
        if ((lines[i][2] - lines[i][0]) != 0)
        {
            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(Point2f(k, b));
        }
        else
        {
            lines_fangcheng.push_back(Point2f(8000, 8000)); //直线未竖直的，则返回斜率和截距都为8000

        }
    }

    return lines_fangcheng;
}

//原点到直线的距离
//输入一堆直线，返回直线到坐标原点的距离
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;

}


/***** 冒泡排序*****/
//输入一堆直线，按斜率排序，返回排序好的直线
vector<Vec4i> Pai_xu(vector<Vec4i> lines)
{
    vector<float> lines_temp;
    float t1;
    lines_temp = get_lines_arctan(lines, 1);
    Vec4i t;

    //冒泡排序  
    for (int i = 0; i<lines.size() - 1; i++)//n个数的数列总共扫描n-1次  
    {
        for (int j = 0; j<lines.size() - i - 1; j++)//每一趟扫描到a[n-i-2]与a[n-i-1]比较为止结束  
        {
            if (lines_temp[j]<lines_temp[j + 1])//后一位数比前一位数大的话，就交换两个数的位置（降序）  
            {
                t = lines[j + 1];
                t1 = lines_temp[j + 1];

                lines[j + 1] = lines[j];
                lines_temp[j + 1] = lines_temp[j];

                lines[j] = t;
                lines_temp[j] = t1;
            }
        }
    }
    return lines;
}

//-----------------------------------【main( )函数】--------------------------------------------
//      描述：控制台应用程序的入口函数，我们的程序从这里开始
//-----------------------------------------------------------------------------------------------
int main()
{
    //【1】载入原始图和Mat变量定义   
    Mat srcImage = imread("14.jpg");  //工程目录下应该有一张名为1.jpg的素材图
    Mat midImage, dstImage;//临时变量和目标图的定义

    //彩色转灰度
    cv::cvtColor(srcImage, srcImage, CV_BGR2GRAY);
    cv::namedWindow("灰度化", 0);
    imshow("灰度化", srcImage);

    //二值化
    threshold(srcImage, srcImage, 150, 255, THRESH_BINARY);
    cv::namedWindow("二值化", 0);
    imshow("二值化", srcImage);
    //模糊
    cv::blur(srcImage, srcImage, cv::Size(3, 3));
    cv::namedWindow("模糊", 0);
    imshow("模糊", srcImage);

    /*******  检测直线优化 开始 ****************************************************************/
    int cannyThreshold = 80;
    float factor = 2.5;


    vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    //HoughLinesP(midImage, lines, 1, CV_PI / 180, 320, 240, 30);
    Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);
    HoughLinesP(midImage, lines, 1, CV_PI / 180, 260, 100, 100);


    //最多的直线
    //while (lines.size() >= 16)
    //{
    //  cannyThreshold += 2;
    //  Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);


    //  HoughLinesP(midImage, lines, 1, CV_PI / 180, 50, 100, 100);
    //}
    最少的直线
    //while (lines.size() <= 10)
    //{
    //  cannyThreshold -= 2;
    //  Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);
    //  HoughLinesP(midImage, lines, 1, CV_PI / 180, 300, 200, 50);
    //}

    cout << "canny边缘检测阈值为:" << cannyThreshold << endl;

    //Canny(srcImage, midImage, cannyThreshold, cannyThreshold * factor);
    //HoughLinesP(midImage, lines, 1, CV_PI / 180, 300, 200, 50);

    /*******  检测直线优化 结束 ****************************************************************/




    //【2】进行边缘检测和转化为灰度图
    //  Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测

    cvtColor(midImage, dstImage, COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图

    //【3】进行霍夫线变换 
    //vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
    //HoughLinesP(midImage, lines, 1, CV_PI / 180, 320, 240, 30);

    printf("\n\n\t\t\t   当前使用的OpenCV版本为" CV_VERSION);
    cout << "\n共检测到原始  直线" << lines.size() << "条" << endl;


    //这里是将检测的线调整到延长至全屏，即射线的效果，其实可以不必这么做 
    //for (unsigned int i = 0; i<lines.size(); i++)
    //{
    //  cv::Vec4i v = lines[i];
    //  lines[i][0] = 0;
    //  lines[i][1] = ((float)v[1] - v[3]) / (v[0] - v[2])* -v[0] + v[1];
    //  lines[i][2] = midImage.cols;
    //  lines[i][3] = ((float)v[1] - v[3]) / (v[0] - v[2])*(midImage.cols - v[2]) + v[3];
    //}

    //【4】依次在图中绘制出每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        Vec4i l = lines[i];
        //此句代码的OpenCV2版为：
        //line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, CV_AA);
        //此句代码的OpenCV3版为：
        line(dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 1, LINE_AA);
    }

    //显示每条直线的角度
    vector <float> lines_arctan;//直线斜率的反正切值,即角度
    lines_arctan = get_lines_arctan(lines, 1);//0为弧度,1为角度

    for (unsigned int i = 0; i < lines.size(); i++)
    {
    //  cout << "检测到的直线弧度" << lines_arctan[i] << endl;
        cout << "检测到的直线角度为：" << lines_arctan[i] << endl;
    }

    //显示每条直线的方程
    //vector <Point2f> lines_fangcheng;//直线斜率的反正切值
    //lines_fangcheng = get_lines_fangcheng(lines);

    //for (unsigned int i = 0; i < lines.size(); i++)
    //{
    //  cout << "\n" << endl;
    //  cout << "检测到的直线斜率为" << lines_fangcheng[i].x << endl;
    //  cout << "检测到的直线截距为：" << lines_fangcheng[i].y << endl;
    //}

    /****************确定自己在哪两条直线中间，并把这两条直线找出来   开始 *********************************************************************/

    vector<Vec4i> lines_1;//排序后的数组
    vector<Vec4i> lines_2;//滤除小于45度的直线
    vector<Vec4i> lines_3;//两个斜率最大的直线
    printf("此程序使用冒泡排序法排列无序数列！\n");
    lines_1 = Pai_xu(lines);//按斜率排序

    vector <float> lines_arctan1, lines_arctan2;//直线斜率的反正切值,即角度
    lines_arctan1 = get_lines_arctan(lines_1, 1);//0为弧度,1为角度


    printf("排列好的第一次直线角度是：\n");
    //输出排列好的数列  
    for (int i = 0; i<lines_1.size(); i++)
    {
        cout << "检测到的直线角度为:" << lines_arctan1[i] << " 度" << endl;
        if (fabs(lines_arctan1[i])>40)
        {
            lines_2.push_back(lines_1[i]);
        }

    }

    lines_arctan2 = get_lines_arctan(lines_2, 1);//0为弧度,1为角度

    printf("排列好的第二次直线角度是：\n");
    for (int i = 0; i < lines_2.size(); i++)
    {
        cout << "检测到的直线角度为:" << lines_arctan2[i] << " 度" << endl;
    }

    if (lines_2.size() >= 2)
    {

        lines_3.push_back(lines_2[0]);
        lines_3.push_back(lines_1[lines_2.size() - 1]);
    }
    else
    {
        cout << "滤除后的直线个数不够"<< endl;
    //  continue;
    }


    //将最后计算用到的两条直线显示出来
    for (int i = 0; i < lines_3.size(); i++)
    {
        line(dstImage, Point(lines_3[i][0], lines_3[i][1]), Point(lines_3[i][2], lines_3[i][3]), Scalar(255, 255, 0), 2, LINE_AA);
    }



    /****************确定自己在哪两条直线中间，并把这两条直线找出来  结束 *********************************************************************/

    /****************找到消失点  开始 *********************************************************************/
    Point2f Xiaoshidian;//线的交点存储  
    Xiaoshidian = getCrossPoint(lines_3[0], lines_3[1]);//消失点
    float H1 = 44.0;//摄像头高度
    float Dmin = 25;//最短距离
    float Dmax = 250;//最长距离
    float D1 = 29.8;//摄像头坐标与水平面线交点差值

    float Alpha;//俯仰角Αα：阿尔法  Alpha
    float Theta;//垂直视场角 西塔 Theta

    Alpha = atan(Dmin / H1);//俯仰角
    Theta = atan(Dmax / H1) - Alpha;//垂直视场角
    //视场中轴线
    line(dstImage, Point(dstImage.cols / 2, 0), Point(dstImage.cols / 2, dstImage.rows), Scalar(255, 0, 0), 3, LINE_AA);

    //与直线平行的地方
    line(dstImage, Point(Xiaoshidian.x, Xiaoshidian.y), Point(dstImage.cols / 2, dstImage.rows*(1 + Alpha / Theta)), Scalar(255, 0, 255), 3, LINE_AA);

    /****************找到消失点  结束 *********************************************************************/

    //vector<Point2f> corners;//线的交点存储  
    //for (unsigned int i = 0; i<lines.size(); i++)
    //{
    //  for (unsigned int j = i + 1; j<lines.size(); j++)
    //  {
    //      cv::Point2f pt = getCrossPoint(lines[i], lines[j]);
    //      if (pt.x >= 0 && pt.y >= 0)
    //      {
    //          corners.push_back(pt);
    //      }
    //  }
    //}
    【4】依次在图中绘制出角点
    //for (size_t i = 0; i < corners.size(); i++)
    //{
    //  circle(dstImage, corners[i], 3, CV_RGB(0, 255, 0), 2);
    //}
    //【5】显示原始图  
    namedWindow("【原始图】", 0);//参数为零，则可以自由拖动
    imshow("【原始图】", srcImage);

    //【6】边缘检测后的图 
    namedWindow("【边缘检测后的图】", 0);//参数为零，则可以自由拖动
    imshow("【边缘检测后的图】", midImage);

    //【7】显示效果图  
    namedWindow("【效果图】", 0);//参数为零，则可以自由拖动
    imshow("【效果图】", dstImage);

    waitKey(0);

}

偶然在网上看到一道有意思的几何题，仔细思考了一下，确实有点趣。
 
原题是：平面上有任意三条平行线，使用尺规则作图画出一个等边三角形，使三角形的三个顶点分别在三条平行线上。
 
画法有好多种，搜集网上的一些画法，先介绍4种，再讨论一下三角形连长与平等线距离的关系，最后讨论下第二种画法的变化（三角形边长的唯一性未证明）。
 
第一种：
 

 作图顺序：（颜色顺序：红—>绿—>蓝—>紫）
 1.在三条直线上的中间直线上任选两点，O与A。
 2.分别以O,A为圆心，OA为半径作圆，交于P，Q两点。
 3.连接PA并延长，交直线L3于D；连接QA并延长，交直线L1于E。
 4.于E点作EC平行于PD，交L3于C；于点D作DB平行于QE交L1于B。
 5.连接AB，BC，CA。
 证明：
 连接DE（辅助线）//仔细观察等腰梯形，其中有全等三角形。
 △CDE≌△DCB　＝＞　CB=DE
 △DAE≌△BEA ＝＞ AB=ED
 △CDA≌△EAD ＝＞ AC=DE
 CB=AB=AC=DE ＝＞ △ABC为等边三角形
 
第二种：
 

 作图顺序：（颜色顺序：红—>绿—>蓝—>紫）
 1.在最上方直线上任取一点A，作垂直于L1的垂线交L2，L3分别于S，T。
 2.以A点为圆心，将三条直线绕点A旋转60度，得到三条新的直线L1’，L2’，L3。（交点如上图所示）
 3.以AT为中心线，作L2’的对称线交L3于点C。
 4.连接AB，BC，CA。
 证明：
 △PQE为等边三角形（旋转三条直线60度，三个角均为60度。），△APR也为等边三角形。△ABC为△PQE的一个内接三角形。
 △CPA≌△ABE≌△BCQ => CA=AB=BC => △ABC为等边三角形。
 
第三种：
 

 作图顺序：（颜色顺序：红—>绿—>蓝—>紫）
 1.在L3上任取一点A，作AT垂直于L3交L1，L2分别于T，S。
 2.分别以S，T为圆心，ST为半径作两个圆交于D，E两点。
 3.连接AD。
 4.于点D作直线垂直于AD交L1，L2分别于C，B。
 5.连接AB，BC，CA。
 证明：略（可结合第二种方法证明）。
 
第四种：
 

 作图顺序：（颜色顺序：红—>绿—>蓝—>紫—>青—>棕）
 1.在直线L1上任取一点A。
 2.过A点作垂直于L1的垂线交L2，L3分别于S，T。
 3.作直线L4，L4为L1，L2的中位线，交AT于点D。
 4.于点T作直线，交L4于点E，使∠ETA=30°。
 5.连接AE并延长交L2于点B。
 6.以A为圆心，AB为半径作圆，交L3于点C。
 7.连接AC，CB。
 证明：略（连接ES，计算AB/2=AE=ES的长度与m，n的关系，余弦定理得到AE2=2/3(m2+n2+mn)，再结合第二种画法证明)。
 
等边三角形连长与直线距离m,n的关系。
 

 设等边三角形边长为p，在△AEB中，通过余弦定理可以得到：p2=4/3(m2+n2+mn)。
 现在开始总结一下所有画法，就是先找出这个关于m，n算式长度的一条线段，那么画图也就算结束了。
 
关于第二种画法的变化
 
可以将画等边三角形改为画等腰直角三角形。
 
 先旋转直线，再作L2的对称线。
 证明：略（一个全等三角形就证明了）。
 
下面看一下旋转任意角度θ，结果如何？
 
 ∠CAB=?
 连接AG，根据对称与旋转产生的全等三角形得到α+β+θ＝90°，从而得到∠CAB=θ。也就是说，旋转对称后得到一个顶角为θ的等腰三角形。三角形ABC腰长设为p，p2=csc2θ((m+n)2+n2-2(m+n)n*cosθ)。