#include "cmvcamera.h"
#include <QDebug>

CMvCamera* CMvCamera::uniqueInstance = nullptr;
CMvCamera* CMvCamera::instance()
{
    if (!uniqueInstance) {
        uniqueInstance = new CMvCamera();
    }
    return uniqueInstance;
}

CMvCamera::CMvCamera()
{
    m_hDevHandle = MV_NULL;
    InitializeCriticalSection(&mCsRead);
    getCameraPara("CameraPara");//CameraPara
}

CMvCamera::~CMvCamera()
{
    if (m_hDevHandle)
    {
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle    = MV_NULL;
    }
}

// ch:获取SDK版本号 | en:Get SDK Version
int CMvCamera::GetSDKVersion()
{
    return MV_CC_GetSDKVersion();
}

// ch:枚举设备 | en:Enumerate Device
int CMvCamera::EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList)
{
    return MV_CC_EnumDevices(nTLayerType, pstDevList);
}

// ch:判断设备是否可达 | en:Is the device accessible
bool CMvCamera::IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode)
{
    return MV_CC_IsDeviceAccessible(pstDevInfo, nAccessMode);
}

// ch:打开设备 | en:Open Device
int CMvCamera::Open(MV_CC_DEVICE_INFO* pstDeviceInfo)
{
    if (MV_NULL == pstDeviceInfo)
    {
        return MV_E_PARAMETER;
    }

    if (m_hDevHandle)
    {
        return MV_E_CALLORDER;
    }

    int nRet  = MV_CC_CreateHandle(&m_hDevHandle, pstDeviceInfo);
    if (MV_OK != nRet)
    {
        return nRet;
    }

    nRet = MV_CC_OpenDevice(m_hDevHandle);
    if (MV_OK != nRet)
    {
        MV_CC_DestroyHandle(m_hDevHandle);
        m_hDevHandle = MV_NULL;
    }

    return nRet;
}

// ch:关闭设备 | en:Close Device
int CMvCamera::Close()
{
    if (MV_NULL == m_hDevHandle)
    {
        return MV_E_HANDLE;
    }

    MV_CC_CloseDevice(m_hDevHandle);

    int nRet = MV_CC_DestroyHandle(m_hDevHandle);
    m_hDevHandle = MV_NULL;

    return nRet;
}

// ch:判断相机是否处于连接状态 | en:Is The Device Connected
bool CMvCamera::IsDeviceConnected()
{
    return MV_CC_IsDeviceConnected(m_hDevHandle);
}

// ch:注册图像数据回调 | en:Register Image Data CallBack
int CMvCamera::RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser)
{
    return MV_CC_RegisterImageCallBackEx(m_hDevHandle, cbOutput, pUser);
}

// ch:开启抓图 | en:Start Grabbing
int CMvCamera::StartGrabbing()
{
    return MV_CC_StartGrabbing(m_hDevHandle);
}

// ch:停止抓图 | en:Stop Grabbing
int CMvCamera::StopGrabbing()
{
    return MV_CC_StopGrabbing(m_hDevHandle);
}

// ch:主动获取一帧图像数据 | en:Get one frame initiatively
int CMvCamera::GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec)
{
    return MV_CC_GetImageBuffer(m_hDevHandle, pFrame, nMsec);
}

// ch:释放图像缓存 | en:Free image buffer
int CMvCamera::FreeImageBuffer(MV_FRAME_OUT* pFrame)
{
    return MV_CC_FreeImageBuffer(m_hDevHandle, pFrame);
}

// ch:设置显示窗口句柄 | en:Set Display Window Handle
int CMvCamera::DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo)
{
    return MV_CC_DisplayOneFrame(m_hDevHandle, pDisplayInfo);
}

// ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image cache nodes in SDK
int CMvCamera::SetImageNodeNum(unsigned int nNum)
{
    return MV_CC_SetImageNodeNum(m_hDevHandle, nNum);
}

// ch:获取设备信息 | en:Get device information
int CMvCamera::GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo)
{
    return MV_CC_GetDeviceInfo(m_hDevHandle, pstDevInfo);
}

// ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
int CMvCamera::GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect)
{
    if (MV_NULL == pMatchInfoNetDetect)
    {
        return MV_E_PARAMETER;
    }

    MV_CC_DEVICE_INFO stDevInfo = {0};
    GetDeviceInfo(&stDevInfo);
    if (stDevInfo.nTLayerType != MV_GIGE_DEVICE)
    {
        return MV_E_SUPPORT;
    }

    MV_ALL_MATCH_INFO struMatchInfo = {0};

    struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT;
    struMatchInfo.pInfo = pMatchInfoNetDetect;
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));

    return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
}

// ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
int CMvCamera::GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect)
{
    if (MV_NULL == pMatchInfoUSBDetect)
    {
        return MV_E_PARAMETER;
    }

    MV_CC_DEVICE_INFO stDevInfo = {0};
    GetDeviceInfo(&stDevInfo);
    if (stDevInfo.nTLayerType != MV_USB_DEVICE)
    {
        return MV_E_SUPPORT;
    }

    MV_ALL_MATCH_INFO struMatchInfo = {0};

    struMatchInfo.nType = MV_MATCH_TYPE_USB_DETECT;
    struMatchInfo.pInfo = pMatchInfoUSBDetect;
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_USB_DETECT);
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_USB_DETECT));

    return MV_CC_GetAllMatchInfo(m_hDevHandle, &struMatchInfo);
}

// ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Int type parameters, such as Width and Height, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX *pIntValue)
{
    return MV_CC_GetIntValueEx(m_hDevHandle, strKey, pIntValue);
}

int CMvCamera::SetIntValue(IN const char* strKey, IN int64_t nValue)
{
    return MV_CC_SetIntValueEx(m_hDevHandle, strKey, nValue);
}

// ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Enum type parameters, such as PixelFormat, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE *pEnumValue)
{
    return MV_CC_GetEnumValue(m_hDevHandle, strKey, pEnumValue);
}

int CMvCamera::SetEnumValue(IN const char* strKey, IN unsigned int nValue)
{
    return MV_CC_SetEnumValue(m_hDevHandle, strKey, nValue);
}

int CMvCamera::SetEnumValueByString(IN const char* strKey, IN const char* sValue)
{
    return MV_CC_SetEnumValueByString(m_hDevHandle, strKey, sValue);
}

int CMvCamera::GetEnumEntrySymbolic(IN const char* strKey, IN MVCC_ENUMENTRY* pstEnumEntry)
{
    return MV_CC_GetEnumEntrySymbolic(m_hDevHandle, strKey, pstEnumEntry);
}

// ch:获取和设置Float型参数，如 ExposureTime和Gain，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Float type parameters, such as ExposureTime and Gain, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE *pFloatValue)
{
    return MV_CC_GetFloatValue(m_hDevHandle, strKey, pFloatValue);
}

int CMvCamera::SetFloatValue(IN const char* strKey, IN float fValue)
{
    return MV_CC_SetFloatValue(m_hDevHandle, strKey, fValue);
}

// ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Get Bool type parameters, such as ReverseX, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetBoolValue(IN const char* strKey, OUT bool *pbValue)
{
    return MV_CC_GetBoolValue(m_hDevHandle, strKey, pbValue);
}

int CMvCamera::SetBoolValue(IN const char* strKey, IN bool bValue)
{
    return MV_CC_SetBoolValue(m_hDevHandle, strKey, bValue);
}

// ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件UserSetSave
// en:Get String type parameters, such as DeviceUserID, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::GetStringValue(IN const char* strKey, MVCC_STRINGVALUE *pStringValue)
{
    return MV_CC_GetStringValue(m_hDevHandle, strKey, pStringValue);
}

int CMvCamera::SetStringValue(IN const char* strKey, IN const char* strValue)
{
    return MV_CC_SetStringValue(m_hDevHandle, strKey, strValue);
}

// ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
// en:Execute Command once, such as UserSetSave, for details please refer to MvCameraNode.xlsx file under SDK installation directory
int CMvCamera::CommandExecute(IN const char* strKey)
{
    return MV_CC_SetCommandValue(m_hDevHandle, strKey);
}

// ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
int CMvCamera::GetOptimalPacketSize(unsigned int* pOptimalPacketSize)
{
    if (MV_NULL == pOptimalPacketSize)
    {
        return MV_E_PARAMETER;
    }

    int nRet = MV_CC_GetOptimalPacketSize(m_hDevHandle);
    if (nRet < MV_OK)
    {
        return nRet;
    }

    *pOptimalPacketSize = (unsigned int)nRet;

    return MV_OK;
}

// ch:注册消息异常回调 | en:Register Message Exception CallBack
int CMvCamera::RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser),void* pUser)
{
    return MV_CC_RegisterExceptionCallBack(m_hDevHandle, cbException, pUser);
}

// ch:注册单个事件回调 | en:Register Event CallBack
int CMvCamera::RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO * pEventInfo, void* pUser), void* pUser)
{
    return MV_CC_RegisterEventCallBackEx(m_hDevHandle, pEventName, cbEvent, pUser);
}

// ch:强制IP | en:Force IP
int CMvCamera::ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay)
{
    return MV_GIGE_ForceIpEx(m_hDevHandle, nIP, nSubNetMask, nDefaultGateWay);
}

// ch:配置IP方式 | en:IP configuration method
int CMvCamera::SetIpConfig(unsigned int nType)
{
    return MV_GIGE_SetIpConfig(m_hDevHandle, nType);
}

// ch:设置网络传输模式 | en:Set Net Transfer Mode
int CMvCamera::SetNetTransMode(unsigned int nType)
{
    return MV_GIGE_SetNetTransMode(m_hDevHandle, nType);
}

// ch:像素格式转换 | en:Pixel format conversion
int CMvCamera::ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam)
{
    return MV_CC_ConvertPixelType(m_hDevHandle, pstCvtParam);
}

// ch:保存图片 | en:save image
int CMvCamera::SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam)
{
    return MV_CC_SaveImageEx2(m_hDevHandle, pstParam);
}

// ch:保存图片为文件 | en:Save the image as a file
int CMvCamera::SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstSaveFileParam)
{
    return MV_CC_SaveImageToFile(m_hDevHandle, pstSaveFileParam);
}

// ch:绘制圆形辅助线 | en:Draw circle auxiliary line
int CMvCamera::DrawCircle(MVCC_CIRCLE_INFO* pCircleInfo)
{
    return MV_CC_DrawCircle(m_hDevHandle, pCircleInfo);
}

// ch:绘制线形辅助线 | en:Draw lines auxiliary line
int CMvCamera::DrawLines(MVCC_LINES_INFO* pLinesInfo)
{
    return MV_CC_DrawLines(m_hDevHandle, pLinesInfo);
}

// 读取buffer
int CMvCamera::ReadBuffer(Mat &image)
{
    Mat* getImage = new Mat();
    unsigned int nRecvBufSize = 0;
    MVCC_INTVALUE stParam;
    memset(&stParam, 0,sizeof(MVCC_INTVALUE));
    int tempValue = MV_CC_GetIntValue(m_hDevHandle,"PayloadSize",&stParam);
    if(tempValue != 0)
    {
        return -1;
    }

    nRecvBufSize = stParam.nCurValue;
    unsigned char* pDate;
    pDate = (unsigned char *)malloc(nRecvBufSize);

    MV_FRAME_OUT_INFO_EX stImageInfo = {0};
    tempValue = MV_CC_GetOneFrameTimeout(m_hDevHandle,pDate, nRecvBufSize, &stImageInfo, 700);
    if(tempValue != 0)
    {
        return -1;
    }

    m_nBufSizeForSaveImage = stImageInfo.nWidth * stImageInfo.nHeight *3+2048;
    unsigned char* m_pBufForSaveImage;
    m_pBufForSaveImage = (unsigned char*)malloc(m_nBufSizeForSaveImage);

    bool isMono;
    switch(stImageInfo.enPixelType)
    {
    case PixelType_Gvsp_Mono8:
    case PixelType_Gvsp_Mono10:
    case PixelType_Gvsp_Mono10_Packed:
    case PixelType_Gvsp_Mono12:
    case PixelType_Gvsp_Mono12_Packed:
        isMono = true;
        break;
    default:
        isMono = false;
        break;

     }

    if(isMono)
    {
        *getImage = Mat(stImageInfo.nHeight,stImageInfo.nWidth,CV_8UC1,pDate);
    }
    else
    {
        //图像到BGR8转换
        MV_CC_PIXEL_CONVERT_PARAM stConvertParam = {0};
        memset(&stConvertParam,0,sizeof(MV_CC_PIXEL_CONVERT_PARAM));
        stConvertParam.nWidth = stImageInfo.nWidth;
        stConvertParam.nHeight = stImageInfo.nHeight;

        stConvertParam.pSrcData = pDate;
        stConvertParam.nSrcDataLen = stImageInfo.nFrameLen;
        stConvertParam.enSrcPixelType = stImageInfo.enPixelType;
        stConvertParam.enDstPixelType = PixelType_Gvsp_BGR8_Packed;

        stConvertParam.pDstBuffer = m_pBufForSaveImage;
        stConvertParam.nDstBufferSize = m_nBufSizeForSaveImage;

        MV_CC_ConvertPixelType(m_hDevHandle,&stConvertParam);

        *getImage = Mat(stImageInfo.nHeight,stImageInfo.nWidth,CV_8UC3,m_pBufForSaveImage);
    }

    (*getImage).copyTo(image);
    (*getImage).release();
    free(pDate);
    free(m_pBufForSaveImage);
    return 0;
}
// 读取buffer
int CMvCamera::GetImage(Mat &image,bool FindFlag)
{
    int ret;
    ::EnterCriticalSection(&mCsRead);
    if (FindFlag)
    {
        ret = SetFloatValue("ExposureTime",ExposureTimeFindEdge);
        if (ret != MV_OK)
        {
            ::LeaveCriticalSection(&mCsRead);
            return -1;
        }
    }
    ClearImageBuffer();
    ret = CommandExecute("TriggerSoftware");
    if (ret != MV_OK)
    {
        ::LeaveCriticalSection(&mCsRead);
        return -1;
    }
    ret = ReadBuffer(image);
    if (ret != MV_OK)
    {
        ::LeaveCriticalSection(&mCsRead);
        return -1;
    }
    if (FindFlag)
    {
        ret = SetFloatValue("ExposureTime",ExposureTime);
        if (ret != MV_OK)
        {
            ::LeaveCriticalSection(&mCsRead);
            return -1;
        }
    }

    ::LeaveCriticalSection(&mCsRead);
    return 0;
}
int CMvCamera::setPoints(std::vector<cv::Point> points, cv::Mat &image)
{
    for (int i = 0; i < points.size(); i++)
    {
        image.at<unsigned char>(points[i].y, points[i].x) = 255;
    }
    return 0;
}

std::vector<cv::Point> CMvCamera::getPoints(cv::Mat &image, int value)
{
    int nl = image.rows; // number of lines
    int nc = image.cols * image.channels();
    std::vector<cv::Point> points;
    for (int j = 0; j < nl; j++)
    {
        uchar* data = image.ptr<uchar>(j);
        for (int i = 0; i < nc; i++)
        {
            if (data[i] >= value)
            {
                points.push_back(cv::Point(i, j));
            }
        }
    }
    return points;
}
bool SortByX(Point &v1, Point &v2)//注意：本函数的参数的类型一定要与vector中元素的类型一致
{
    return v1.x < v2.x;//升序排列
}
bool SortByY(Point &v1, Point &v2)//注意：本函数的参数的类型一定要与vector中元素的类型一致
{
    return v1.y < v2.y;//升序排列
}
int CMvCamera::GetLineSlope(Mat &src,bool &result,double *slope)
{
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    std::vector<cv::Point> points;
    std::vector<cv::Point> points20;
    std::vector<cv::Point> points_dst;
    result = false;

    imwrite("src.bmp", src);
    Mat src_gray = src(Rect(src.cols/4, 0, src.cols / 2, src.rows));

    blur(src_gray, src_gray, Size(7, 7));
    threshold(src_gray, src_gray, ParaThreshold, 255, THRESH_BINARY); //参数1：阈值
    imwrite("canny0.bmp", src_gray);

    Mat dst = Mat::zeros(src_gray.size(), CV_8UC1);

    Point p_tmp, p_start;
    unsigned char pix_next;
    int x_tmp = 100;

    while (1)
    {
        bool flag = false;
        for (int j = src_gray.rows/2; j > 0; j--)    //参数2：Y方向起始值
        {
            pix_next = src_gray.at<unsigned char>(j - 1, x_tmp);
            if (pix_next == 0)
            {
                p_start.x = x_tmp;
                p_start.y = j - 1;
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            return -1;
        }
        int x2, y2;
        x2 = p_start.x;
        y2 = p_start.y + YOffsetPos;    //参数3：Y方向偏移值
        for (int k = 0; k < ContinuePointSum; k++)  //参数4：连续合格点数量，排除干扰
        {
            for (int j = y2; j > 0; j--)
            {
                pix_next = src_gray.at<unsigned char>(j - 1, x2);
                if (pix_next == 0)
                {
                    p_tmp.x = x2;
                    p_tmp.y = j-1;
                    points20.push_back(p_tmp);
                    break;
                }
            }
            x2++;
        }
        if (points20.empty())
        {
            return -1;
        }

        int minY = p_start.y, maxY = p_start.y;
        for (int k = 0; k < ContinuePointSum; k++)     //参数4：连续合格点数量，排除干扰
        {
            if (minY > points20[k].y)
            {
                minY = points20[k].y;
            }
            if (maxY < points20[k].y)
            {
                maxY = points20[k].y;
            }
        }
        if ((maxY - minY) < YPointValueDiff)   //参数5：Y方向差值
            break;
        x_tmp = x_tmp + ContinuePointSum;       //参数4：连续合格点数量，排除干扰
        std::vector<cv::Point>().swap(points20);
        if (x_tmp >= src_gray.cols)
            return -1;
    }
    if (points20.empty())
    {
        return -1;
    }



    {
        Mat tmpsrtgray;
        src_gray.copyTo(tmpsrtgray);
        Canny(tmpsrtgray, src_gray, 70, 200);
        imwrite("canny.bmp", src_gray);
        Mat shape1;

        findContours(src_gray, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);//RETR_EXTERNAL
        //imwrite("dstnull.bmp", dst);
        if ((contours.size() > 0))
        {

            bool flag = false;
            int num = 0;
            for (unsigned int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < contours[i].size(); j++)
                {
                    if (contours[i][j] == points20[0])
                    {
                        num = i;
                        flag = true;
                        break;
                    }
                }
                if (flag)
                    break;

            }
            points = contours[num];


            std::sort(points.begin(), points.end(), SortByX);
            setPoints(points, dst);
            //imwrite("canny2.bmp", dst);
            //imshow("src_gray1", dst);
        }

        if (points.size() > ContoursPointSum)     //参数6：轮廓点数量
        {
            float step = points.size() / LinePointCount;   //参数7：取点间隔
            int i = 0;
            while (1)
            {
                points_dst.push_back(points[(int)(i*step)]);
                i++;
                if (i >= LinePointCount)  //参数7：取点间隔
                    break;
            }

        }
        else
        {
            points_dst = points;
        }
    }

    cv::Vec4f line;
    double k;
    double b;
    double cos_theta;
    double sin_theta;
    double x0, y0;
    fitLine(points_dst, line, DIST_L2, 0, 0.01, 0.01);
    cos_theta = line[0];
    sin_theta = line[1];
    x0 = line[2];
    y0 = line[3];
    k = sin_theta / cos_theta;
    b = y0 - k * x0;
    *slope = k;

    cv::Point pt1((int)(-b/k), 0);
    cv::Point pt2((int)((dst.rows - b)/k), dst.rows);
    cv::line(dst, pt1, pt2, cv::Scalar(255, 255, 255), 2);
    //imshow("src_gray2", dst);

    double A, B, C, TotalDistance = 0;
    A = k;
    B = -1;
    C = b;
    for (unsigned int i = 0; i < points_dst.size(); i++)
    {
        double dis = abs(A * points_dst[i].x + B * points_dst[i].y + C) / sqrt(A * A + B * B);
        TotalDistance = TotalDistance + dis;
    }
    if (TotalDistance <= SumValueThresh)  //参数8：取点间隔
    {
        result = true;

    }
    else
    {
        result = false;
    }
    qDebug()<< "result:"<<result;
    qDebug()<< "slope:"<<*slope;
    qDebug()<< "TotalDistance:"<<TotalDistance;
    return 0;

}


int CMvCamera::GetGap(Mat &src,bool &result,int *xPos)
{
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    std::vector<cv::Point> points;
    std::vector<cv::Point> points20;
    std::vector<cv::Point> points_dst;
    result = false;

    imwrite("src.bmp", src);
    Mat src_gray = src(Rect(src.cols/4, 0, src.cols / 2, src.rows));

    blur(src_gray, src_gray, Size(7, 7));
    threshold(src_gray, src_gray, ParaThreshold, 255, THRESH_BINARY); //参数1：阈值ParaThreshold
    imwrite("canny0.bmp", src_gray);

    Mat dst = Mat::zeros(src_gray.size(), CV_8UC1);

    Point p_tmp, p_start;
    unsigned char pix_next;
    int x_tmp = 100;

    while (1)
    {
        bool flag = false;
        for (int j = src_gray.rows*3/4; j > 0; j--)    //参数2：Y方向起始值
        {
            pix_next = src_gray.at<unsigned char>(j - 1, x_tmp);
            if (pix_next == 0)
            {
                p_start.x = x_tmp;
                p_start.y = j - 1;
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            return -1;
        }
        int x2, y2;
        x2 = p_start.x;
        y2 = p_start.y + YOffsetPos;    //参数3：Y方向偏移值
        for (int k = 0; k < ContinuePointSum; k++)  //参数4：连续合格点数量，排除干扰
        {
            for (int j = y2; j > 0; j--)
            {
                pix_next = src_gray.at<unsigned char>(j - 1, x2);
                if (pix_next == 0)
                {
                    p_tmp.x = x2;
                    p_tmp.y = j-1;
                    points20.push_back(p_tmp);
                    break;
                }
            }
            x2++;
        }
        if (points20.empty())
        {
            return -1;
        }

        int minY = p_start.y, maxY = p_start.y;
        for (int k = 0; k < ContinuePointSum; k++)     //参数4：连续合格点数量，排除干扰
        {
            if (minY > points20[k].y)
            {
                minY = points20[k].y;
            }
            if (maxY < points20[k].y)
            {
                maxY = points20[k].y;
            }
        }
        if ((maxY - minY) < YPointValueDiff_6)   //参数5：Y方向差值
            break;
        x_tmp = x_tmp + ContinuePointSum;       //参数4：连续合格点数量，排除干扰
        std::vector<cv::Point>().swap(points20);
        if (x_tmp >= src_gray.cols)
            return -1;
    }
    if (points20.empty())
    {
        return -1;
    }



    {
        Mat tmpsrtgray;
        src_gray.copyTo(tmpsrtgray);
        Canny(tmpsrtgray, src_gray, 70, 255);
        imwrite("canny.bmp", src_gray);
        Mat shape1;

        findContours(src_gray, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);//RETR_EXTERNAL
        //imwrite("dstnull.bmp", dst);
        if ((contours.size() > 0))
        {

            bool flag = false;
            int num = 0;
            for (unsigned int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < contours[i].size(); j++)
                {
                    if (contours[i][j] == points20[0])
                    {
                        num = i;
                        flag = true;
                        break;
                    }
                }
                if (flag)
                    break;

            }
            points = contours[num];


            std::sort(points.begin(), points.end(), SortByY);
            setPoints(points, dst);
            //imwrite("canny2.bmp", dst);
            //imshow("src_gray1", dst);
        }
        qDebug()<< "ContoursPointSum:"<<ContoursPointSum;
        if (points.size() > ContoursPointSum)     //参数6：轮廓点数量
        {
            int maxY = points[points.size()-1].y;   //参数7：取点间隔 //参数6：轮廓点数量 //参数5：Y方向差值 //参数4：连续合格点数量，排除干扰 //参数3：Y方向偏移值 //参数2：Y方向起始值 //参数1：阈值
            int maxX = points[points.size() - 1].x;

            if ((maxX <= 50) || (maxX >= (int)src_gray.cols - 50))
            {
                return 0;
            }
            result = true;
            std::vector<cv::Point> points_maxY;
            for (int i = 0; i < points.size(); i++)
            {
                if (maxY == points[i].y)
                {
                    points_maxY.push_back(points[i]);
                }
            }
            maxX = 0;
            for (int i = 0; i < points_maxY.size(); i++)
            {
                maxX = maxX + points_maxY[i].x;
            }
            maxX = maxX / points_maxY.size();
            *xPos = maxX;

            Point tmpPoint;
            tmpPoint.x = maxX;
            tmpPoint.y = maxY;
            circle(src_gray, tmpPoint, 5, (255, 255, 255), 1);
            imwrite("canny666.bmp", src_gray);

        }
        else
        {
            return 0;
        }
    }


    return 0;

}



int CMvCamera::getCameraPara(QString DevName)//CameraPara
{
    QSettings *settings;//申明一个QSetting类函数
    settings = new QSettings ("SerialDevSet.ini", QSettings::IniFormat);//构建函数

    QString strKey;
    strKey = DevName+"/ParaThreshold";
    ParaThreshold = settings->value(strKey).toInt();
    strKey = DevName+"/YOffsetPos";
    YOffsetPos = static_cast<unsigned short>(settings->value(strKey).toInt());

    strKey = DevName+"/ContinuePointSum";
    ContinuePointSum = static_cast<unsigned short>(settings->value(strKey).toInt());
    strKey = DevName+"/YPointValueDiff";
    YPointValueDiff = static_cast<unsigned short>(settings->value(strKey).toInt());

    strKey = DevName+"/YPointValueDiff_6";
    YPointValueDiff_6 = static_cast<unsigned short>(settings->value(strKey).toInt());

    strKey = DevName+"/ContoursPointSum";
    ContoursPointSum = static_cast<unsigned short>(settings->value(strKey).toInt());
    strKey = DevName+"/LinePointCount";
    LinePointCount = static_cast<unsigned short>(settings->value(strKey).toInt());

    strKey = DevName+"/SumValueThresh";
    SumValueThresh = static_cast<unsigned short>(settings->value(strKey).toInt());
    strKey = DevName+"/StepOfFalse";
    StepOfFalse = static_cast<unsigned short>(settings->value(strKey).toInt());
    strKey = DevName+"/StepOfTrue";
    StepOfTrue = static_cast<unsigned short>(settings->value(strKey).toInt());

    strKey = DevName+"/ExposureTimeFindEdge";
    ExposureTimeFindEdge = static_cast<unsigned short>(settings->value(strKey).toInt());
    strKey = DevName+"/ExposureTime";
    ExposureTime = static_cast<unsigned short>(settings->value(strKey).toInt());


    return 0;
}
int CMvCamera::ClearImageBuffer()
{
    return MV_CC_ClearImageBuffer(m_hDevHandle);
}
std::vector<cv::Point> CMvCamera::getLinePoints(Mat img)
{
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    std::vector<cv::Point> points;
    std::vector<cv::Point> points20;
    std::vector<cv::Point> points_dst;

    Mat src_gray;
    img.copyTo(src_gray);

    blur(src_gray, src_gray, Size(7, 7));
    threshold(src_gray, src_gray, ParaThreshold, 255, THRESH_BINARY); //参数1：阈值
    imwrite("canny0.bmp", src_gray);

    Mat dst = Mat::zeros(src_gray.size(), CV_8UC1);

    Point p_tmp, p_start;
    unsigned char pix_next;
    int x_tmp = 100;

    while (1)
    {
        bool flag = false;
        for (int j = src_gray.rows / 2; j > 0; j--)    //参数2：Y方向起始值
        {
            pix_next = src_gray.at<unsigned char>(j - 1, x_tmp);
            if (pix_next == 0)
            {
                p_start.x = x_tmp;
                p_start.y = j - 1;
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            return points_dst;
        }
        int x2, y2;
        x2 = p_start.x;
        y2 = p_start.y + YOffsetPos;    //参数3：Y方向偏移值
        for (int k = 0; k < ContinuePointSum; k++)  //参数4：连续合格点数量，排除干扰
        {
            for (int j = y2; j > 0; j--)
            {
                pix_next = src_gray.at<unsigned char>(j - 1, x2);
                if (pix_next == 0)
                {
                    p_tmp.x = x2;
                    p_tmp.y = j - 1;
                    points20.push_back(p_tmp);
                    break;
                }
            }
            x2++;
        }
        if (points20.empty())
        {
            return points_dst;
        }

        int minY = p_start.y, maxY = p_start.y;
        for (int k = 0; k < ContinuePointSum; k++)     //参数4：连续合格点数量，排除干扰
        {
            if (minY > points20[k].y)
            {
                minY = points20[k].y;
            }
            if (maxY < points20[k].y)
            {
                maxY = points20[k].y;
            }
        }
        if ((maxY - minY) < YPointValueDiff)   //参数5：Y方向差值
            break;
        x_tmp = x_tmp + ContinuePointSum;       //参数4：连续合格点数量，排除干扰
        std::vector<cv::Point>().swap(points20);
        if (x_tmp >= src_gray.cols)
            return points_dst;
    }
    if (points20.empty())
    {
        return points_dst;
    }



    {
        Mat tmpsrtgray;
        src_gray.copyTo(tmpsrtgray);
        Canny(tmpsrtgray, src_gray, 70, 200);
        imwrite("canny.bmp", src_gray);
        Mat shape1;

        findContours(src_gray, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);//RETR_EXTERNAL
        //imwrite("dstnull.bmp", dst);
        if ((contours.size() > 0))
        {

            bool flag = false;
            int num = 0;
            for (unsigned int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < contours[i].size(); j++)
                {
                    if (contours[i][j] == points20[0])
                    {
                        num = i;
                        flag = true;
                        break;
                    }
                }
                if (flag)
                    break;

            }
            points = contours[num];


            std::sort(points.begin(), points.end(), SortByX);
            //setPoints(points, dst);
            //imwrite("canny2.bmp", dst);
            //imshow("src_gray1", dst);


        }


        points_dst = points;

        return points_dst;

    }
}
int CMvCamera::GetCrossPoint(Mat& src,  bool left,int * top)
{
    std::vector<cv::Point> points;
    std::vector<cv::Point> points_dst;

    Mat src_gray = src(Rect(src.cols / 3, 0, src.cols / 3, src.rows));
    points_dst = getLinePoints(src_gray);
    if (points_dst.size() == 0)
        return -1;

    Mat src_6 = src(Rect(src.cols / 6, 0, src.cols *4/ 6, src.rows));
    points = getLinePoints(src_6);
    if (points.size() == 0)
        return -1;


    cv::Vec4f line;
    double k;
    double b;
    double cos_theta;
    double sin_theta;
    double x0, y0;
    fitLine(points_dst, line, DIST_L2, 0, 0.01, 0.01);
    cos_theta = line[0];
    sin_theta = line[1];
    x0 = line[2];
    y0 = line[3];
    k = sin_theta / cos_theta;
    b = y0 - k * x0;


    //cv::Point pt1((int)(-b / k), 0);
    //cv::Point pt2((int)((dst.rows - b) / k), dst.rows);
    ////imshow("src_gray1", dst);
    //Mat testdst;
    //testdst = cv::imread("2_jiaodian.bmp", 0);
    ////cv::line(src_gray, pt1, pt2, cv::Scalar(255, 255, 255), 3);
    //cv::Point pt3((int)(-(b- src.cols / 4 * k) / k), 0);
    //cv::Point pt4((int)((dst.rows - (b - src.cols / 4 * k)) / k), dst.rows);
    //cv::line(testdst, pt3, pt4, cv::Scalar(255, 255, 255), 3);
    //cv::line(dst, pt1, pt2, cv::Scalar(255, 255, 255), 3);
    //imshow("dst", dst);
    ////imshow("src_gray2", src);
    //imshow("src_gray", testdst);
    ////imwrite("src_gray3.bmp", src_gray);
    double A, B, C;
    A = k;
    B = -1;
    C = b - src.cols / 6 * k;

    cv::Point pt3((int)(-(b- src.cols / 6 * k) / k), 0);
    cv::Point pt4((int)((src.rows - (b - src.cols / 6 * k)) / k), src.rows);
    Mat dst = Mat::zeros(src_6.size(), CV_8UC1);
    setPoints(points, dst);
    /*cv::line(dst, pt3, pt4, cv::Scalar(255, 255, 255), 1);
    imwrite("src_6.bmp", dst);*/
    unsigned int i;
    double dis;
    if (left)
    {
        for (i = points.size() / 2; i > 0; i--)
        {
            dis = abs(A * points[i].x + B * points[i].y + C) / sqrt(A * A + B * B);
            if (dis > 3)
            {
                if ((i - 10) > 0)
                {
                    double dis2 = abs(A * points[i - 1].x + B * points[i - 1].y + C) / sqrt(A * A + B * B);
                    if (dis2 > 2*dis)
                        break;
                }
                else
                    break;
            }

        }
        if (i > 0)
        {
            //circle(dst, points[i-1],3,Scalar(255), -1, 8);
            cv::Point pt1(points[i + 1].x, points[i + 1].y + 20);
            cv::Point pt2(points[i + 1].x, points[i + 1].y - 20);
            cv::line(dst, pt1, pt2, cv::Scalar(255, 255, 255), 1);
            imwrite("src_left.jpg", dst);
            *top = points[i + 1].y;
            return points[i + 1].x;
        }
        else
            return -1;
    }
    else
    {
        for (i = points.size() / 2; i < points.size(); i++)
        {
            dis = abs(A * points[i].x + B * points[i].y + C) / sqrt(A * A + B * B);
            if (dis > 3)
            {
                if ((i + 10) < points.size())
                {
                    double dis2 = abs(A * points[i + 1].x + B * points[i + 1].y + C) / sqrt(A * A + B * B);
                    if (dis2 > 2*dis)
                        break;
                }
                else
                    break;
            }

        }
        if (i < points.size())
        {
            //circle(dst, points[i-1],3,Scalar(255), -1, 8);
            cv::Point pt1(points[i - 1].x, points[i - 1].y + 20);
            cv::Point pt2(points[i - 1].x, points[i - 1].y - 20);
            cv::line(dst, pt1, pt2, cv::Scalar(255, 255, 255), 1);
            imwrite("src_right.bmp", dst);
            *top = points[i - 1].y;
            return dst.cols - points[i - 1].x;
        }
        else
            return -1;
    }




}
int CMvCamera::getLinePoints_bottom(Mat& img)
{
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    std::vector<cv::Point> points;
    std::vector<cv::Point> points20;
    std::vector<cv::Point> points_dst;

    Mat src_gray = img(Rect(img.cols / 3, 0, img.cols / 3, img.rows));
    //Mat src_gray;
    //img.copyTo(src_gray);

    blur(src_gray, src_gray, Size(7, 7));
    threshold(src_gray, src_gray, ParaThreshold, 255, THRESH_BINARY); //参数1：阈值
    imwrite("canny0.bmp", src_gray);

    Mat dst = Mat::zeros(src_gray.size(), CV_8UC1);

    Point p_tmp, p_start;
    unsigned char pix_next;
    int x_tmp = 100;

    while (1)
    {
        bool flag = false;
        for (int j = src_gray.rows / 3; j < src_gray.rows; j++)    //参数2：Y方向起始值
        {
            pix_next = src_gray.at<unsigned char>(j + 1, x_tmp);
            if (pix_next == 0)
            {
                p_start.x = x_tmp;
                p_start.y = j + 1;
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            return -1;
        }
        int x2, y2;
        x2 = p_start.x;
        y2 = p_start.y - YOffsetPos;    //参数3：Y方向偏移值
        for (int k = 0; k < 20; k++)  //参数4：连续合格点数量，排除干扰
        {
            for (int j = y2; j < src_gray.rows; j++)
            {
                pix_next = src_gray.at<unsigned char>(j + 1, x2);
                if (pix_next == 0)
                {
                    p_tmp.x = x2;
                    p_tmp.y = j ;
                    points20.push_back(p_tmp);
                    break;
                }
            }
            x2++;
        }
        if (points20.empty())
        {
            return -1;
        }

        int minY = p_start.y, maxY = p_start.y;
        for (int k = 0; k < 20; k++)     //参数4：连续合格点数量，排除干扰
        {
            if (minY > points20[k].y)
            {
                minY = points20[k].y;
            }
            if (maxY < points20[k].y)
            {
                maxY = points20[k].y;
            }
        }
        if ((maxY - minY) < 30)   //参数5：Y方向差值
            break;
        x_tmp = x_tmp + 20;       //参数4：连续合格点数量，排除干扰
        std::vector<cv::Point>().swap(points20);
        if (x_tmp >= src_gray.cols)
            return -1;
    }
    if (points20.empty())
    {
        return -1;
    }



    {
        Mat tmpsrtgray;
        src_gray.copyTo(tmpsrtgray);
        Canny(tmpsrtgray, src_gray, 70, 200);
        imwrite("canny.bmp", src_gray);
        Mat shape1;

        findContours(src_gray, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);//RETR_EXTERNAL
        //imwrite("dstnull.bmp", dst);
        if ((contours.size() > 0))
        {

            bool flag = false;
            int num = 0;
            for (unsigned int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < contours[i].size(); j++)
                {
                    if (contours[i][j] == points20[0])
                    {
                        num = i;
                        flag = true;
                        break;
                    }
                }
                if (flag)
                    break;

            }
            points = contours[num];


            std::sort(points.begin(), points.end(), SortByX);
            setPoints(points, dst);
            imwrite("canny2.bmp", dst);
            //imshow("src_gray1", dst);


        }
        for (int i = 0; i < points.size(); i++)
        {
            if (points[i].x == (int)src_gray.cols / 2)
                return points[i].y;
        }

        return -1;

    }
}
int CMvCamera::calc_arc_bypoints3(double* points0, double* points1, double* points2, double* center, double* radius)
{
    double x1 = points0[0],
        x2 = points1[0],
        x3 = points2[0];
    double y1 = points0[1],
        y2 = points1[1],
        y3 = points2[1];
    double z1 = points0[2],
        z2 = points1[2],
        z3 = points2[2];

    double a1 = (y1 * z2 - y2 * z1 - y1 * z3 + y3 * z1 + y2 * z3 - y3 * z2),
        b1 = -(x1 * z2 - x2 * z1 - x1 * z3 + x3 * z1 + x2 * z3 - x3 * z2),
        c1 = (x1 * y2 - x2 * y1 - x1 * y3 + x3 * y1 + x2 * y3 - x3 * y2),
        d1 = -(x1 * y2 * z3 - x1 * y3 * z2 - x2 * y1 * z3 + x2 * y3 * z1 + x3 * y1 * z2 - x3 * y2 * z1);

    double a2 = 2 * (x2 - x1),
        b2 = 2 * (y2 - y1),
        c2 = 2 * (z2 - z1),
        d2 = x1 * x1 + y1 * y1 + z1 * z1 - x2 * x2 - y2 * y2 - z2 * z2;

    double a3 = 2 * (x3 - x1),
        b3 = 2 * (y3 - y1),
        c3 = 2 * (z3 - z1),
        d3 = x1 * x1 + y1 * y1 + z1 * z1 - x3 * x3 - y3 * y3 - z3 * z3;

    double xyz_dev = a1 * b2 * c3 - a1 * b3 * c2 - a2 * b1 * c3 + a2 * b3 * c1 + a3 * b1 * c2 - a3 * b2 * c1;
    if (xyz_dev < 1e-6f)
    {
        return 0;
    }

    center[0] = -(b1 * c2 * d3 - b1 * c3 * d2 - b2 * c1 * d3 + b2 * c3 * d1 + b3 * c1 * d2 - b3 * c2 * d1)
        / xyz_dev;
    center[1] = (a1 * c2 * d3 - a1 * c3 * d2 - a2 * c1 * d3 + a2 * c3 * d1 + a3 * c1 * d2 - a3 * c2 * d1)
        / xyz_dev;
    center[2] = -(a1 * b2 * d3 - a1 * b3 * d2 - a2 * b1 * d3 + a2 * b3 * d1 + a3 * b1 * d2 - a3 * b2 * d1)
        / xyz_dev;

    *radius = sqrt(pow((points0[0] - center[0]), 2) + pow((points0[1] - center[1]), 2) + pow((points0[2] - center[2]), 2));
    return 1;
}