#include "TrainAnaEngine.h"

#define SHOW_RECTANGLE

using namespace ai_matrix;

unsigned int num=0;

TrainAnaEngine::TrainAnaEngine() {}

TrainAnaEngine::~TrainAnaEngine() {}

APP_ERROR TrainAnaEngine::Init()
{
    LogInfo << "TrainAnaEngine Init start";
    // 初始化相机帧率
    nFrameRate = FRAME_RATE;
    nRecIndex = 0;
    nPicAreaChangeing = 0x00;
    
    strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
    strPort1_ = engineName_ + "_" + std::to_string(engineId_) + "_1";
    dataSourceConfig_ = MyYaml::GetIns()->GetDataSourceConfigById(engineId_);
    strResultPath_ = MyYaml::GetIns()->GetPathValue("gc_result_path");
    strResultPath_for_test = MyYaml::GetIns()->GetPathValue("gc_result_path_for_test");

    // 获取算法参数的文件路径
    std::string strsettingpath = MyYaml::GetIns()->GetStringValue("method_setting");
    // 读取算法参数的内容
    getsetting(strsettingpath);
    // 获取动态检测参数的数量
    int nMethodCount = lstAction.size();
    // LogInfo << "TrainAnaEngine Init method list count:" << nMethodCount;
    if (nMethodCount > 2)
    {
        //计算变化值
        nRightComeFlagR3 = 0x00000001 << (lstAction.size() - 3);
        nRightComeFlagR2 = 0x00000001 << (lstAction.size() - 2) + nRightComeFlagR3;
        nRightComeFlagR1 = 0x00000001 << (lstAction.size() - 1) + nRightComeFlagR2;
        // LogInfo << "TrainAnaEngine Init nRightComeFlagR3:" << nRightComeFlagR3;
        // LogInfo << "TrainAnaEngine Init nRightComeFlagR2:" << nRightComeFlagR2;
        // LogInfo << "TrainAnaEngine Init nRightComeFlagR1:" << nRightComeFlagR1;
    }
    // 获取尾部车钩的偏移量
    nTailPixOffset = getTailPixOffset();
    // LogInfo << "TrainAnaEngine Init nTailPixOffset:" << nTailPixOffset;
    //初始化来车检测状态
    nStatus=TRAIN_INIT_STATUS;
    // 初始化引擎相关的参数
    vResetPartion();

    LogInfo << "TrainAnaEngine Init ok";
    return APP_ERR_OK;
}

APP_ERROR TrainAnaEngine::DeInit()
{
    LogInfo << "TrainAnaEngine DeInit ok";
    return APP_ERR_OK;
}


/**
* 参数初始化(列车结束时需调用)
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void TrainAnaEngine::InitParam()
{
    LogInfo << "TrainAnaEngine InitParam start";
    strTrainData_ = "";
    strTrainName_ = "";
    LogInfo << "TrainAnaEngine InitParam end";
}


/**
* 初始化车厢分割信息
* inParam : N/A
* outParam: N/A
* return  : N/A
*/
void TrainAnaEngine::vResetPartion()
{
    LogInfo << "TrainAnaEngine vResetPartion start";
	InitParam();
    // //行车状态为初始化
	// nStatus = TRAIN_INIT_STATUS;
    // nPreStatus = TRAIN_INIT_STATUS;

    //设定检测动态区域均为未发生变化
	nPicAreaChangeing = 0x00;
	nPrePicAreaChangeing = 0x00;
    //清空车厢划分列表
	lstPartInfo.clear();
    //初始化开始帧
    nLatestFrame = 0;

    // 根据帧率计算检测到车钩以后忽略检测的帧数
    // 1.默认车辆3.9秒通过
    // 2.默认车体长度 14.5(TRAIN_WIDTH)
    // 3.单位:米/秒
    fdefaultspeed = (TRAIN_WIDTH / 3.9);

    // 车体的三分之一作为忽略标准
    // 车体三分之一的通过时间
    float fpasstime = (TRAIN_WIDTH / 3.0) / fdefaultspeed;
    // 忽略帧数：时间*帧率
    nSamePartionIgnoreCount = fpasstime * nFrameRate;
    
    nPartionPassFrameCount = 0;

    LogInfo << "TrainAnaEngine vResetPartion start";
}

/**
* 格式化算分配置文件内容
* inParam : 单个算法配置分割后的字符信息
* outParam: 结构化的算法配置信息
* return  : N/A
*/
void TrainAnaEngine::vformatStructAnalyseInfo(std::vector<std::string> elems, AnalyseInfo &info)
{
    LogInfo << "TrainAnaEngine vformatStructAnalyseInfo start";
    //以下内容为文件读取的结果
    //算法类型 1动态检测 2车厢划分
    info.nType = -1;
    //检测敏感区域开始位置的X值
    info.nAreaX1 = -1;
    //检测敏感区域开始位置的Y值
    info.nAreaY1 = -1;
    //检测敏感区域结束位置的X值
    info.nAreaX2 = -1;
    //检测敏感区域结束位置的Y值
    info.nAreaY2 = -1;
    //算法结果等级相同做AND处理，不同做OR处理
    info.bOrLevel = -1;
    //是否以不同作为判断结果
    info.bDiff = false;
    //算法是否有效 1有效 0无效
    info.bOn = false;
    //判断相同的阈值
    info.dSameThresholdVal = 0.0;
    //判断不同的阈值
    info.dDiffThresholdVal = 0.0;
    //判断停车的累计帧数阈值
    info.nPauseMaxCoumt = 0;
    //图像增强的算法(位运算)
    //0x01 灰度化 
    //0x02 直方图均衡化
    //0x04 自定义
    info.npicimprovetype = -1;
    //OPENCV模板对比算法
    info.templemethod = -1;
    //直方图对比算法
    info.histmethod = -1;
    //自定义算法
    info.specmethod = -1;
    //图像比对的方法(位运算)
    //0x01 OPENCV模板对比
    //0x02 直方图对比
    //0x04 自定义
    info.compmethod = -1;
    //对比的基准图的路径
    info.baseImagePath = "";
    
    //以下内容为初始化结果
    //图像对比数值
    info.dComparePoint = 0.0;
    //上一帧对比数值
    info.dPreComparePoint = 0.0;
    //图像与基础状态是否发生变化
    info.bChanged = 0.0;
    //上一帧图像与基础状态是否发生变化
    info.bPreChanged = 0.0;
    //图像变化后(保持在一个平衡状态即值不变的状态)累计值
    info.nSameCount = 0;

    char *chrevptr;
    if (elems.size() == IMAGEANALYSE_NUM)
    {
        info.nType = atoi(elems[0].c_str());
        info.nAreaX1 = atoi(elems[1].c_str());
        info.nAreaY1 = atoi(elems[2].c_str());
        info.nAreaX2 = atoi(elems[3].c_str());
        info.nAreaY2 = atoi(elems[4].c_str());
        info.bOrLevel = atoi(elems[5].c_str());
        info.bDiff = (atoi(elems[6].c_str()) == 1) ? true : false;
        info.bOn = (atoi(elems[7].c_str()) == 1) ? true : false;
        info.dSameThresholdVal = strtod(elems[8].c_str(), &chrevptr);
        info.dDiffThresholdVal = strtod(elems[9].c_str(), &chrevptr);
        info.nPauseMaxCoumt = atoi(elems[10].c_str());
        info.npicimprovetype = atoi(elems[11].c_str());
        info.templemethod = atoi(elems[12].c_str());
        info.histmethod = atoi(elems[13].c_str());
        info.specmethod = atoi(elems[14].c_str());
        info.compmethod = atoi(elems[15].c_str());
        info.baseImagePath = elems[16];
    }
    LogInfo << "TrainAnaEngine vformatStructAnalyseInfo end";
}

/**
* 获取图像比对的结果值
* inParam : 算法配置信息
* inParam : 当前图像的Mat值
* inParam : 比对基础图像的Mat值
* outParam: N/A
* return  : 比对值的数组
*/
std::vector<double> TrainAnaEngine::getCompPoint(AnalyseInfo info, cv::Mat baseimg, cv::Mat tarpic)
{
    LogInfo << "TrainAnaEngine getCompPoint start";
    std::vector<double> dRetVal;
    cv::Point cvOutPoint;

    LogInfo << "TrainAnaEngine getCompPoint info.compmethod:" << info.compmethod;
    if ((info.compmethod & IMAGE_COMP_BY_SPEC) == IMAGE_COMP_BY_SPEC)
    {
        double dHistPoint = anapicbySpec(baseimg);
        dRetVal.push_back(dHistPoint);
    }
    //OPENCV模型比对方法
    if ((info.compmethod & IMAGE_COMP_BY_TEMPLE) == IMAGE_COMP_BY_TEMPLE)
    {
        double dtemplePoint = anapicbyTemple(baseimg, tarpic, info.templemethod, cvOutPoint);
        dRetVal.push_back(dtemplePoint);
    }
    //直方图比对方法
    if ((info.compmethod & IMAGE_COMP_BY_HIST) == IMAGE_COMP_BY_HIST)
    {
        double dHistPoint = anapicbyHist(baseimg, tarpic, info.histmethod);
        dRetVal.push_back(dHistPoint);
    }
    
    
    LogInfo << "TrainAnaEngine getCompPoint end:" << dRetVal[0];
    return dRetVal;
}

/**
* 获取算法配置文件的内容
* inParam : 算法配置文件路径
* outParam: N/A
* return  : N/A
*/
void TrainAnaEngine::getsetting(string strFilePath)
{
    //LogInfo << "TrainAnaEngine getsetting start";
    std::string strLineInfo;
    std::ifstream finfile(strFilePath);
    int nindex = 0;
    //按行读取
    while (std::getline(finfile, strLineInfo))
    {
        //LogInfo << "TrainAnaEngine getsetting nindex:" << nindex;
        //首行作为注释不读取
        if (nindex == 0)
        {
            nindex++;
            continue;
        }
        nindex++;
        std::vector<std::string> elems;
        //每行以逗号, 作为分隔符
        elems = MyUtils::getins()->split(strLineInfo, ",");

        AnalyseInfo strTempInfo;
        //根据逗号分割的列表数据 初始化算法配置信息
        vformatStructAnalyseInfo(elems, strTempInfo);
        //LogInfo << "TrainAnaEngine getsetting strTempInfo.nType :" << strTempInfo.nType ;
        //保存动态检测的算法到集合中
        if (strTempInfo.nType == TRAIN_ACTION)
        {
            lstAction.push_back(strTempInfo);
        }
        //保存车厢划分的算法到集合中
        else if(strTempInfo.nType == TRAIN_PARTION)
        {
            lstPartion.push_back(strTempInfo);
        }
    }
    //LogInfo << "TrainAnaEngine getsetting end";
}

/**
* 根据直方图做比对
* inParam : 当前图像的Mat值
* inParam : 比对基础图像的Mat值
* inParam : 比对算法
* outParam: N/A
* return  : 比对值
*/
double TrainAnaEngine::anapicbySpec(cv::Mat baseimg)
{
    LogInfo << "TrainAnaEngine anapicbySpec start";
    double match = 0.0;
    int nmean = 0;
    Mat tmp_m, tmp_sd;
    cv::Mat mtTempImage = mtresizeImage(baseimg, (int)(baseimg.cols / 4), (int)(baseimg.rows / 4));


    cv::Mat mtOutImage;
    cv::meanStdDev(mtTempImage, tmp_m, tmp_sd);
    nmean = (int)tmp_m.at<double>(0,0);
    int nwidth = mtTempImage.cols;
    int nHeight = mtTempImage.rows;
    std::vector<int> elems;
    int nmax = 0;
    int nmin = 0;
    for(int i = 0;i < nHeight;i++) {
        int ncheckval = 0;
        for(int j = 0; j < nwidth;j++) {
            ncheckval = ncheckval + mtTempImage.at<uchar>(i,j);
        }
        ncheckval = (int)(ncheckval / nwidth) - nmean;
        if(ncheckval > nmax){
            nmax = ncheckval;
        }
        if(ncheckval < nmin){
            nmin = ncheckval;
        }
        elems.push_back(ncheckval);
    }
    
    int nstartindex = 6;
    int nendindex = 24;
    int nblackcount = 0;
    for(int i = nstartindex + 1;i < nendindex;i++) {
        if(elems[i] < 0 && elems[i - 1] < 0){
            nblackcount++;
        } else {
            //nblackcount = 0;
        }
    }
    LogInfo << "TrainAnaEngine anapicbySpec nblackcount:" << nblackcount;
    if (nblackcount > ((nendindex - nstartindex) / 2)) {
        for(int i = 0;i < nHeight;i++) {
            elems[i] = 0 - elems[i];
        }
    }

    int nfirstpot = -1;
    int nsecondpot = -1;
    int nthirdpot = -1;
    int nfirstpotsum = 0;
    int nsecondpotsum = 0;
    int nthirdpotsum = 0;

    int npremax = 0;
    int npremin = 0;
    int nfirstmax = 0;
    int nfirstmin = 0;
    int nsecondmax = 0;
    int nsecondmin = 0;

    for(int i = 2; i < nHeight; i++) {
        LogInfo << "TrainAnaEngine elems[i] :" <<  elems[i];
        if (elems[i -2] < elems[i - 1] && elems[i - 1] < elems[i]  && nfirstpot == -1 && elems[i] > 0) {
            nfirstpot = i;
        }
        if (nfirstpot == -1) {
            if(npremax < elems[i]){
                npremax =  elems[i];
            }
            if(npremin > elems[i]){
                npremin =  elems[i];
            }
            continue;
        }
        if (elems[i -2] > elems[i - 1] && elems[i - 1] > elems[i]  && nsecondpot == -1 && elems[i] < 0) {
            nsecondpot = i;
        }
        if (nsecondpot == -1 && elems[i] > 0) {
            nfirstpotsum++;
            if(nfirstmax < elems[i]){
                nfirstmax =  elems[i];
            }
            if(nfirstmin > elems[i]){
                nfirstmin =  elems[i];
            }
        }
        if (nsecondpot == -1) {
            continue;
        }
        if (nthirdpot == -1 && elems[i] < 0) {
            nsecondpotsum++;
            if(nsecondmax < elems[i]){
                nsecondmax =  elems[i];
            }
            if(nsecondmin > elems[i]){
                nsecondmin =  elems[i];
            }
        }
        if (elems[i -2] < elems[i - 1] && elems[i - 1] < elems[i]  && nthirdpot == -1 && elems[i] > 0) {
            nthirdpot = i;
        }
        if (nthirdpot != -1) {
            nthirdpotsum++;
        }
    }

    LogInfo << "TrainAnaEngine nHeight :" << nHeight;
    LogInfo << "TrainAnaEngine nfirstpot :" << nfirstpot;
    LogInfo << "TrainAnaEngine nsecondpot :" << nsecondpot;
    LogInfo << "TrainAnaEngine nthirdpot :" << nthirdpot;
    LogInfo << "TrainAnaEngine nmax :" << nmax;
    LogInfo << "TrainAnaEngine nmin :" << nmin;
    LogInfo << "TrainAnaEngine npremin :" << npremin;
    LogInfo << "TrainAnaEngine npremax :" << npremax;
    LogInfo << "TrainAnaEngine nfirstmax :" << nfirstmax;
    LogInfo << "TrainAnaEngine nfirstmin :" << nfirstmin;
    LogInfo << "TrainAnaEngine nsecondmax :" << nsecondmax;
    LogInfo << "TrainAnaEngine nsecondmin :" << nsecondmin;
    if (
        (nfirstpot < (int)(nHeight / 3))
        && (nsecondpot > (int)(nHeight / 2)) && (nsecondpot < (int)(nHeight *2 / 3))
        && (nthirdpot > (int)(nHeight * 3/ 4))
        && (npremin < 0)
        && (nfirstmax > 0)
        && (nsecondmin < 0)
        //&& (nfirstpotsum > (nsecondpot - nfirstpot - 2))
        //&& (nsecondpotsum > (nthirdpot - nsecondpot - 2))
        //&& (nthirdpotsum >= (nHeight - nthirdpot - 1))
        //&& (nmax- nfirstmax > nmax/2)
        //&& (nsecondmin < nmin/2)
    ){
        match = 1.0;
        double firstsinoffset = 180.0/nfirstpot;
        double secondsinoffset = 180.0/(nsecondpot - nfirstpot);
        double thirdsinoffset = 180.0/(nthirdpot - nsecondpot);
        double dbaseoffset = 1.0 / (nHeight * 1.0);
        double dmaxoffset = (nmax-nmin) * 1.0 ;
        LogInfo << "TrainAnaEngine firstsinoffset :" << firstsinoffset;
        LogInfo << "TrainAnaEngine secondsinoffset :" << secondsinoffset;
        LogInfo << "TrainAnaEngine thirdsinoffset :" << thirdsinoffset;
        LogInfo << "TrainAnaEngine dbaseoffset :" << dbaseoffset;
        LogInfo << "TrainAnaEngine dmaxoffset :" << dmaxoffset;
        double dtmp = 0.0;
        for (int i = 0; i < nHeight; i++) {
            if (i < nfirstpot){
                dtmp = dbaseoffset * abs(elems[i] - sin((i)*firstsinoffset)*(npremin* 1.0))/ dmaxoffset;
	    } else if(i>= nfirstpot && i < nsecondpot){
                dtmp = dbaseoffset * abs(elems[i] - sin((i - nfirstpot)*secondsinoffset)*(nfirstmax * 1.0)) / dmaxoffset;
            } else if(i>= nsecondpot && i < nthirdpotsum){
                dtmp = dbaseoffset * abs(elems[i] - sin((i - nsecondpot)*thirdsinoffset)*(nsecondmin * 1.0)) / dmaxoffset;
            } else if(i >= nthirdpotsum){
                dtmp = 0.0;
            }
            LogInfo << "TrainAnaEngine befor match :" << match;
            LogInfo << "TrainAnaEngine dtmp :" << dtmp;
            match = match - dtmp;
            LogInfo << "TrainAnaEngine after match :" << match;
        }
        //match = 1.0;
    }
    if (strResultPath_for_test != "")
    {
        std::ostringstream ossfloat,ossint;
        ossfloat<<(int)(match * 1000);
        ossint<<ncurtime;
        std::string strscore(ossfloat.str());
        std::string strindex(ossint.str());
        std::string strtestpath = strResultPath_for_test + strindex + "_______" + strscore + ".jpg";
        LogInfo << "TrainAnaEngine anapicbySpec image to" << strtestpath;
        cv::imwrite(strtestpath, mtTempImage);
    
    }
    LogInfo << "TrainAnaEngine anapicbySpec end:" << match;
    return match;
}

/**
* 根据直方图做比对
* inParam : 当前图像的Mat值
* inParam : 比对基础图像的Mat值
* inParam : 比对算法
* outParam: N/A
* return  : 比对值
*/
double TrainAnaEngine::anapicbyHist(cv::Mat baseimg, cv::Mat tarpic, int method)
{
    LogInfo << "TrainAnaEngine anapicbyHist start";
    float hranges[] = {0, 180};
    float sranges[] = {0, 255};
    const float *ranges[] = {hranges, sranges};
    int hbins = 60, sbins = 64;
    int histSize[] = {hbins, sbins};
    int channels[] = {0};
    cv::Mat hist1, hist2;
    //获取直方图信息
    cv::calcHist(&baseimg, 1, channels, Mat(), hist1, 2, histSize, ranges);
    cv::calcHist(&tarpic, 1, channels, Mat(), hist2, 2, histSize, ranges);

    double match = cv::compareHist(hist1, hist2, method);
    LogInfo << "TrainAnaEngine anapicbyHist end:" << match;
    return match;
}

/**
* 根据模板做比对
* inParam : 当前图像的Mat值
* inParam : 比对基础图像的Mat值
* inParam : 比对算法
* outParam: 目标的坐标
* return  : 比对值
*/
double TrainAnaEngine::anapicbyTemple(cv::Mat baseimg, cv::Mat tarpic, int method, cv::Point &pPos)
{
    LogInfo << "TrainAnaEngine anapicbyTemple start";
    double dRetVal = 0.0;
    cv::Mat img_match;
    //LogInfo << "TrainAnaEngine anapicbyTemple baseimg.cols:" << baseimg.cols;
    //LogInfo << "TrainAnaEngine anapicbyTemple baseimg.rows:" << baseimg.rows;
    //LogInfo << "TrainAnaEngine anapicbyTemple tarpic.cols:" << tarpic.cols;
    //LogInfo << "TrainAnaEngine anapicbyTemple tarpic.rows:" << tarpic.rows;
    
    cv::matchTemplate(baseimg, tarpic, img_match, method);

    double minval, maxval;
    cv::Point minloc, maxloc;
    cv::minMaxLoc(img_match, &minval, &maxval, &minloc, &maxloc);

    //LogInfo << "TrainAnaEngine anapicbyTemple method:" << method;
    //TM_SQDIFF算法和TM_SQDIFF_NORMED算法最小值为最匹配的数值
    if (
        method == cv::TM_SQDIFF || method == cv::TM_SQDIFF_NORMED)
    {
        dRetVal = minval;
        pPos = minloc;
    }
    //TM_CCORR TM_CCORR_NORMED TM_CCOEFF TM_CCOEFF_NORMED算法最大值为最匹配的数值
    else if (
        method == cv::TM_CCORR || method == cv::TM_CCORR_NORMED || method == cv::TM_CCOEFF || method == cv::TM_CCOEFF_NORMED)
    {
        dRetVal = maxval;
        pPos = maxloc;
    }
    //LogInfo << "TrainAnaEngine anapicbyTemple end" << dRetVal;
    //if (strResultPath_for_test != "" && nLatestFrame != 0)
    if(false)
    {
        cv::Mat cvdes = Mat(baseimg.rows, baseimg.cols + tarpic.cols, baseimg.type());
        cv::Mat cvleft = cvdes(cv::Rect(0, 0, baseimg.cols, baseimg.rows));
        baseimg.copyTo(cvleft);
        cv::Mat cvright = cvdes(cv::Rect(baseimg.cols, 0, tarpic.cols, tarpic.rows));
        tarpic.copyTo(cvright);

        std::ostringstream ossfloat,ossint;
        ossfloat<<(int)(dRetVal*1000);
        ossint<<nLatestFrame;
        std::string strscore(ossfloat.str());
        std::string strindex(ossint.str());
        std::string strtestpath = strResultPath_for_test + strindex + "_" + strscore + ".jpg";
        //LogInfo << "TrainAnaEngine anapicbyTemple image to" << strtestpath;
        cv::imwrite(strtestpath, cvdes);
    
    }
    return dRetVal;
}

/**
* 读取图像文件并转化为Mat值
* inParam : 读取文件的路径
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtdecodeImageDatabyFile(string path)
{
    LogInfo << "TrainAnaEngine mtdecodeImageDatabyFile start";
    //LogInfo << "TrainAnaEngine mtdecodeImageDatabyFile path:" << path;
    std::ifstream imagefile(path, std::ios::binary);
    std::vector<char> imagedata;
    imagefile >> std::noskipws;
    std::copy(std::istream_iterator<char>(imagefile), std::istream_iterator<char>(), std::back_inserter(imagedata));
    cv::Mat jpegimage = cv::imdecode(Mat(imagedata), cv::IMREAD_COLOR);
    imagefile.close();
    LogInfo << "TrainAnaEngine mtdecodeImageDatabyFile end";
    return jpegimage;
}


/**
* 将图像二进制数据转化为Mat值
* inParam : 二进制数据指针
* inParam : 二进制数据长度
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtdecodeImageDatabyBin(LPVOID lpimgdata, int imglen)
{
    LogInfo << "TrainAnaEngine mtdecodeImageDatabyBin start";
    //LogInfo << "TrainAnaEngine mtdecodeImageDatabyBin imglen:" << imglen;
    const char *buffer = static_cast<char *>(lpimgdata);
    vector<uchar>::size_type size = imglen;

    std::vector<unsigned char> imagedata(buffer, buffer + size);
    cv::Mat jpegimage = imdecode(imagedata, cv::IMREAD_COLOR);
    LogInfo << "TrainAnaEngine mtdecodeImageDatabyBin end";
    return jpegimage;
}


/**
* 图像增强
* inParam : 原始图片的Mat值
* inParam : 算法配置信息
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtImproveImage(cv::Mat inImage, AnalyseInfo info, bool bcvread)
{
    LogInfo << "TrainAnaEngine mtImproveImage start";
    cv::Mat mtOutImage = inImage;
    //cv::Mat mtOutImage;
    int x1 = info.nAreaX1;
    int y1 = info.nAreaY1;
    int width = info.nAreaX2 - info.nAreaX1;
    int height = info.nAreaY2 - info.nAreaY1;
    int type = info.nType;
    int mode = (bcvread == false) ? cv::COLOR_YUV2GRAY_420 : cv::COLOR_RGB2GRAY;

    //LogInfo << "TrainAnaEngine mtImproveImage x1:"<<x1;
    //LogInfo << "TrainAnaEngine mtImproveImage y1:"<<y1;
    //LogInfo << "TrainAnaEngine mtImproveImage width:"<<width;
    //LogInfo << "TrainAnaEngine mtImproveImage height:"<<height;
    //LogInfo << "TrainAnaEngine mtImproveImage type:"<<type;
    
    //图像灰度处理
    if (((info.npicimprovetype & IMAGE_GRAY) == IMAGE_GRAY) && (mode != -1))
    {
        mtOutImage = mtgrayImage(mtOutImage, mode);
    }
    //图像直方图均衡化处理
    if ((info.npicimprovetype & IMAGE_EQUALIZE) == IMAGE_EQUALIZE)
    {
        mtOutImage = mtequalizeImage(mtOutImage);
    }
    //图像进行gamma变换
    if ((info.npicimprovetype & IMAGE_GAMMA) == IMAGE_GAMMA)
    {
        mtOutImage = mtGammaImage(mtOutImage, 1.0);
    }
    //自定义处理
    if ((info.npicimprovetype & IMAGE_SPEC) == IMAGE_SPEC)
    {
        mtOutImage = mtspecImage(mtOutImage);
    }
    LogInfo << "TrainAnaEngine mtImproveImage end";
    return mtOutImage;
}

/**
* 修改图像尺寸
* inParam : 原始图片的Mat值
* inParam : 目标宽度
* inParam : 目标高度
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtresizeImage(cv::Mat inImage, int width, int height)
{
    LogInfo << "TrainAnaEngine mtresizeImage start";
    //LogInfo << "TrainAnaEngine mtresizeImage width:"<<width;
    //LogInfo << "TrainAnaEngine mtresizeImage height:"<<height;
    cv::Mat mtTempImage = inImage;
    cv::Mat mtOutImage;

    cv::resize(mtTempImage, mtOutImage, cv::Size(width, height));
    LogInfo << "TrainAnaEngine mtresizeImage end";
    return mtOutImage;
}

/**
* 裁剪图像
* inParam : 原始图片的Mat值
* inParam : 开始位置的X值
* inParam : 开始位置的Y值
* inParam : 结束位置的X值
* inParam : 结束位置的Y值
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtareaImage(cv::Mat inImage, int x1, int y1, int x2, int y2)
{
    LogInfo << "TrainAnaEngine mtareaImage start";
    //LogInfo << "TrainAnaEngine mtareaImage x1:"<<x1;
    //LogInfo << "TrainAnaEngine mtareaImage y1:"<<y1;
    //LogInfo << "TrainAnaEngine mtareaImage x2:"<<x2;
    //LogInfo << "TrainAnaEngine mtareaImage y2:"<<y2;
    cv::Mat mtTempImage = inImage;
    
    cv::Rect recArea = cv::Rect(x1, y1, abs(x2 - x1), abs(y2 - y1));
    cv::Mat mtOutImage = mtTempImage(recArea);

    //LogInfo << "TrainAnaEngine mtareaImage out cols:"<< mtOutImage.cols;
    //LogInfo << "TrainAnaEngine mtareaImage out rows:"<< mtOutImage.rows;
    LogInfo << "TrainAnaEngine mtareaImage end";
    return mtOutImage;
}

/**
* 图像灰度化
* inParam : 原始图片的Mat值
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtgrayImage(cv::Mat inImage, int mode)
{
    LogInfo << "TrainAnaEngine mtgrayImage start";
    cv::Mat mtTempImage = inImage;
    cv::Mat mtOutImage;
    cv::cvtColor(mtTempImage, mtOutImage, mode);
    LogInfo << "TrainAnaEngine mtgrayImage end";
    return mtOutImage;
}

/**
* 图像直方图均衡化
* inParam : 原始图片的Mat值
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtequalizeImage(cv::Mat inImage)
{
    LogInfo << "TrainAnaEngine mtequalizeImage start";
    cv::Mat mtTempImage = inImage;
    cv::Mat mtOutImage;

    cv::equalizeHist(mtTempImage, mtOutImage);
    LogInfo << "TrainAnaEngine mtequalizeImage end";
    return mtOutImage;
}
/**
* 图像进行gamma变换
* inParam : 原始图片的Mat值
* inParam : gamma值
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtGammaImage(cv::Mat inImage, float fgamma = 1.0)
{
    LogInfo << "TrainAnaEngine mtGammaImage start";
    //LogInfo << "TrainAnaEngine mtGammaImage fgamma:"<<fgamma;
    cv::Mat mtTempImage = inImage;
    cv::Mat mtOutImage;

    for (int i = 0; i < mtTempImage.rows; i++){
        for (int j = 0; j < mtTempImage.cols; j++) {
            mtTempImage.at<uchar>(i, j) = 6*pow((double)inImage.at<unsigned char>(i, j), fgamma);
        }
    }
    cv::normalize(mtTempImage, mtTempImage, 0, 255, NORM_MINMAX);
    cv::convertScaleAbs(mtTempImage, mtOutImage);
    LogInfo << "TrainAnaEngine mtGammaImage end";
    return mtOutImage;
}


/**
* 图像进行自定义处理
* inParam : 原始图片的Mat值
* outParam: N/A
* return  : 图像Mat值
*/
cv::Mat TrainAnaEngine::mtspecImage(cv::Mat inImage)
{
    LogInfo << "TrainAnaEngine mtspecImage start";
    cv::Mat mtTempImage = inImage;
    cv::Mat mtOutImage;
    //中值滤波，降采样
    cv::medianBlur(inImage,mtTempImage,3);
    cv::resize(mtTempImage, mtOutImage, Size((int)(mtTempImage.rows*0.5),(int)(mtTempImage.cols*0.5) ), INTER_LINEAR);
    LogInfo << "TrainAnaEngine mtspecImage end";
    return mtOutImage;
}

/*
* 获取最近100帧的dComparePoint的最大值与最小值之差
* inParam : 第i个方框的dComparePoint值
* inParam : 第i个框的索引
* outParam: N/A
* return  : N/A
*/
float TrainAnaEngine::GetPointMaxReduceMin(float dComparePoint,int index){
    static float  array[20] ={0.0};
    switch (index)
    {
    case 0:
    static int num_count1=0;
    static float  array1[20] ={0.0};
    array1[num_count1]=dComparePoint;
    num_count1++;
    if (num_count1>19){
        num_count1=0;
    }
    for(int i=0;i<=19;i++){
        array[i]=array1[i];
    }
    break;


    case 1:
    static int num_count2=0;
    static float  array2[20] ={0.0};
    array2[num_count2]=dComparePoint;
    num_count2++;
    if (num_count2>19){
        num_count2=0;
    }
    for(int i=0;i<=19;i++){
        array[i]=array2[i];
    }
    break;


    case 2:
    static int num_count3=0;
    static float  array3[20] ={0.0};
    array3[num_count3]=dComparePoint;
    num_count3++;
    if (num_count3>19){
        num_count3=0;
    }
    for(int i=0;i<=19;i++){
        array[i]=array3[i];
    }
    break;
    }

    sort(array,array+20);
    return (array[19]-array[0]);
}
/**
* 来车动态检测
* inParam : 原始图片的Mat值
* inParam : 原始图片的时间戳
* outParam: N/A
* return  : N/A
*/
void TrainAnaEngine::checkAction(cv::Mat baseimg, uint64_t i64TimeStamp)
{
    #ifdef SHOW_RECTANGLE
    cv::Mat img=baseimg.clone(); 
    cv::Scalar sca(0,0,255);
    #endif


    //count[5]记录选择区域的状态为来车所保持的帧数，当帧数大于5时，改变选择区域的状态为来车
    static int count[5]={0};
    LogInfo << "TrainAnaEngine checkAction start";
    // 记录上一帧的行车状态
    nPreStatus = nStatus;
    // 记录上一帧的动态变化情况
    nPrePicAreaChangeing = nPicAreaChangeing;
    // 初始化当前帧的动态变化情况
    nPicAreaChangeing = 0x00;
    // 检测区域数量
    int nlistlen = lstAction.size();
    //LogInfo << "TrainAnaEngine checkAction nlistlen:" << nlistlen;
    //LogInfo << "TrainAnaEngine checkAction i64TimeStamp:" << i64TimeStamp;

    
    for (int i = 0; i < nlistlen; i++)
    {
        // 根据检测区域切分当前帧
        cv::Mat cvImg1 = mtareaImage(baseimg, lstAction[i].nAreaX1, lstAction[i].nAreaY1, lstAction[i].nAreaX2, lstAction[i].nAreaY2);
        cvImg1 = mtImproveImage(cvImg1, lstAction[i], false);
        // 根据检测区域切分基础帧
        cv::Mat cvImg2 = mtareaImage(cvFirstImg, lstAction[i].nAreaX1+5, lstAction[i].nAreaY1+5, lstAction[i].nAreaX2-5, lstAction[i].nAreaY2-5);
        cvImg2 = mtImproveImage(cvImg2, lstAction[i], false);
        // 获取比对数值
        std::vector<double> lstRet = getCompPoint(lstAction[i], cvImg1, cvImg2);
        // 记录上一帧比对数值
        lstAction[i].dPreComparePoint = lstAction[i].dComparePoint;
        // 记录当前帧比对数值
        lstAction[i].dComparePoint = lstRet[0];
        //LogInfo << "TrainAnaEngine checkAction i:" << i;
        //LogInfo << "TrainAnaEngine checkAction nlistlen:" << nlistlen;
        //LogInfo << "TrainAnaEngine checkAction nStatus:" << nStatus;
        //LogInfo << "TrainAnaEngine checkAction lstAction[i].dComparePoint:" << lstAction[i].dComparePoint;
        //LogInfo << "TrainAnaEngine checkAction lstAction[i].dSameThresholdVal:" << lstAction[i].dSameThresholdVal;

        #ifdef SHOW_RECTANGLE
        //方框的位置
        cv::Rect rect(lstAction[i].nAreaX1,lstAction[i].nAreaY1,(lstAction[i].nAreaX2-lstAction[i].nAreaX1),(lstAction[i].nAreaY2-lstAction[i].nAreaY1));
        //point1当前的方框状态显示的位置
        cv::Point point(lstAction[i].nAreaX1,lstAction[i].nAreaY1-90);
        //point2时当前的方框相似度的值显示的位置
        cv::Point point2(lstAction[i].nAreaX1,lstAction[i].nAreaY1-60);
        //point2时当前的方框累加的值显示的位置
        cv::Point point3(lstAction[i].nAreaX1,lstAction[i].nAreaY1-30);
        cv::rectangle(img,rect,sca,3); 
        #endif
        
        // 比对数值小于设定的阈值则判断检测区域发生变化
         if (lstAction[i].dComparePoint < lstAction[i].dSameThresholdVal){
            //LogInfo << "TrainAnaEngine checkAction start nPicAreaChangeing:" << nPicAreaChangeing;
            // 设定状态 当前区域存在变化
            count[i]++;
            if(count[i]>=5){    
                // nPicAreaChangeing += 0x00000001 << i;
                lstAction[i].bChanged = true;
                if(count[i]>10)
                count[i]=10;
            }
            //LogInfo << "TrainAnaEngine checkAction end nPicAreaChangeing:" << nPicAreaChangeing;
        }else{
            count[i]--;
            if(count[i]<=0){
                count[i]=0;
                //nPicAreaChangeing =(nPicAreaChangeing&(~(0x00000001<<i)));
                lstAction[i].bChanged = false;
            }       
        }
 
        #ifdef SHOW_RECTANGLE
        if( lstAction[i].bChanged){
            cv::putText(img,"yes",point,5,1.5,sca,3);
            LogInfo<<"current img id   "<<num << "  yes";
        }else{
            cv::putText(img,"no",point,5,1.5,sca,3);
            LogInfo<<"current img id   "<<num << "  no";
        } 
        cv::putText(img,"similarity: "+to_string((int)((lstAction[i].dComparePoint)*1000)),point2,5,1.5,sca,3);
         LogInfo<<"current img id   "<<num << "  similarity:  "<<(int)((lstAction[i].dComparePoint)*1000);
        #endif
        


        // 如果最近100帧的最大值与最小值小于0.03视为无变化
        if (GetPointMaxReduceMin(lstAction[i].dComparePoint,i)< 0.03){
            lstAction[i].fluctuationFlag=true;
        }else{
            lstAction[i].fluctuationFlag=false;
        }

        #ifdef SHOW_RECTANGLE
        if(lstAction[i].fluctuationFlag){
            cv::putText(img,"fluctuation Low",point3,5,1.5,sca,3);
            LogInfo<<"current img id   "<<num << "  fluctuation Low";
        }else{
            cv::putText(img,"fluctuation High",point3,5,1.5,sca,3);
            LogInfo<<"current img id   "<<num << "  fluctuation High";
        }
        #endif

        lstAction[i].bPreChanged = lstAction[i].bChanged;
    }
    
    //LogInfo << "TrainAnaEngine checkAction nStatus:" << nStatus;
    //LogInfo << "TrainAnaEngine checkAction nPicAreaChangeing:" << nPicAreaChangeing;
    //LogInfo << "TrainAnaEngine checkAction nPrePicAreaChangeing:" << nPrePicAreaChangeing;





    /************************************************状态切换****************************************************************/
    // 状态无车（并进行基础帧替换） -> 检测有车
    if (nStatus == TRAIN_INIT_STATUS){
        //LogInfo << "TrainAnaEngine checkAction TRAIN_INIT_STATUS start";
        // 动态检测区域状态是否发生变化 true 发生 false 未发生
        bool bStatuschanged = false;
        //根据方框的编号以及对应的状态判断当前来车的方向以及有无来车
        //0对应左侧方框一，1对应中间方框
        if((lstAction[0].bChanged&&lstAction[1].bChanged&&(!lstAction[2].bChanged))||(lstAction[0].bChanged&(!lstAction[1].bChanged)&lstAction[2].bChanged)){
            nStatus = TRAIN_RIGHT_RUN;
            bStatuschanged = true;
        }else if(lstAction[1].bChanged&&lstAction[2].bChanged&&(!lstAction[0].bChanged)){
            nStatus = TRAIN_LEFT_RUN;
            bStatuschanged = true;
        }
        // }else if(lstAction[0].bChanged&&lstAction[1].bChanged&&lstAction[2].bChanged){
        //     nStatus = TRAIN_RIGHT_RUN;
        //     bStatuschanged = true;
        // }

        // 状态发生变化
        if (bStatuschanged == true) {
            // 开始记录车厢划分信息/添加一节车厢划分信息
            PartionInfo stTempInfo;
            stTempInfo.nindex = 1;
            stTempInfo.startframe = 1;
            stTempInfo.i64StartTimeStamp = i64TimeStamp;
            lstPartInfo.push_back(stTempInfo);            
        } 

         //基础帧替换的第一种情况。
        //用于计算高校相似度保持的帧数，当帧数保持10帧以上则进行帧替换
        static int count_num=0;
        bool bEmpty1=true;
        for (int i = 0; i < nlistlen; i++) {
           bEmpty1=bEmpty1&&(lstAction[i].dPreComparePoint>=0.95);
        }
        if (bEmpty1){
            count_num++;
            if(count_num>=10) {
                // 没有发生变化，则将该帧作为基础帧       
                cvFirstImg = baseimg;

                count_num=0;           
            }
        }else{
            count_num=0;
        }


        //基础帧替换的第二种情况,过车后引起的相似度下降，需要最近100帧相似度波动小于0.03
        bool bEmpty2=true;
        static int count_num2=0;
        for (int i = 0; i < nlistlen; i++) {
           bEmpty2=bEmpty2&&(!lstAction[i].bChanged);
           bEmpty2=bEmpty2&&(lstAction[i].fluctuationFlag);
        }
        if(bEmpty2){
             count_num2++;
             if(count_num2>100){
                cvFirstImg = baseimg;
                count_num2=0;
             }          
        }else{
            count_num2=0;
        }

        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  train no";
        cv::putText(img,"train no",cv::Point(150,200),5,4,sca,3);
        #endif 

    }else if(nStatus == TRAIN_LEFT_RUN){
        bool bpaused = false;
        bool bpassed = false;
        bool noFluctuationFlag = true;
        unsigned short int bpaused_count = 0;


        //0,1,2全部无改变，相似度较高，视为车辆已经过去
        //0改变，1，2无变化仍视为车辆已经过去
        if(
        (!lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(!lstAction[2].bChanged)||
        (lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(!lstAction[2].bChanged)){ 
            bpassed=true;    

        }

        for (int i = 0; i < nlistlen; i++)
        {
            //任意两个及以上改变视为停车
            if(lstAction[i].bChanged){
                bpaused_count++;
            }
            noFluctuationFlag = (noFluctuationFlag && lstAction[i].fluctuationFlag);
        }

        bpaused=((bpaused_count>=2 )&& noFluctuationFlag);
        bpassed=(bpassed && noFluctuationFlag);

         //计算累计帧数
        static unsigned short int count1=0;
        static unsigned short int count2=0;
           // 状态 有车 -> 停车
        if (bpaused == true)
        {
            count1++;
            if(count1>50){
                nStatus = TRAIN_PAUSE;
                count1=0;
                count2=0;
            }  
        }else{
            count1=0;
        }
        // 状态 有车 -> 完全通过
        if (bpassed == true)
        {
            count2++;
            if(count2>50){
                nStatus = TRAIN_PASSED;
                count1=0;
                count2=0;
            } 
        }else{
            count2=0;
            
        }

        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  director left ";
        cv::putText(img,"director left",cv::Point(150,200),5,4,sca,3);    
        #endif

    }else if (nStatus == TRAIN_RIGHT_RUN){
        bool bpaused = false;
        bool bpassed = false;
        bool noFluctuationFlag = true;
        unsigned short int bpaused_count = 0;

        //0,1,2全部无改变，相似度较高，视为车辆已经过去
        //2改变，0,1无变化仍视为车辆已经过去
        if(
        (!lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(!lstAction[2].bChanged)||
        (!lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(lstAction[2].bChanged)){ 
            bpassed=true;    
        }

        for (int i = 0; i < nlistlen; i++)
        {
            //任意两个及以上改变视为停车
            if(lstAction[i].bChanged){
                bpaused_count++;
            }
            noFluctuationFlag = (noFluctuationFlag && lstAction[i].fluctuationFlag);
        }

        bpaused=((bpaused_count>=2 )&& noFluctuationFlag);
        bpassed=(bpassed && noFluctuationFlag);

         //计算累计帧数
        static unsigned short int count1=0;
        static unsigned short int count2=0;
          // 状态 有车 -> 停车
        if (bpaused == true)
        {
            count1++;
            if(count1>50){
                nStatus = TRAIN_PAUSE;
                count1=0;
                count2=0;
            }  
        }else{
            count1=0;
        }
        // 状态 有车 -> 完全通过
        if (bpassed == true)
        {
            count2++;
            if(count2>50){
                nStatus = TRAIN_PASSED;
                count1=0;
                count2=0;
            } 
        }else{
            count2=0;
        }
        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  director right ";
        cv::putText(img,"director right",cv::Point(150,200),5,4,sca,3);    
        #endif
    }else if (nStatus == TRAIN_UNKOWN_RUN){

        bool bpaused = false;
        bool bpassed = false;
        bool noFluctuationFlag = true;
        unsigned short int bpaused_count = 0;
        //0,1,2全部无改变，相似度较高，视为车辆已经过去
        //2改变，0,1无变化仍视为车辆已经过去,或者0给改变，12无变化
        if(
        (!lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(!lstAction[2].bChanged)||
        (!lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(lstAction[2].bChanged)||
        (lstAction[0].bChanged)&&(!lstAction[1].bChanged)&&(!lstAction[2].bChanged)
        ){ 
            bpassed=true;    
        }

        for (int i = 0; i < nlistlen; i++)
        {
            //任意两个及以上改变视为停车
            if(lstAction[i].bChanged){
                bpaused_count++;
            }
            noFluctuationFlag = (noFluctuationFlag && lstAction[i].fluctuationFlag);
        }

        bpaused=((bpaused_count>=2 )&& noFluctuationFlag);
        bpassed=(bpassed && noFluctuationFlag);

        //计算累计帧数
        static unsigned short int count1=0;
        static unsigned short int count2=0;
        // 状态 有车 -> 停车
        if (bpaused == true)
        {
            count1++;
            if(count1>50){
                nStatus = TRAIN_PAUSE;
                count1=0;
                count2=0;
            }  
        }else{
              count1=0;
        }
        // 状态 有车 -> 完全通过
        if (bpassed == true)
        {
            count2++;
            if(count2>50){
                nStatus = TRAIN_PASSED;
                count1=0;
                count2=0;
            } 
        }else{
                count2=0;
        }

        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  director unkonw ";
        cv::putText(img,"director unkonw",cv::Point(150,200),5,4,sca,3);    
        #endif
    }else if(nStatus == TRAIN_PAUSE){
        static short int count=0; 
        //停车状态只检测波动，三块全部波动保持20帧即重启
        if(!lstAction[0].fluctuationFlag&&!lstAction[1].fluctuationFlag&&!lstAction[2].fluctuationFlag){
            if(count>20){
              nStatus=TRAIN_RESTART;
              count=0;
            }
            count++;
        }
        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  train stop ";
        cv::putText(img,"train stop",cv::Point(150,200),5,4,sca,3);
        #endif 
    }else if(nStatus == TRAIN_RESTART){
        //切换到TRAIN_UNKOWN_RUN
        nStatus=TRAIN_UNKOWN_RUN;
        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  train restort ";
        cv::putText(img,"train restort",cv::Point(150,200),5,4,sca,3);
        #endif 
    }else if(nStatus == TRAIN_PASSED){
        //切换回TRAIN_INIT_STATUS状态
        nStatus = TRAIN_INIT_STATUS;
        #ifdef SHOW_RECTANGLE
        LogInfo<<"current img id   "<<num << "  train passed ";
        cv::putText(img,"train passed",cv::Point(150,200),5,4,sca,3);
        #endif 
    }

    if(nStatus!=TRAIN_INIT_STATUS){
        #ifdef SHOW_RECTANGLE
        if(num%4==0){
            LogInfo<<"current img id   "<<num << "  state:  "<<nStatus;
            cv::putText(img,"state: "+to_string(nStatus),cv::Point(150,400),5,4,sca,5);  
            imwrite(to_string(num)+".jpg",img);
        }
        #endif 
    }

    LogInfo << "TrainAnaEngine checkAction end";
}

/**
* 车厢划分检测
* inParam : 原始图片的Mat值
* inParam : 原始图片的时间戳
* outParam: N/A
* return  : N/A
*/
bool TrainAnaEngine::checkPartion(cv::Mat baseimg, uint64_t i64TimeStamp)
{
    LogInfo << "TrainAnaEngine checkPartion start";
    // 初始化是否有划分信息
    bool bPartion = false;
    // 记录上一帧的判断等级(相同作and处理 不同作or处理)
    int nPreOrLevel = 1;
   // LogInfo << "TrainAnaEngine checkPartion nStatus:" << nStatus;
    // 停车状态不进行划分信息检测
    //if(false){
    if ((nStatus == TRAIN_PAUSE) 
        || (nStatus == TRAIN_INIT_STATUS)
        || (nStatus == TRAIN_PASSED)){    
        return bPartion;
    }
    //LogInfo << "TrainAnaEngine checkPartion lstPartion.size():" << lstPartion.size();
    // 根据判断算法的数量进行循环比对
    bPartion = true;
    for (int i = 0; i < lstPartion.size(); i++)
    {
        //LogInfo << "TrainAnaEngine checkPartion i:" << i;
        // 算法不开启则跳过
        if (lstPartion[i].bOn == false)
        {
            //LogInfo << "TrainAnaEngine checkPartion lstPartion[i].bOn  i:" << i;
            continue;
        }

        // 对当前帧图片进行切割
        cv::Mat baseimgin = mtareaImage(baseimg, lstPartion[i].nAreaX1, lstPartion[i].nAreaY1, lstPartion[i].nAreaX2, lstPartion[i].nAreaY2);
        // 对当前帧图片进行画面增强
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 cols:" << baseimgin.cols;
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 rows:" << baseimgin.rows;
        cv::Mat cvImg1 = mtImproveImage(baseimgin, lstPartion[i], false);
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 cols:" << cvImg1.cols;
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 rows:" << cvImg1.rows;
        cv::Mat cvImg2;
        //LogInfo << "TrainAnaEngine checkPartion lstPartion[i].baseImagePath:" << lstPartion[i].baseImagePath;
        if (lstPartion[i].baseImagePath == "None")
        {   
            cv::Mat cvFirstImgin = mtareaImage(cvFirstImg, lstPartion[i].nAreaX1 - 10, lstPartion[i].nAreaY1 -10, lstPartion[i].nAreaX2 -10, lstPartion[i].nAreaY2 -10);
            // 设定为None 用基础图像进行比对
            cvImg2 = mtImproveImage(cvFirstImgin, lstPartion[i], false);
        }
        else
        {
            // 设定有路径则读取路径的文件进行比对
            cvImg2 = cv::imread(lstPartion[i].baseImagePath, cv::IMREAD_GRAYSCALE);
            // cvImg2 = mtdecodeImageDatabyFile(lstPartion[i].baseImagePath);
            // 图像增强
            cvImg2 = mtImproveImage(cvImg2, lstPartion[i], true);
        }
        // 获取比对值
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 cols:" << cvImg1.cols;
        //LogInfo << "TrainAnaEngine checkPartion cvImg1 rows:" << cvImg2.rows;

        std::vector<double> lstRet = getCompPoint(lstPartion[i], cvImg1, cvImg2);
        lstPartion[i].dComparePoint = lstRet[0];
        //LogInfo << "TrainAnaEngine checkPartion lstPartion[i].dComparePoint:" << lstPartion[i].dComparePoint;

        // 获取是相同还是不同作为判断标准
        bool bCurrentRet = (lstPartion[i].bDiff == true) ? lstPartion[i].dComparePoint < lstPartion[i].dDiffThresholdVal : lstPartion[i].dComparePoint > lstPartion[i].dSameThresholdVal;
        // 对比等级不同 进行判断结果OR处理
        if (lstPartion[i].bOrLevel != nPreOrLevel)
        {
            //LogInfo << "TrainAnaEngine checkPartion lstPartion[i].bOrLevel != nPreOrLevel";
            bPartion = bPartion || bCurrentRet;
        }
        // 比对等级相同 进行判断结果AND处理
        else
        {
            //LogInfo << "TrainAnaEngine checkPartion lstPartion[i].bOrLevel == nPreOrLevel";
            bPartion = bPartion && bCurrentRet;
        }
        // 判断结果存在false的情况 直接停止判断确定没有车厢划分信息
        if (bPartion == false)
        {
            //LogInfo << "TrainAnaEngine checkPartion bPartion == false";
            break;
        }
    }
    // 存在车厢划分信息
    if (bPartion == true)
    {
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true for end";
        // nPartionPassFrameCount = 0;
        // 获取最新的车厢节数
        int nPrePartionIndex = lstPartInfo.size() - 1;
        
        // 获取时间戳
        lstPartInfo[nPrePartionIndex].i64EndTimeStamp = i64TimeStamp;
        // 根据开始帧时间戳和结束帧时间错 计算当节车厢的行车速度
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].ftime：" << abs(lstPartInfo[nPrePartionIndex].i64EndTimeStamp - lstPartInfo[nPrePartionIndex].i64StartTimeStamp);
        // 根据时间戳计算时间差
        float nTimePassed = (abs(lstPartInfo[nPrePartionIndex].i64EndTimeStamp - lstPartInfo[nPrePartionIndex].i64StartTimeStamp)) * 1.0;
        lstPartInfo[nPrePartionIndex].fspeed = (TRAIN_WIDTH * 1000.0) /nTimePassed;
        // 
        //nSamePartionIgnoreCount = (nTimePassed / (3 * 5000)) * nFrameRate;
        // 结束帧为当前帧再往后 (除以2的原因：中间为车钩，车钩后的车体宽度为整个镜头的宽度除以2)
        lstPartInfo[nPrePartionIndex].endframe = nLatestFrame + getOffsetFrame(lstPartInfo[nPrePartionIndex].fspeed, (TRAIN_IN_CAMERA_WIDTH / 2), nFrameRate);
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].endframe" << lstPartInfo[nPrePartionIndex].endframe;
        lstPartInfo[nPrePartionIndex].bfuncconfirmed = true;
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].i64EndTimeStamp：" << lstPartInfo[nPrePartionIndex].i64EndTimeStamp;
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].i64StartTimeStamp:" << lstPartInfo[nPrePartionIndex].i64StartTimeStamp;
        // 如果时间戳相同则不是划分信息
        if (lstPartInfo[nPrePartionIndex].i64EndTimeStamp == lstPartInfo[nPrePartionIndex].i64StartTimeStamp) {
            bPartion = false;
            return bPartion;
        }

        
        //LogInfo << "TrainAnaEngine checkPartion nPrePartionIndex" << nPrePartionIndex;
        //LogInfo << "TrainAnaEngine checkPartion lstPartInfo[nPrePartionIndex].i64EndTimeStamp" << lstPartInfo[nPrePartionIndex].i64EndTimeStamp;
        //LogInfo << "TrainAnaEngine checkPartion lstPartInfo[nPrePartionIndex].nLatestFrame" << nLatestFrame;
        //LogInfo << "TrainAnaEngine checkPartion lstPartInfo[nPrePartionIndex].fspeed:" << lstPartInfo[nPrePartionIndex].fspeed;
        //LogInfo << "TrainAnaEngine checkPartion lstPartInfo[nPrePartionIndex].endframe" << lstPartInfo[nPrePartionIndex].endframe;
        //LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].fspeed:" << lstPartInfo[nPrePartionIndex].fspeed;
    }
    LogInfo << "TrainAnaEngine checkPartion end";
    return bPartion;
}

/**
* 计算车钩从中间到边缘的间隔帧
* inParam : 行车速度(单位:米/秒)
* inParam : 宽度
* inParam : 相机帧率(单位:帧/秒)
* outParam: N/A
* return  : 间隔帧
*/
int TrainAnaEngine::getOffsetFrame(float fspeed, int width, int nFrameRate)
{
    LogInfo << "TrainAnaEngine getOffsetFrame start";
    //LogInfo << "TrainAnaEngine getOffsetFrame fspeed:" << fspeed;
    //LogInfo << "TrainAnaEngine getOffsetFrame width:" << width;
    //LogInfo << "TrainAnaEngine getOffsetFrame nFrameRate:" << nFrameRate;
    //LogInfo << "TrainAnaEngine getOffsetFrame nLatestFrame:" << nLatestFrame;
    //偏移值 = (中间到边缘的宽度(米) / 速度(米/秒)->时间(秒))* 帧率(帧/秒)
    float ftmp = width * (float) nFrameRate;
    //LogInfo << "TrainAnaEngine getOffsetFrame start end:" << ftmp;
    ftmp = ftmp / fspeed;
    //LogInfo << "TrainAnaEngine getOffsetFrame start end:" << ftmp;
    int nRet = (int) ftmp;
    LogInfo << "TrainAnaEngine getOffsetFrame start end:" << nRet;
	return nRet;
}


/**
* 计算车钩移动的像素值
* inParam : 行车速度(单位:米/秒)
* inParam : 宽度
* inParam : 相机帧率(单位:帧/秒)
* outParam: N/A
* return  : 间隔帧
*/
int TrainAnaEngine::getCouplerOffsetPosition(float fspeed, int nframeindex)
{
    LogInfo << "TrainAnaEngine getCouplerOffsetPosition start";
    //LogInfo << "TrainAnaEngine getCouplerOffsetPosition fspeed:" << fspeed;
    //LogInfo << "TrainAnaEngine getCouplerOffsetPosition start:" << nframeindex;
    //单位换算
    // 米/秒 -> 米/帧
    // 米/帧 = 米/秒 * 秒/帧(即:1/帧率)
    float fmeter_frame = fspeed / nFrameRate;
    //LogInfo << "TrainAnaEngine getCouplerOffsetPosition fmeter_frame:" << fmeter_frame;
    // 米/帧 -> 像素/帧
    // 像素/帧 = 米/帧 * 像素/米
    float fpix_frame = fmeter_frame * (METHOD_BASE_WIDTH / TRAIN_IN_CAMERA_WIDTH);
    //LogInfo << "TrainAnaEngine getCouplerOffsetPosition fpix_frame:" << fpix_frame;

    int nretPixOffet = (int)fpix_frame;
    nretPixOffet = nretPixOffet * nframeindex;
    //LogInfo << "TrainAnaEngine getCouplerOffsetPosition nretPixOffet:" << nretPixOffet;
    LogInfo << "TrainAnaEngine getCouplerOffsetPosition end";
    return nretPixOffet;
}

int TrainAnaEngine::getTailPixOffset()
{
    LogInfo << "TrainAnaEngine getTailPixOffset start";
    // 单位计算
    // 帧宽像素/米
    float fframewidth_meter = ((METHOD_BASE_WIDTH * 1.0) / (TRAIN_IN_CAMERA_WIDTH));
    //LogInfo << "TrainAnaEngine getTailPixOffset fframewidth_meter:" << fframewidth_meter;
    // 车尾车钩像素位置
    float fOffsetPosistion = TRAIN_WIDTH * fframewidth_meter;
    //LogInfo << "TrainAnaEngine getTailPixOffset fOffsetPosistion:" << fOffsetPosistion;

    int nretOffset = (int)fOffsetPosistion;
    //LogInfo << "TrainAnaEngine getTailPixOffset nretOffset:" << nretOffset;
    //LogInfo << "TrainAnaEngine getTailPixOffset end";
    return nretOffset;
}


APP_ERROR TrainAnaEngine::Process()
{
    int iRet = APP_ERR_OK;
    //程序启动标志位
    bool bInited = false;
    while (!isStop_)
    {
        std::shared_ptr<void> pVoidData0 = nullptr;
        inputQueMap_[strPort0_]->pop(pVoidData0);
        if (nullptr == pVoidData0)
        {
            usleep(1000); //1ms
            continue;
        }

        LogInfo << "TrainAnaEngine Process start";
        std::shared_ptr<DecodedData> pDecodeData = std::static_pointer_cast<DecodedData>(pVoidData0);
        std::shared_ptr<void> pHostData = nullptr;

        //获取图像数据
        cv::Mat matYUV(pDecodeData->iHeight * 3 / 2, pDecodeData->iWidth, CV_8UC1);
        int iCopySize = pDecodeData->iWidth * pDecodeData->iHeight * 3 / 2;
        memcpy(matYUV.data, pHostData.get(), iCopySize);

        // 将YUV格式灰度化之后修改图像尺寸
	    cv::Mat cvtemp;
	    cv::cvtColor(matYUV, cvtemp, cv::COLOR_YUV2GRAY_420);
	    //cv::imwrite("/home/HwHiAiUser/1.jpg",cvtemp);
        matYUV = mtresizeImage(cvtemp, METHOD_BASE_WIDTH, METHOD_BASE_HEIGHT);
        //来车
        //cv::Mat baseimg = mtdecodeImageDatabyBin(lpimgdata, imglen);
        //cv::Mat baseimg = matYUV.data;
        //程序启动第一帧跳过 保存为基础图像
        if (bInited == false) {
            cvFirstImg = matYUV;
            bInited = true;
            nFrameRate = pDecodeData->iRate;
            continue;
        }
        LogInfo << "TrainAnaEngine Process pDecodeData.i64TimeStamp:" << pDecodeData->i64TimeStamp;
        ncurtime = pDecodeData->i64TimeStamp;
        //来车状态检测
        checkAction(matYUV, pDecodeData->i64TimeStamp);

        //判断是否有来车
        pDecodeData->iStatus = (nStatus == TRAIN_LEFT_RUN || nStatus == TRAIN_RIGHT_RUN || nStatus == TRAIN_UNKOWN_RUN || nStatus == TRAIN_RESTART) ? 1 : ( nStatus == TRAIN_PAUSE)? 2 : 0;
        //判断来车方向 0 方向未知/无车 1右侧来车(向左行驶:模型识别用) 2左侧来车(向右行驶:模型识别用)
        pDecodeData->iDirection = ((nStatus == TRAIN_LEFT_RUN) ? 1 : ((nStatus == TRAIN_RIGHT_RUN) ? 2 : 0));
        //列车是否通过
        pDecodeData->bIsEnd = (nStatus == TRAIN_PASSED || nStatus == TRAIN_RESTART ) ? true : false;
        LogInfo << "TrainAnaEngine Process pDecodeData->iStatus:" << pDecodeData->iStatus;
        //LogInfo << "TrainAnaEngine Process pDecodeData->iDirection:" << pDecodeData->iDirection;
        //新过车创建文件夹
        if ((nStatus != TRAIN_INIT_STATUS && nPreStatus == TRAIN_INIT_STATUS) ||
            ( nPreStatus == TRAIN_RESTART && nStatus == TRAIN_UNKOWN_RUN))
        {
            strTrainData_ = MyUtils::getins()->GetDate();
            strTrainName_ = MyUtils::getins()->GetTime();
            std::string strTrainPath = strResultPath_ + strTrainData_ + "/" + strTrainName_ + "/";
            MyUtils::getins()->CreateDirPath(strTrainPath);
        }
        //过车日期
        pDecodeData->strTrainDate = strTrainData_;
        //过车时间
        pDecodeData->strTrainName = strTrainName_;

       // iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pDecodeData));

        //当前帧是否有划分信息
        bool bPartionExist = false;
        
        //有车的状态进行车厢划分检测
        if (nStatus != TRAIN_INIT_STATUS){
            //LogInfo << "TrainAnaEngine Process nPartionPassFrameCount:" << nPartionPassFrameCount;
            //LogInfo << "TrainAnaEngine Process nSamePartionIgnoreCount:" << nSamePartionIgnoreCount;
            //检测到划分状态的情况下 进行跳帧处理
            //跳帧值为计算的车体通过三分之一之后的帧
            if (nPartionPassFrameCount < nSamePartionIgnoreCount) {
                nPartionPassFrameCount++;
            } else {
                //超过跳帧进行车厢划分检测
                bPartionExist = checkPartion(matYUV, pDecodeData->i64TimeStamp);
                //如果检测到车厢划分信息则检测跳帧的值
                if (bPartionExist == true) {
                    nPartionPassFrameCount = 0;
                }
            }
        }

        /// write json info to file

        //先读取文本内容，追加新的信息后再写入
        //划分信息 JSON格式
        Json::Value jvPartionInfo;
        //JSON保存路径
        std::string strFilePath;
        //当然车厢通过的数量
        int nPartionIndex = lstPartInfo.size() - 1;

        LogInfo << "TrainAnaEngine Process nPartionIndex:" << nPartionIndex;
        LogInfo << "TrainAnaEngine Process bPartionExist:" << bPartionExist;
        //检测到车厢划分信息
        if ((bPartionExist == true)) {
            strFilePath = strResultPath_ + pDecodeData->strTrainDate + "/" + pDecodeData->strTrainName + "/" 
                        + std::to_string(nPartionIndex + 1) + ".txt";
            // 记录过车日期
            jvPartionInfo["trainDate"] = pDecodeData->strTrainDate;
            // 记录过车时间
            jvPartionInfo["trainName"] = pDecodeData->strTrainName;
            // 记录车厢节数 (索引从0开始 所以这里+1)
            jvPartionInfo["trainNo"] = nPartionIndex + 1;
            // 记录行车开始帧
            jvPartionInfo["startFrameId"] = lstPartInfo[nPartionIndex].startframe;
            // 记录行车结束帧
            jvPartionInfo["endFrameId"] = lstPartInfo[nPartionIndex].endframe;
            // 记录车厢是否完全通过
            jvPartionInfo["isEnd"] = pDecodeData->bIsEnd;

            // 首部车钩的偏移位置 (单位帧)
            int headpos = 0;
            // 尾部车钩的偏移位置 (单位帧)
            int tailpos = (0 - nTailPixOffset);

            if (nPartionIndex == 0)
            {
                headpos = METHOD_BASE_WIDTH / 2;
                tailpos = tailpos + headpos;
            }
            // 是否位右侧来车
            bool brightcome = false;
            if (nStatus == TRAIN_RIGHT_RUN)
            {    
                brightcome = true;
                // 右侧来车 首部车钩从画面最右侧开始
                headpos = METHOD_BASE_WIDTH;
                // 右侧来车 尾部车钩从画面最右侧+车厢宽的像素值
                tailpos = METHOD_BASE_WIDTH + nTailPixOffset; 

                if (nPartionIndex == 0)
                {
                    headpos = METHOD_BASE_WIDTH / 2;
                    tailpos = tailpos - headpos;
                }
            }
            

            //LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].startframe：" << lstPartInfo[nPartionIndex].startframe ;
            //LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].endframe：" << lstPartInfo[nPartionIndex].endframe;
            //从当节车厢的开始帧到结束帧计算首部车钩和尾部车钩的偏移值
            for (int nplayframe = lstPartInfo[nPartionIndex].startframe; nplayframe <= lstPartInfo[nPartionIndex].endframe; nplayframe++)
            {
                Json::Value jvposInfo;
                // 当前车厢的第几几帧
                int noffsetindex = (nplayframe - lstPartInfo[nPartionIndex].startframe);
                // 根据车速计算车钩位置量(单位 像素)
                int noffsetpos = getCouplerOffsetPosition(lstPartInfo[nPartionIndex].fspeed, noffsetindex);
                // 初始化首部车钩偏移量(单位 像素)
                jvposInfo["headpos"] = -1;
                // 初始化尾部车钩偏移量(单位 像素)
                jvposInfo["tailpos"] = -1;
                
                if (brightcome == false) {
                    // 左侧来车 
                    // 首部车钩和尾部车钩 每帧加 车钩偏移值
                    jvposInfo["headpos"] = (headpos + noffsetpos);
                    jvposInfo["tailpos"] = (tailpos + noffsetpos);
                } else {
                    // 右侧来车 
                    // 首部车钩和尾部车钩 每帧减 车钩偏移值
                    jvposInfo["headpos"] = (headpos - noffsetpos);
                    jvposInfo["tailpos"] = (tailpos - noffsetpos);
                }
                //LogInfo << "TrainAnaEngine Process jvposInfo[headpos]" << jvposInfo["headpos"];
               // LogInfo << "TrainAnaEngine Process jvposInfo[tailpos]:" << jvposInfo["tailpos"];
                //LogInfo << "TrainAnaEngine Process jvPartionListInfo.append";
                jvPartionInfo[std::to_string(nplayframe)] = jvposInfo;
            }
            
            PartionInfo stTempInfo;
            // 开始记录新的一节车厢信息(从索引变成序号+1 ，新增一节车厢信息+1)
            stTempInfo.nindex = nPartionIndex + 2;
            // 上一节车厢的结束帧  - (偏移帧 = (镜头内的车体宽度/ (速度) -> 通过时间) * 帧/秒 ) 作为下一节车厢的开始帧
            int ntempOffsetFrame = lstPartInfo[nPartionIndex].endframe - (int)(((TRAIN_IN_CAMERA_WIDTH) / lstPartInfo[nPartionIndex].fspeed) * nFrameRate);
            //LogInfo << "TrainAnaEngine Process ntempOffsetFrame:" << ntempOffsetFrame;
            stTempInfo.startframe = (ntempOffsetFrame > nSamePartionIgnoreCount) ? ntempOffsetFrame : nSamePartionIgnoreCount;
            stTempInfo.i64StartTimeStamp = pDecodeData->i64TimeStamp;
            // 初始化下一节的结束帧
            //stTempInfo.endframe = 0;

            lstPartInfo.push_back(stTempInfo);
            // 记录当前车厢的信息到JSON文件
            //MyUtils::getins()->WriteJsonInfo(jvPartionInfo, strFilePath);
            std::shared_ptr<TrainRange> pTrainRange = std::make_shared<TrainRange>();
            pTrainRange->strTrainDate = jvPartionInfo["trainDate"].asString();
            pTrainRange->strTrainName = jvPartionInfo["trainName"].asString();
            pTrainRange->iTrainIndex = jvPartionInfo["trainNo"].asInt();
            pTrainRange->iStartFrameId = jvPartionInfo["startFrameId"].asInt();
            pTrainRange->iEndFrameId = jvPartionInfo["endFrameId"].asInt();
            pTrainRange->bIsEnd = jvPartionInfo["isEnd"].asBool();
            //iRet = outputQueMap_[strPort1_]->push(std::static_pointer_cast<void>(pTrainRange));    
        }

        // 有车的情况下。记录帧数：累加1
        if (nStatus != TRAIN_INIT_STATUS)
        {
            nLatestFrame = nLatestFrame + 1;
        }
        //停车或无车(初始化相关参数)


        /*
        if ((nStatus  == TRAIN_INIT_STATUS 
            && (nStatus != TRAIN_INIT_STATUS)) || pDecodeData->bIsEnd)
        {
            vResetPartion();
        }
        */
        // 车厢通过初始化状态
        if (pDecodeData->bIsEnd) {
            vResetPartion();
        }
        LogError<<"current img id   "<<num;
        num++;

        LogInfo << "TrainAnaEngine Process end";
    }
    return APP_ERR_OK;
}