#include "Edge_Search.h"
#include <numeric>
Edge_Search::Edge_Search()
{
    bshowimg = false;
}

Edge_Search::~Edge_Search()
{
}
// 计算平均值
double Edge_Search::computeAverage(const std::vector<double> &data)
{
    return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
}

// 剔除异常数据，这里以平均值加减两倍标准差为界限
std::vector<double> Edge_Search::removeOutliers(const std::vector<double> &data)
{
    double mean = computeAverage(data);
    double sq_sum = std::inner_product(data.begin(), data.end(), data.begin(), 0.0);
    double stdev = std::sqrt(sq_sum / data.size() - mean * mean);
    std::vector<double> filteredData;
    for (double value : data)
    {
        if (std::abs(value - mean) <= 2 * stdev)
        { // 可以根据需要调整异常值判断的标准
            filteredData.push_back(value);
        }
    }
    return filteredData;
}

int Edge_Search::Detect(const cv::Mat &detimg, DetConfigResult *pDetConfig, std::shared_ptr<EdgeDetResult> &pEdgeDetResult)
{

    m_pdetlog = pDetConfig->pdetlog;
    if (pDetConfig->bDebugsaveImg)
    {
        m_pdetlog->bPrintStr = true;
    }
    int re = 0;
    bool bdraw = pDetConfig->pEdgeROI->Use_DrawROI;
    bool bAIDet = pDetConfig->pEdgeROI->Use_AIEdge;
    bool bUseEdge = pDetConfig->pEdgeROI->Use_DetEdge;
    if (pDetConfig->bMode_Edge_test)
    {
        bdraw = false;
        bAIDet = true;
    }
    // 边缘搜索
    if (bAIDet)
    {

        long ts = CheckUtil::getcurTime();
        m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s AI Detect  start  ", pDetConfig->strCamName.c_str());
        re = Detect_AI(detimg, pDetConfig, pEdgeDetResult);

        if (re != 0)
        {
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s Error  AI Detect re = %d", pDetConfig->strCamName.c_str(), re);

            // 如果失败了，启用绘制的结果。
            if (pDetConfig->pEdgeROI->AI_Fail_UseDraw)
            {
                bdraw = true;
            }
            else
            {
                return re;
            }
        }
        else
        {
            bdraw = false; // 如果AI检测成功，则不使用绘制结果
            long te = CheckUtil::getcurTime();
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  AI Detect  Success time %ld ms", pDetConfig->strCamName.c_str(), te - ts);
        }
    }

    if (bdraw)
    {
        long ts = CheckUtil::getcurTime();
        m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  UseDraw ROI  start", pDetConfig->strCamName.c_str());
        re = Detect_Draw(detimg, pDetConfig, pEdgeDetResult);
        if (re != 0)
        {
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s Error UseDraw ROI re = %d", pDetConfig->strCamName.c_str(), re);
            bUseEdge = true;
        }
        else
        {
            long te = CheckUtil::getcurTime();
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  UseDraw ROI  Success time %ld ms", pDetConfig->strCamName.c_str(), te - ts);
            bUseEdge = false;
        }
    }

    if (bUseEdge)
    {
        long ts = CheckUtil::getcurTime();
        m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  Search edge  start", pDetConfig->strCamName.c_str());
        re = Detect_Search(detimg, pDetConfig, pEdgeDetResult);
        if (re != 0)
        {
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s Error Search edge re = %d", pDetConfig->strCamName.c_str(), re);
            return re;
        }
        else
        {
            long te = CheckUtil::getcurTime();
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  Search edge  Success time %ld ms", pDetConfig->strCamName.c_str(), te - ts);
        }
    }
 
    // getchar();
    if (pDetConfig->bMode_Edge_test)
    {
        return 0;
    }
    // 特征定位
    if (!pEdgeDetResult->shieldMask_Src.empty())
    {
        long ts = CheckUtil::getcurTime();
        m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  Feature_Align  start", pDetConfig->strCamName.c_str());
        re = Feature_Align(detimg, pDetConfig, pEdgeDetResult);
        if (re != 0)
        {
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s Error Feature_Align re = %d", pDetConfig->strCamName.c_str(), re);
        }
        else
        {
            long te = CheckUtil::getcurTime();
            m_pdetlog->AddCheckstr(PrintLevel_2, "Edge_Search", " cam %s  Feature_Align  Success time %ld ms", pDetConfig->strCamName.c_str(), te - ts);
        }
    }

    return 0;
}

int Edge_Search::Detect_AI(const cv::Mat &detimg, DetConfigResult *pDetConfig, std::shared_ptr<EdgeDetResult> &pEdgeDetResult)
{
    Function_EdgeROI *pEdgeROI = pDetConfig->pEdgeROI;
    AI_Edge_Algin::DetConfig AI_detConfig;

    AI_detConfig.Init();
    AI_detConfig.saveProcessImg = AI_Edge_Algin::Save_Close;
    AI_detConfig.nAIErodesize = pEdgeROI->AI_Erode_Size;
    AI_detConfig.bUseDrawRoi_Check = pEdgeROI->AI_Fail_UseDraw;
    AI_detConfig.ncamId = 0;
    AI_detConfig.strCamName = pDetConfig->strCamName;
    if (AI_detConfig.bUseDrawRoi_Check)
    {
        AI_detConfig.drawMask = pEdgeROI->EdgeMask;
    }

    if (pEdgeROI->pointArry1.size() <= 0)
    {
        AI_detConfig.bUseDrawRoi_Check = false;
        m_pdetlog->AddCheckstr(PrintLevel_3, "Edge_Search", "Draw roi param erro");
    }
    else
    {
        AI_detConfig.drawRoi = cv::boundingRect(pEdgeROI->pointArry1);
    }

    if (pEdgeROI->EdgeMask.empty())
    {
        AI_detConfig.bUseDrawRoi_Check = false;
        m_pdetlog->AddCheckstr(PrintLevel_3, "Edge_Search", "Draw roi param erro");
    }

    if (pDetConfig->bMode_Edge_test)
    {
        AI_detConfig.bUseDrawRoi_Check = false;
        AI_detConfig.saveProcessImg = AI_Edge_Algin::Save_Filter;
    }

    if (pDetConfig->bDebugsaveImg)
    {
        AI_detConfig.bDebugSaveImg = true;
    }

    std::shared_ptr<Edge_AI_Result> CheckResult_Aling;
    // if (m_pAI_Edge_Algin.get() != nullptr)
    {

        int re = m_pAI_Edge_Algin.Detect(detimg, &AI_detConfig, CheckResult_Aling);

        if (re != 0)
        {
            printf("AIEdgeDete  error \n");
            return re;
        }
        pEdgeDetResult->nresult = 0;
        pEdgeDetResult->cutRoi = CheckResult_Aling->roi;
        pEdgeDetResult->shieldMask = CheckResult_Aling->mask;
        pEdgeDetResult->shieldMask_Src = CheckResult_Aling->DetMask_src;
        pEdgeDetResult->pEdgeDet_roiList = CheckResult_Aling->edge_RoiList;


        m_pdetlog->AddCheckstr(PrintLevel_3, "Edge_Search", "pEdgeDet_roiList %ld", pEdgeDetResult->pEdgeDet_roiList->size());
        // detMaskImg = CheckResult_Aling->mask.clone();
        // roi = CheckResult_Aling->roi;
        // detmask = CheckResult_Aling->DetMask_src.clone();
    }
    // getchar();
    return 0;
}

int Edge_Search::Detect_Draw(const cv::Mat &detimg, DetConfigResult *pDetConfig, std::shared_ptr<EdgeDetResult> &pEdgeDetResult)
{
    Function_EdgeROI *pEdgeROI = pDetConfig->pEdgeROI;
    cv::Mat paraMaskImg = pEdgeROI->EdgeMask;
    bool bsucc = false;
    cv::Rect roi;
    if (!paraMaskImg.empty())
    {
        if (pDetConfig->bDebugsaveImg)
        {
            cv::imwrite("draw_roi_1.png", paraMaskImg);
        }

        // cv::imwrite("paraMaskImg.png", paraMaskImg);
        if (detimg.size() == paraMaskImg.size())
        {
            pEdgeDetResult->shieldMask_Src = paraMaskImg;
            // m_DetEdge.detmask = paraMaskImg;
            // 查找轮廓
            std::vector<std::vector<cv::Point>> contours;
            std::vector<cv::Vec4i> hierarchy;
            cv::findContours(paraMaskImg, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

            // 找到最大轮廓
            int max_contour_index = -1;
            double max_area = 0;

            for (size_t i = 0; i < contours.size(); i++)
            {
                double area = cv::contourArea(contours[i]);
                if (area > max_area)
                {
                    max_area = area;
                    max_contour_index = i;
                }
            }
            if (max_contour_index >= 0)
            {
                roi = cv::boundingRect(contours[max_contour_index]);
                bsucc = true;
            }
            else
            {
                m_pdetlog->AddCheckstr(PrintLevel_3, "Detect_Draw", "Error DrMaskImg  NO contours");
            }

            // 计算最大轮廓的外接矩形
        }
        else
        {
            m_pdetlog->AddCheckstr(PrintLevel_3, "Detect_Draw", "Error DrMaskImg size != det img size");
        }
    }
    else
    {
        m_pdetlog->AddCheckstr(PrintLevel_3, "Detect_Draw", "Error config MaskImg is empty");
    }
    if (!bsucc)
    {
        return -1;
    }

    if (roi.x < 0 || roi.y < 0 || roi.width <= 0 || roi.height <= 0)
    {
        return 1;
    }
    if (roi.x + roi.width > detimg.cols)
    {
        return 1;
    }
    if (roi.y + roi.height > detimg.rows)
    {
        return 1;
    }
    pEdgeDetResult->cutRoi = roi;

    // 对绘制的边缘进行 精细处理
    {
        int thresholdvalue = pEdgeROI->threshold_value;

        cv::Mat detMaskImg = paraMaskImg(roi).clone();
        if (pDetConfig->bDebugsaveImg)
        {
            cv::imwrite("draw_roi_2.png", detMaskImg);
        }
        detMaskImg = ~detMaskImg;
        if (pDetConfig->bDebugsaveImg)
        {
            cv::imwrite("draw_roi_3.png", detMaskImg);
        }
        if (thresholdvalue > 0)
        {
            int threshold_value = 11; // 你可以根据需要调整阈值
            if (thresholdvalue >= 0 && thresholdvalue < 255)
            {
                threshold_value = thresholdvalue;
            }
            int max_value = 255;                        // 最大像素值，白色
            int threshold_type = cv::THRESH_BINARY_INV; // 将高于阈值的像素设为白色，低于阈值的像素设为黑色

            cv::Mat temimg;
            cv::threshold(detimg(roi), temimg, threshold_value, max_value, threshold_type);
            printf("threshold_value %d\n", threshold_value);
            // 定义膨胀核
            int dilation_size = 3; // 膨胀核的大小
            if (pEdgeROI->AI_Erode_Size > 0 && pEdgeROI->AI_Erode_Size < 101)
            {
                dilation_size = 2 * pEdgeROI->AI_Erode_Size;
            }
            cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(dilation_size, dilation_size));

            // 进行膨胀操作
            cv::Mat dilated_image;
            cv::dilate(temimg, dilated_image, kernel);
            printf("detMaskImg= %d %d  %d\n", detMaskImg.cols, detMaskImg.rows, detMaskImg.channels());
            printf("dilated_image= %d %d  %d\n", dilated_image.cols, dilated_image.rows, dilated_image.channels());
            detMaskImg += dilated_image;
        }
        pEdgeDetResult->shieldMask = detMaskImg;
        if (pDetConfig->bDebugsaveImg)
        {
            cv::imwrite("draw_roi_4.png", pEdgeDetResult->shieldMask);
        }
        pEdgeDetResult->nresult = 0;
    }

    return 0;
}

int Edge_Search::Detect_Search(const cv::Mat &detimg, DetConfigResult *pDetConfig, std::shared_ptr<EdgeDetResult> &pEdgeDetResult)
{
    cv::Rect roi;

    int re = SearchEdge(detimg, roi, pDetConfig->bDebugsaveImg);
    if (re < 0)
    {
        return re;
    }

    if (roi.x < 0 || roi.y < 0 || roi.width <= 0 || roi.height <= 0)
    {
        return 1;
    }
    if (roi.x + roi.width > detimg.cols)
    {
        return 1;
    }
    if (roi.y + roi.height > detimg.rows)
    {
        return 1;
    }

    cv::Mat detMaskImg = cv::Mat(roi.height, roi.width, CV_8U, cv::Scalar(0));
    int thresholdvalue = pDetConfig->pEdgeROI->threshold_value;
    for (int i = 0; i < 4; i++)
    {
        int detH = 60;
        cv::Rect cutroi;
        cv::Rect maskRoi;

        switch (i)
        {
        case 0:
            cutroi.x = roi.x;
            cutroi.y = roi.y;

            cutroi.width = roi.width;
            cutroi.height = detH;

            maskRoi.x = 0;
            maskRoi.y = 0;
            maskRoi.width = roi.width;
            maskRoi.height = detH;
            break;
        case 1:
            cutroi.x = roi.x;
            cutroi.y = roi.y + roi.height - detH;

            cutroi.width = roi.width;
            cutroi.height = detH;

            maskRoi.x = 0;
            maskRoi.y = roi.height - detH;
            maskRoi.width = roi.width;
            maskRoi.height = detH;

            break;
        case 2:

            cutroi.x = roi.x;
            cutroi.y = roi.y;

            cutroi.width = detH;
            cutroi.height = roi.height;

            maskRoi.x = 0;
            maskRoi.y = 0;
            maskRoi.width = detH;
            maskRoi.height = roi.height;

            break;
        case 3:
            cutroi.x = roi.x + roi.width - detH;
            cutroi.y = roi.y;

            cutroi.width = detH;
            cutroi.height = roi.height;

            maskRoi.x = roi.width - detH;
            maskRoi.y = 0;
            maskRoi.width = detH;
            maskRoi.height = roi.height;
            break;
        default:
            break;
        }

        int threshold_value = 11; // 你可以根据需要调整阈值
        if (thresholdvalue >= 0 && thresholdvalue < 255)
        {
            threshold_value = thresholdvalue;
        }

        int max_value = 255;                        // 最大像素值，白色
        int threshold_type = cv::THRESH_BINARY_INV; // 将高于阈值的像素设为白色，低于阈值的像素设为黑色
        cv::Mat temimg;
        cv::threshold(detimg(cutroi), temimg, threshold_value, max_value, threshold_type);
        // 定义膨胀核
        int dilation_size = 4; // 膨胀核的大小

        if (pDetConfig->pEdgeROI->AI_Erode_Size > 0 && pDetConfig->pEdgeROI->AI_Erode_Size < 101)
        {
            dilation_size = 2 * pDetConfig->pEdgeROI->AI_Erode_Size;
        }
        cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(dilation_size, dilation_size));

        // 进行膨胀操作
        cv::Mat dilated_image;
        cv::dilate(temimg, detMaskImg(maskRoi), kernel);
    }

    pEdgeDetResult->nresult = 0;
    pEdgeDetResult->cutRoi = roi;
    pEdgeDetResult->shieldMask = detMaskImg;
    if (pDetConfig->bDebugsaveImg)
    {
        cv::imwrite(pDetConfig->strCamName + "8_Search_result.png", pEdgeDetResult->shieldMask);
        cv::imwrite(pDetConfig->strCamName + "8_Search_result_src.png", detimg(roi));
    }
    return 0;
}

int Edge_Search::SearchEdge(const cv::Mat &detimg, cv::Rect &roi, bool bsave)
{
    bool bdetSucc = false;

    cv::Mat img = detimg;
    bshowimg = bsave;
    if (bshowimg)
    {
        cv::cvtColor(img, showimg, cv::COLOR_GRAY2BGR);
    }
    int exp = 0;
    cv::Rect detroi;
    detroi.x = 0;
    detroi.y = 0;
    detroi.width = img.cols;
    detroi.height = img.rows * 0.8;
    int re = UDNoiseEdgeDetect(img, 3, 40, 1, detroi, 30, 60);
    if (re < 0)
    {
        printf("edge error 1 %d \n", re);
        return re;
    }
    roi.y = re + exp;

    if (bshowimg && !showimg.empty())
    {
        cv::Point p1 = cv::Point(0, re);
        cv::Point p2 = cv::Point(img.cols, re);
        cv::line(showimg, p1, p2, cv::Scalar(255, 0, 255), 5);
        printf(">>>>>1>>000000>\n");
    }
    // cv::Point p1 = cv::Point(0, re);
    // cv::Point p2 = cv::Point(img.cols, re);
    // cv::line(img, p1, p2, cv::Scalar(255));

    detroi.x = 0;
    detroi.y = img.rows * 0.2;
    detroi.width = img.cols;
    detroi.height = img.rows * 0.8 - 1;
    re = UDNoiseEdgeDetect(img, -3, 40, 10, detroi, 30, 60);
    if (re < 0)
    {
        printf("edge error 2 %d \n", re);
        return re;
    }
    roi.height = re - exp - roi.y;
    if (bshowimg && !showimg.empty())
    {
        cv::Point p1 = cv::Point(0, re);
        cv::Point p2 = cv::Point(img.cols, re);
        cv::line(showimg, p1, p2, cv::Scalar(255, 0, 255), 5);
    }

    // p1 = cv::Point(0, re);
    // p2 = cv::Point(img.cols, re);
    // cv::line(img, p1, p2, cv::Scalar(255));
    // cv::imwrite("showimg.png", img);
    // printf(">>>>>>>>\n");
    // getchar();

    detroi.x = 0;
    detroi.y = 0;
    detroi.width = img.cols / 2;
    detroi.height = img.rows;
    re = LRNoiseEdgeDetect(img, 3, 40, 1, detroi, 30, 60);
    if (re < 0)
    {
        printf("edge error 333   v %d \n", re);
        return re;
    }
    roi.x = re + exp;

    if (bshowimg && !showimg.empty())
    {
        cv::Point p1 = cv::Point(re, 0);
        cv::Point p2 = cv::Point(re, img.rows);
        cv::line(showimg, p1, p2, cv::Scalar(255, 0, 255), 5);
    }
    // p1 = cv::Point(re, 0);
    // p2 = cv::Point(re, img.rows);
    // cv::line(img, p1, p2, cv::Scalar(255));
    // cv::imwrite("showimg.png", img);
    // printf(">>>>>>>>\n");
    // getchar();
    // cv::imwrite("showimg.png", showimg);
    // printf(">>>>>1>>>re %d\n", re);
    // getchar();
    detroi.x = img.cols / 2;
    detroi.y = 0;
    detroi.width = img.cols / 2 - 1;
    detroi.height = img.rows;
    re = LRNoiseEdgeDetect(img, -3, 40, 1, detroi, 30, 60);
    if (re < 0)
    {
        printf(">>>>>>>>\n");
        printf("edge error 4  %d \n", re);
        return re;
    }
    roi.width = re - exp - roi.x;
    // int len = roi.width / 4 * 4;
    // roi.width = len;

    if (bshowimg && !showimg.empty())
    {

        cv::Point p1 = cv::Point(re, 0);
        cv::Point p2 = cv::Point(re, img.rows);
        cv::line(showimg, p1, p2, cv::Scalar(255, 0, 255), 5);
        cv::rectangle(showimg, roi, cv::Scalar(0, 255, 0));
    }

    // cv::Mat temimg = showimg(real_roi).clone();

    // if (real_roi.width > real_roi.height)
    // {
    // 	sz.width = 2048;
    // 	fx = sz.width * 1.0f / real_roi.width;
    // 	sz.height = real_roi.height * fx;
    // }
    // else
    // {
    // 	sz.height = 2048;
    // 	fx = sz.height * 1.0f / real_roi.height;
    // 	sz.width = real_roi.width * fx;
    // }

    // cv::resize(temimg, showimg, sz);

    if (bshowimg && !showimg.empty() && true)
    {

        printf(">>>>>>>>\n");
        static int ssss = 0;

        cv::Size sz;

        if (img.cols > img.rows)
        {
            sz.width = 2732;
            sz.height = 2048;
        }
        else
        {
            sz.width = 2048;
            sz.height = 2732;
        }

        // cv::Mat detsizeimg;
        cv::resize(showimg, showimg, sz);
        // std::string strpath22 = "./img/edge/" + std::to_string(ssss++) + "_det.png";
        // printf(">>>>>>>>strpath22 %s\n", strpath22.c_str());
        // cv::imwrite(strpath22, detsizeimg);

        // std::string strpath22222 = "./img/edge/" + std::to_string(ssss++) + "_src.png";
        // printf(">>>>>>>>strpath22 %s\n", strpath22.c_str());
        // cv::imwrite(strpath22222, img);

        cv::imwrite("showimg.png", showimg);
        printf(">>>>>>>>\n");
    }

    // p1 = cv::Point(re, 0);
    // p2 = cv::Point(re, img.rows);
    // cv::line(img, p1, p2, cv::Scalar(255));
    // cv::imwrite("showimg.png", img);
    // printf(">>>>>>>>\n");
    // getchar();
    // cv::rectangle(img, roi, cv::Scalar(255));
    // cv::imwrite("showimg.png", img);
    // printf(">>>>>>>>\n");
    // getchar();
    return 0;
}

int Edge_Search::Feature_Align(const cv::Mat &detimg, DetConfigResult *pDetConfig, std::shared_ptr<EdgeDetResult> &pEdgeDetResult)
{

    // 1、要使用 AI 搜边。
    // 2、对齐开关要开启
    // 3、特征maks不为空
    // 4、边缘mask不为空
    cv::Rect Det_CropRoi = pEdgeDetResult->cutRoi;
    cv::Mat detImg_mask = pEdgeDetResult->shieldMask_Src;

    if (!pDetConfig->pAlign)
    {
        return 1;
    }
    std::string strlog = "";
    Function_Image_Align *pAlign;
    pAlign = pDetConfig->pAlign;

    if (pAlign->bOpen &&
        !pAlign->feature_Mask.empty())
    {
        // cv::imwrite("Align_search_img.png", m_DetEdge.detmask(pFuntion_L255->function.f_Image_Align.search_Roi).clone());
        // cv::imwrite("Align_Kernel_img.png", pFuntion_L255->function.f_Image_Align.feature_Mask);
        // cv::imwrite("detmaskssss.png", m_DetEdge.detmask);
        // cv::imwrite("ssss.png", L255->in_shareImage->img);
        CheckUtil::printROI(Det_CropRoi, "Det Img Crop Roi");
        CheckUtil::printROI(pAlign->Crop_Roi, "Param Img Crop Roi");
        Image_Feature_Algin::DetConfig detconfig;
        detconfig.DetImg = detImg_mask;
        detconfig.TemplateImg = pAlign->feature_Mask;
        detconfig.Search_Roi = pAlign->search_Roi;
        detconfig.feature_Roi = pAlign->feature_Roi;
        detconfig.param_CropRoi = pAlign->Crop_Roi;
        detconfig.DetImg_CropROi = Det_CropRoi;
        detconfig.bSaveImg = pDetConfig->bDebugsaveImg;
        detconfig.fscore = pAlign->fscore;

        long t1 = CheckUtil::getcurTime();
        m_Image_Feature_Algin.Detect(&detconfig, &pEdgeDetResult->m_align_Result, m_pdetlog->logList);
        long t2 = CheckUtil::getcurTime();
        m_pdetlog->AddCheckstr(PrintLevel_3, "Image_Align", "use time %ld ", t2 - t1);

        pEdgeDetResult->m_align_Result.bDraw = pAlign->bDraw;

        // 对齐成功
        if (pEdgeDetResult->m_align_Result.bDet)
        {
            if (pAlign->runType == Function_Image_Align::type_Use)
            {
                pEdgeDetResult->m_align_Result.bUse = true;
            }
            // 更新 特征图像区域在检测图片上的位置。
            for (const auto &point : pAlign->pointArry1)
            {
                cv::Point p = point;
                cv::Point ss = pEdgeDetResult->m_align_Result.Parm_srcToDet_Crop_Point(p);
                pEdgeDetResult->m_align_Result.feature_PointList_DetImg.push_back(ss);
            }

            if (pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.x < 0)
            {
                pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.x = 0;
            }
            if (pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.x + pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.width > detimg.cols)
            {
                pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.x = detimg.cols - pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.width;
            }
            if (pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.y < 0)
            {
                pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.y = 0;
            }
            if (pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.y + pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.height > detimg.rows)
            {
                pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.y = detimg.rows - pEdgeDetResult->m_align_Result.Crop_Roi_ParmImg.height;
            }

            if (pDetConfig->bDebugsaveImg)
            {
                // 绘制对齐

                {
                    cv::Mat showimg;
                    cv::cvtColor(detimg(Det_CropRoi), showimg, cv::COLOR_GRAY2BGR);

                    cv::polylines(showimg, pEdgeDetResult->m_align_Result.feature_PointList_DetImg, true, cv::Scalar(255, 255, 0), 2);

                    cv::imwrite("align_Result.png", showimg);
                }
            }
        }
    }
    else
    {
        if (!pAlign->bOpen)
        {
            m_pdetlog->AddCheckstr(PrintLevel_3, "Image_Align", "-- error :Align Param Close");
        }
        else if (pAlign->feature_Mask.empty())
        {
            m_pdetlog->AddCheckstr(PrintLevel_3, "Image_Align", " -- error :AI Edge Det Error");
        }
        else
        {
            m_pdetlog->AddCheckstr(PrintLevel_3, "Image_Align", " -- error :Align Param Error");
        }
    }
    return 0;
}

int Edge_Search::UDNoiseEdgeDetect(cv::Mat img, int DirectSign, int Gate, int BorW, cv::Rect roi, int StepCount, int Limit)
{

    if (img.empty())
    {
        return -11;
    }
    if (img.channels() != 1)
    {
        printf("*****************************channels\n");

        return -12;
    }
    if (StepCount < 0 || StepCount >= roi.width)
    {
        printf("*****************************StepCount\n");

        return -22;
    }
    std::vector<double> data;
    // cv::Mat showimg;
    // cv::cvtColor(img, showimg, cv::COLOR_GRAY2BGR);
    uchar *pdata = (uchar *)img.data;

    int sx = roi.x;
    int ex = roi.x + roi.width;
    int sy = roi.y;
    int ey = roi.y + roi.height;
    // 表示 反向搜索
    if (DirectSign < 0)
    {
        sy = roi.y + roi.height;
        ey = roi.y;
    }
    int step = roi.width / StepCount;
    int offt = 0;
    int sumsite = 0;
    int sumcount = 0;
    // 表示搜索黑点
    if (BorW == 0)
    {
    }
    else // 表示搜索白点
    {
        for (int x = roi.x; x < ex; x = x + step)
        {

            int ncount = 0;
            int start = 0;

            for (int y = sy;; y = y + DirectSign)
            {
                if (DirectSign > 0 && y > ey)
                {
                    break;
                }
                if (DirectSign < 0 && y < ey)
                {
                    break;
                }
                int maxv = 0;
                // 1、计算当前值是否 满足基本要求
                offt = y * img.cols + x;
                maxv = pdata[offt];

                if (maxv < 40)
                {
                    for (int ix = -4; ix < 5; ix++)
                    {
                        int newx = x + ix;
                        if (newx < 0)
                        {
                            newx = 0;
                        }
                        if (newx > img.cols)
                        {
                            newx = img.cols;
                        }

                        offt = y * img.cols + newx;

                        if (pdata[offt] > maxv)
                        {
                            maxv = pdata[offt];
                        }
                    }
                }

                if (maxv > 40)
                {
                    // 2、计算区域最大值
                    for (int k = -4; k < 5; k++)
                    {
                        int newy = y + k;
                        if (newy < 0)
                        {
                            newy = 0;
                        }
                        if (newy >= img.rows)
                        {
                            newy = img.rows - 1;
                        }

                        for (int ix = -4; ix < 5; ix++)
                        {
                            int newx = x + ix;
                            if (newx < 0)
                            {
                                newx = 0;
                            }
                            if (newx > img.cols)
                            {
                                newx = img.cols;
                            }

                            offt = newy * img.cols + newx;

                            if (pdata[offt] > maxv)
                            {
                                maxv = pdata[offt];
                            }
                        }

                        /* code */
                    }
                    if (bshowimg)
                    {
                        cv::Rect roi;
                        roi.x = x - 2;
                        roi.width = 5;
                        if (roi.x < 0)
                        {
                            roi.x = 0;
                        }
                        int rdp = roi.x + roi.width;
                        if (rdp > showimg.cols)
                        {
                            rdp = showimg.cols;
                        }
                        roi.width = rdp - roi.x;

                        roi.y = y - 2;
                        roi.height = 5;
                        if (roi.y < 0)
                        {
                            roi.y = 0;
                        }
                        rdp = roi.y + roi.height;
                        if (rdp > showimg.rows)
                        {
                            rdp = showimg.rows;
                        }
                        roi.height = rdp - roi.y;
                        cv::rectangle(showimg, roi, cv::Scalar(0, 0, 255));
                        /* code */
                    }
                }
                else
                {
                    // if (start > 0)
                    // {
                    // 	printf("error  p  %d %d %d \n", x, y, maxv);
                    // 	/* code */
                    // }
                }
                // 3、满足要求 记录
                if (maxv >= Gate)
                {
                    ncount += 2;
                    if (start == 0)
                    {
                        start = y;
                    }
                    if (ncount > Limit)
                    {
                        break;
                    }
                }
                else
                {
                    // if (maxv < 15)
                    // {
                    // 	ncount = 0;
                    // }
                    ncount--;
                    if (ncount < 0)
                    {
                        ncount = 0;
                        start = 0;
                    }
                }
            }
            // 4、满足退出要求，就退出
            if (ncount > Limit)
            {
                sumcount++;
                sumsite += start;
                data.push_back(start);

                if (bshowimg && !showimg.empty())
                {
                    cv::Point p(x, start);
                    cv::circle(showimg, p, 13, cv::Scalar(0, 255, 0), 5);
                    // cv::imwrite("showimg.png", showimg);
                    // printf(">>>>>>>> %d %d \n",x,start);
                    // getchar();
                }
            }
        }
    }

    if (sumcount <= 0)
    {
        return -3;
    }
    else
    {
        // 先剔除异常数据
        std::vector<double> filteredData = removeOutliers(data);

        if (bshowimg && !showimg.empty())
        {

            // for (int i = 0; i < data.size(); i++)
            // {
            // 	printf("%d %f \n ", i, data.at(i));
            // }

            // for (int i = 0; i < filteredData.size(); i++)
            // {
            // 	printf("%d %f \n ", i, filteredData.at(i));
            // }
        }
        sumsite = 0;
        sumcount = 0;
        int mean = 0;
        for (int i = 0; i < filteredData.size(); i++)
        {
            sumsite += filteredData.at(i);
            sumcount++;
        }
        if (sumcount > 0)
        {
            mean = sumsite / sumcount;
        }

        mean = sumsite / sumcount;
        return mean;
    }

    return -5;
}

int Edge_Search::LRNoiseEdgeDetect(cv::Mat img, int DirectSign, int Gate, int BorW, cv::Rect roi, int StepCount, int Limit)
{
    if (img.empty())
    {
        return -1;
    }
    if (img.channels() != 1)
    {
        printf("*****************************channels\n");

        return -1;
    }
    if (StepCount < 0 || StepCount >= roi.width)
    {
        printf("*****************************StepCount\n");

        return -2;
    }

    std::vector<double> data;
    // cv::Mat showimg;
    // cv::cvtColor(img, showimg, cv::COLOR_GRAY2BGR);
    uchar *pdata = (uchar *)img.data;

    int sx = roi.x;
    int ex = roi.x + roi.width;
    int sy = roi.y;
    int ey = roi.y + roi.height;
    // 表示 反向搜索
    if (DirectSign < 0)
    {
        sx = roi.x + roi.width;
        ex = roi.x;
    }
    int step = roi.height / StepCount;
    int offt = 0;
    int sumsite = 0;
    int sumcount = 0;
    // 表示搜索黑点
    if (BorW == 0)
    {
    }
    else // 表示搜索白点
    {
        // printf("---- y  sy %d ey %d sx %d ex %d\n", sy, ey, sx, ex);
        for (int y = sy; y < ey; y = y + step)
        {
            int ncount = 0;
            int start = 0;

            for (int x = sx;; x = x + DirectSign)
            {
                if (DirectSign > 0 && x > ex)
                {
                    break;
                }
                if (DirectSign < 0 && x < ex)
                {
                    break;
                }
                int maxv = 0;
                // 1、计算当前值是否 满足基本要求
                offt = y * img.cols + x;
                maxv = pdata[offt];
                if (maxv < 40)
                {
                    for (int k = -4; k < 5; k++)
                    {
                        int newy = y + k;
                        if (newy < 0)
                        {
                            newy = 0;
                        }
                        if (newy >= img.rows)
                        {
                            newy = img.rows - 1;
                        }
                        offt = newy * img.cols + x;
                        maxv = pdata[offt];
                        if (pdata[offt] > maxv)
                        {
                            maxv = pdata[offt];
                        }
                    }
                }

                if (maxv > 40)
                {
                    // 2、计算区域最大值
                    for (int k = -4; k < 5; k++)
                    {
                        int newy = y + k;
                        if (newy < 0)
                        {
                            newy = 0;
                        }
                        if (newy >= img.rows)
                        {
                            newy = img.rows - 1;
                        }

                        for (int ix = -4; ix < 5; ix++)
                        {
                            int newx = x + ix;
                            if (newx < 0)
                            {
                                newx = 0;
                            }
                            if (newx > img.cols)
                            {
                                newx = img.cols;
                            }

                            offt = newy * img.cols + newx;

                            if (pdata[offt] > maxv)
                            {
                                maxv = pdata[offt];
                            }
                        }

                        /* code */
                    }
                    if (bshowimg)
                    {
                        cv::Rect roi;
                        roi.x = x - 2;
                        roi.width = 5;
                        if (roi.x < 0)
                        {
                            roi.x = 0;
                        }
                        int rdp = roi.x + roi.width;
                        if (rdp > showimg.cols)
                        {
                            rdp = showimg.cols;
                        }
                        roi.width = rdp - roi.x;

                        roi.y = y - 2;
                        roi.height = 5;
                        if (roi.y < 0)
                        {
                            roi.y = 0;
                        }
                        rdp = roi.y + roi.height;
                        if (rdp > showimg.rows)
                        {
                            rdp = showimg.rows;
                        }
                        roi.height = rdp - roi.y;
                        cv::rectangle(showimg, roi, cv::Scalar(0, 0, 255));
                        /* code */
                    }
                }
                else
                {
                    // if (start > 0)
                    // {
                    // 	//printf("error  p  %d %d %d \n", x, y, maxv);
                    // 	/* code */
                    // }
                }
                // 3、满足要求 记录

                if (maxv >= Gate)
                {
                    ncount += 2;
                    if (start == 0)
                    {
                        start = x;
                        // printf("---- %d %d y %d\n", pdata[offt], start, y);
                    }
                    if (ncount > Limit)
                    {
                        break;
                    }
                }
                else
                {
                    // if (maxv < 15)
                    // {
                    // 	ncount = 0;
                    // }
                    ncount--;
                    if (ncount < 0)
                    {
                        start = 0;
                        ncount = 0;
                    }
                }
            }
            if (ncount > Limit)
            {
                sumcount++;
                sumsite += start;
                data.push_back(start);
                if (bshowimg && !showimg.empty())
                {
                    cv::Point p(start, y);
                    cv::circle(showimg, p, 13, cv::Scalar(255, 255, 125), 5);
                    // cv::imwrite("showimg.png", showimg);
                    // printf(">>>>>>>>\n");
                    // getchar();
                }
            }
        }
    }

    // if (bshowimg && !showimg.empty())
    // {
    // 	cv::imwrite("showimg.png", showimg);
    // 	printf(">>>>>>123>>  DirectSign %d   \n",DirectSign);
    // 	getchar();
    // }
    // if (DirectSign < 0)
    // {

    // 	cv::imwrite("showimg.png", img);
    // 	printf(">>>>>>>>\n");
    // 	getchar();
    // }
    if (sumcount <= 0)
    {
        return -3;
    }
    else
    {

        // 先剔除异常数据
        std::vector<double> filteredData = removeOutliers(data);

        if (bshowimg && !showimg.empty())
        {

            // for (int i = 0; i < data.size(); i++)
            // {
            // 	printf("%d %f \n ", i, data.at(i));
            // }

            // for (int i = 0; i < filteredData.size(); i++)
            // {
            // 	printf("%d %f \n ", i, filteredData.at(i));
            // }
        }
        sumsite = 0;
        sumcount = 0;
        int mean = 0;
        for (int i = 0; i < filteredData.size(); i++)
        {
            sumsite += filteredData.at(i);
            sumcount++;
        }
        if (sumcount > 0)
        {
            mean = sumsite / sumcount;
        }

        mean = sumsite / sumcount;
        return mean;
    }

    return -5;
}