/*
 * @Author: yangzilong
 * @Date: 2021-12-16 14:25:13
 * @Last Modified by: yangzilong
 * @Email: yangzilong@objecteye.com
 * @Description:
 */
#include "GatherDetect.h"
#include "../helpers/img_util.h"

GatherDetect::GatherDetect()
{
    m_task_param_manager = task_param_manager::getInstance();
}

void GatherDetect::init(algorithm_type_t eType)
{
    m_eType = eType;
}

std::vector<GatherResult> GatherDetect::process(vector<DeviceMemory*> vec_vptMem, vector<onelevel_det_result> &ol_det_result) {
    std::vector<GatherResult> results;

    map<string, algor_open_config_param> && algor_config_param = m_task_param_manager->get_task_algor_params();
    map<string, map<algo_type, task_param_manager::algo_param_type_t_*>> && algor_param = m_task_param_manager->get_task_other_params();

    for (size_t idx = 0; idx < vec_vptMem.size(); idx++)
    {
        DeviceMemory* cur_vptMem = vec_vptMem[idx];
        string task_id = cur_vptMem->getId();

        auto it_algor = algor_param.find(task_id);
        if (it_algor == algor_param.end()) {
            continue;
        }

        task_param_manager::algo_param_type_t_* cur_task_params = algor_param[task_id][m_eType];
        if (nullptr == cur_task_params) {
            continue;
        }

        algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)cur_task_params->basic_param;
        if (basic_param == nullptr || basic_param->adapt_param == nullptr) {
            continue;
        }
        universal_algor_adapt_param *adapt_param = basic_param->adapt_param;
        
        map<string, std::vector<box_t>> taskid_to_boxes;

        onelevel_det_result &cur_task_ol_detres = ol_det_result[idx];
        for (int c = 0; c < cur_task_ol_detres.obj_count; c++)
        {
            auto& obj_c = cur_task_ol_detres.obj[c];

            bool bHuman = m_eType == algorithm_type_t::HUMAN_GATHER || m_eType == algorithm_type_t::HUMAN_DENSITY || m_eType == algorithm_type_t::HUMAN_REGION_GATHER;

            bool bCount = false;
            if(bHuman && obj_c.index == (int)det_class_label_t::HUMAN) {
                bCount = true;
            } else if (m_eType == algorithm_type_t::VEHICLE_GATHER && obj_c.index >= 4 && obj_c.index <= 8) {
                bCount = true;
            }

            sy_point center;
            center.x_ = (obj_c.right + obj_c.left)/ 2 ;
            center.y_ = (obj_c.bottom + obj_c.top) / 2;
            // vec_pt.push_back(center);
            if (bCount && common::isInPolygon(adapt_param->points, adapt_param->points_count, center)) {
                box_t box;
                box.top = obj_c.top;
                box.left = obj_c.left;
                box.right = obj_c.right;
                box.bottom = obj_c.bottom;
                box.score = obj_c.confidence;
                taskid_to_boxes[task_id].emplace_back(std::move(box));
            }
        }

        int count_threshold = ((algor_config_param_human_gather*)cur_task_params->algor_param)->human_count_threshold;
        int frame_stride = ((algor_config_param_human_gather*)cur_task_params->algor_param)->frame_stride;

        if (taskid_to_boxes[task_id].size() > count_threshold && cur_vptMem->getFrameNb() % frame_stride == 0)
        {
            GatherResult data;
            data.origin_img = VPCUtil::vpc_devMem2vpcImg(vec_vptMem[idx]);
            data.task_id = task_id;
            data.boxes = std::move(taskid_to_boxes[task_id]);
            data.id = gid_++;
            results.emplace_back(std::move(data));
        }
    }

    return results;
}