handleaiuinew/HanddleAI/HandleAiUi-new/algo/ALGO_Inspection.h

#include <back/threadPoolManager.h>
#include <halconAlgo/Inspection.h>
#include <future>
#include <chrono>
#include <algo/simpleAlgo.h>
#include <CISCO_struct.hpp>
#include <CISCO_STARGAZER.hpp>
#include <CISCO_APEX.hpp>
#include <CISCO_APEXSMALL.hpp>
#include <CISCO_ASR.hpp>
#include <templateAlgo.h>
cv::Mat pinHandleAiEvaluate(std::shared_ptr <detData> data, cv::Mat& src,
    handleAiModelSeg* segPtr, handleAiModelCls* clsPtr);
bool pinHalconEvaluate(std::shared_ptr <detData> data, cv::Rect& Result, cv::Mat& src, cv::Mat& out, int productType);

//公头定位
std::vector<handdleAI::Bbox> pinDetEvaluate(std::shared_ptr <detData> data, cv::Mat& src, handleAiModelManager* _handleAiModelManager)
{
    std::vector<handdleAI::Bbox> result;
    handleAiModelDet* detPtr = _handleAiModelManager->getDetModel("connectorDet.BHD");
    if (detPtr == nullptr)
        return std::vector<handdleAI::Bbox>();
    src = rotateImage(src, cv::Point2f(src.cols / 2, src.rows / 2), -1, 1);
    detPtr->Evaluate(src, result);
    return result;
}
std::vector<handdleAI::Bbox> getpinHandleAiEvaluateRect(std::shared_ptr <detData> data, cv::Mat& src, std::vector<handdleAI::Bbox>& detResult)
{
    std::vector<handdleAI::Bbox> result;
    //计算过滤条件
    int totalWidth = 0;
    for (auto detResult : detResult)
        totalWidth += detResult.w;
    int avgWidth = totalWidth / detResult.size();

    cv::Point centerPos(src.rows / 2, src.cols / 2);
    cv::Rect targetRect(src.cols / 4, src.rows / 4, src.cols / 2, src.rows / 2);
    for (auto detData : detResult)
    {
        if ((detData.x< targetRect.x || detData.x > targetRect.x + targetRect.width ||
            detData.y < targetRect.y || detData.y > targetRect.y + targetRect.height) == false)
        {
            result.push_back(detData);
        }
    }
    return result;
}

//主函数
int ALGO_InspectionErrorCheck(std::shared_ptr <detData> data)
{
    if (data->oriImgs.size() < 1)
    {
        qDebug() << __FUNCDNAME__ << __LINE__ << "camera Mat size is Error!";
        return 1;
    }
    if (data->productType == -1)
    {
        qDebug() << __FUNCDNAME__ << __LINE__ << "productType -1";
        return 2;
    }
    return 0;
}
void ALGO_Inspection(std::shared_ptr <detData> data, handleAiModelManager* _handleAiModelManager)
{
#if disableeAlgo
    return;
#endif
    int errorCode = ALGO_InspectionErrorCheck(data);
    if (errorCode != 0)
    {
        qDebug() << __FUNCDNAME__ << __LINE__ << "errorCheck ERR" << errorCode;
        return;
    }
    data->algoStartTime = std::chrono::high_resolution_clock::now();
    cv::Mat src = data->oriImgs[0];
    //使用det获取每个公头的位置
    std::vector<handdleAI::Bbox> detResult = pinDetEvaluate(data, src, _handleAiModelManager);
    if (detResult.size() == 0)return;

    //过滤结果，获取用于handleAi/HALCON检测的rect
    std::vector<handdleAI::Bbox> pinPos = getpinHandleAiEvaluateRect(data, src, detResult);
    //handdleAI::Bbox box;
    //box.x = 2685.22437;
    //box.y = 1868.65869;
    //box.w = 2394.87671;
    //box.h = 2542.57446;
    //box.classes = 2;
    //std::vector<handdleAI::Bbox> pinPos;
    //pinPos.push_back(box);
    //检测
    std::vector<cv::Mat>halconImgResult;
    std::vector<cv::Mat>aiImgResult;

    for (auto &connector : pinPos)
    {
        switch(connector.classes)
        {
            case 0://ASR
                halconImgResult.push_back(asrHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(asrHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 2://APEX
                halconImgResult.push_back(apexHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(apexHandleAiAlgo(data, src(BboxToRect(connector)),_handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 3://APEX BACK
                halconImgResult.push_back(apexBackHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(apexBackHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 5://STARGAZER
                halconImgResult.push_back(stargazerHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(stargazerHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 6://STARGAZER HUGE
                halconImgResult.push_back(stargazerHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(stargazerHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 1://APEX SMALL
                halconImgResult.push_back(apexSmallHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(apexSmallHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;
            case 7://APEX SMALL BACK
                halconImgResult.push_back(apexSmallBackHalconAlgo(data, src(BboxToRect(connector))));
                data->handleAiEndTime = std::chrono::high_resolution_clock::now();
                aiImgResult.push_back(apexSmalllBackHandleAiAlgo(data, src(BboxToRect(connector)), _handleAiModelManager));
                data->halconEndTime = std::chrono::high_resolution_clock::now();
                break;

        }
    }

    //平铺结果图
    if (aiImgResult.size() > 0)
        data->resultImgs.push_back(tiledImages(aiImgResult));
    if (halconImgResult.size() > 0)
        data->resultImgs.push_back(tiledImages(halconImgResult));

}