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

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

std::vector<GatherResult> GatherDetect::process(vector<DeviceMemory*> vec_vptMem, vector<onelevel_det_result> &ol_det_result, algorithm_type_t algor_type) {
    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();
        map<string, int> taskid_obj_count;
        map<string, std::vector<box_t>> taskid_to_boxes;
        if (algor_config_param.count(task_id) && algor_config_param[task_id].human_algors.count(algor_type))
        {
            task_param_manager::algo_param_type_t_* cur_task_params = algor_param[task_id][algor_type];
            {
                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 = algor_type == algorithm_type_t::HUMAN_GATHER || algor_type == algorithm_type_t::HUMAN_DENSITY || algor_type == algorithm_type_t::HUMAN_REGION_GATHER;

                    bool bCount = false;
                    if(bHuman && obj_c.index == (int)det_class_label_t::HUMAN) {
                        bCount = true;
                    } else if (algor_type == algorithm_type_t::VEHICLE_GATHER && obj_c.index >= 4 && obj_c.index <= 8) {
                        bCount = true;
                    }
                    
                    if (bCount && snapshot_legal_inarea(cur_task_params->basic_param->algor_valid_rect, obj_c.left, obj_c.top, obj_c.right, obj_c.bottom))
                    {
                        taskid_obj_count[task_id]++;
                        
                        auto tmp_box = cur_task_ol_detres.obj[c];
                        box_t box;
                        box.top = tmp_box.top;
                        box.left = tmp_box.left;
                        box.right = tmp_box.right;
                        box.bottom = tmp_box.bottom;
                        box.score = tmp_box.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_obj_count[task_id] > 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;
}