/*
 * Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "proposalPlugin.h"
#include "NvInfer.h"
#include <cassert>
#include <cmath>
#include <cstring>
#include <stdio.h>
#include <vector>

using namespace nvinfer1;
using nvinfer1::plugin::ProposalPlugin;
using nvinfer1::plugin::ProposalDynamicPlugin;
using nvinfer1::plugin::ProposalBasePluginCreator;
using nvinfer1::plugin::ProposalPluginCreator;
using nvinfer1::plugin::ProposalDynamicPluginCreator;

// plugin specific constants
namespace
{
static const char* PROPOSAL_PLUGIN_VERSION{"1"};
static const char* PROPOSAL_PLUGIN_NAMES[] = {"Proposal", "ProposalDynamic"};
static const float RPN_STD_SCALING{1.0f};
} // namespace

// Static class fields initialization
PluginFieldCollection ProposalBasePluginCreator::mFC{};
std::vector<PluginField> ProposalBasePluginCreator::mPluginAttributes;

// Helper function for serializing plugin
template <typename T>
void writeToBuffer(char*& buffer, const T& val)
{
    *reinterpret_cast<T*>(buffer) = val;
    buffer += sizeof(T);
}

// Helper function for deserializing plugin
template <typename T>
T readFromBuffer(const char*& buffer)
{
    T val = *reinterpret_cast<const T*>(buffer);
    buffer += sizeof(T);
    return val;
}

ProposalPlugin::ProposalPlugin(int input_height, int input_width, int rpn_height, int rpn_width, float rpn_std_scaling,
    int rpn_stride, float bbox_min_size, float nms_iou_threshold, int pre_nms_top_n, int max_box_num,
    const float* anchor_sizes, int anc_size_num, const float* anchor_ratios, int anc_ratio_num) noexcept
    : mInputHeight(input_height)
    , mInputWidth(input_width)
    , mRpnHeight(rpn_height)
    , mRpnWidth(rpn_width)
    , mRpnStdScaling(rpn_std_scaling)
    , mRpnStride(rpn_stride)
    , mBboxMinSize(bbox_min_size)
    , mNmsIouThreshold(nms_iou_threshold)
    , mPreNmsTopN(pre_nms_top_n)
    , mMaxBoxNum(max_box_num)
    , mAnchorSizeNum(anc_size_num)
    , mAnchorRatioNum(anc_ratio_num)
{
    for (int i = 0; i < anc_size_num; ++i)
    {
        mAnchorSizes.push_back(anchor_sizes[i]);
    }

    for (int i = 0; i < anc_ratio_num; ++i)
    {
        mAnchorRatios.push_back(anchor_ratios[i]);
    }
}

ProposalDynamicPlugin::ProposalDynamicPlugin(int input_height, int input_width, int rpn_height, int rpn_width,
    float rpn_std_scaling, int rpn_stride, float bbox_min_size, float nms_iou_threshold, int pre_nms_top_n,
    int max_box_num, const float* anchor_sizes, int anc_size_num, const float* anchor_ratios,
    int anc_ratio_num) noexcept
    : mInputHeight(input_height)
    , mInputWidth(input_width)
    , mRpnHeight(rpn_height)
    , mRpnWidth(rpn_width)
    , mRpnStdScaling(rpn_std_scaling)
    , mRpnStride(rpn_stride)
    , mBboxMinSize(bbox_min_size)
    , mNmsIouThreshold(nms_iou_threshold)
    , mPreNmsTopN(pre_nms_top_n)
    , mMaxBoxNum(max_box_num)
    , mAnchorSizeNum(anc_size_num)
    , mAnchorRatioNum(anc_ratio_num)
{
    for (int i = 0; i < anc_size_num; ++i)
    {
        mAnchorSizes.push_back(anchor_sizes[i]);
    }

    for (int i = 0; i < anc_ratio_num; ++i)
    {
        mAnchorRatios.push_back(anchor_ratios[i]);
    }
}

ProposalPlugin::ProposalPlugin(int input_height, int input_width, float rpn_std_scaling, int rpn_stride,
    float bbox_min_size, float nms_iou_threshold, int pre_nms_top_n, int max_box_num, const float* anchor_sizes,
    int anc_size_num, const float* anchor_ratios, int anc_ratio_num) noexcept
    : mInputHeight(input_height)
    , mInputWidth(input_width)
    , mRpnStdScaling(rpn_std_scaling)
    , mRpnStride(rpn_stride)
    , mBboxMinSize(bbox_min_size)
    , mNmsIouThreshold(nms_iou_threshold)
    , mPreNmsTopN(pre_nms_top_n)
    , mMaxBoxNum(max_box_num)
    , mAnchorSizeNum(anc_size_num)
    , mAnchorRatioNum(anc_ratio_num)
{
    for (int i = 0; i < anc_size_num; ++i)
    {
        mAnchorSizes.push_back(anchor_sizes[i]);
    }

    for (int i = 0; i < anc_ratio_num; ++i)
    {
        mAnchorRatios.push_back(anchor_ratios[i]);
    }
}

ProposalDynamicPlugin::ProposalDynamicPlugin(int input_height, int input_width, float rpn_std_scaling, int rpn_stride,
    float bbox_min_size, float nms_iou_threshold, int pre_nms_top_n, int max_box_num, const float* anchor_sizes,
    int anc_size_num, const float* anchor_ratios, int anc_ratio_num) noexcept
    : mInputHeight(input_height)
    , mInputWidth(input_width)
    , mRpnStdScaling(rpn_std_scaling)
    , mRpnStride(rpn_stride)
    , mBboxMinSize(bbox_min_size)
    , mNmsIouThreshold(nms_iou_threshold)
    , mPreNmsTopN(pre_nms_top_n)
    , mMaxBoxNum(max_box_num)
    , mAnchorSizeNum(anc_size_num)
    , mAnchorRatioNum(anc_ratio_num)
{
    for (int i = 0; i < anc_size_num; ++i)
    {
        mAnchorSizes.push_back(anchor_sizes[i]);
    }

    for (int i = 0; i < anc_ratio_num; ++i)
    {
        mAnchorRatios.push_back(anchor_ratios[i]);
    }
}

ProposalPlugin::ProposalPlugin(const void* serial_buf, size_t serial_size) noexcept
{
    const char* d = reinterpret_cast<const char*>(serial_buf);
    const char* a = d;
    mInputHeight = readFromBuffer<size_t>(a);
    mInputWidth = readFromBuffer<size_t>(a);
    mRpnHeight = readFromBuffer<size_t>(a);
    mRpnWidth = readFromBuffer<size_t>(a);
    mRpnStride = readFromBuffer<size_t>(a);
    mPreNmsTopN = readFromBuffer<size_t>(a);
    mMaxBoxNum = readFromBuffer<size_t>(a);
    mAnchorSizeNum = readFromBuffer<size_t>(a);
    mAnchorRatioNum = readFromBuffer<size_t>(a);
    mRpnStdScaling = readFromBuffer<float>(a);
    mBboxMinSize = readFromBuffer<float>(a);
    mNmsIouThreshold = readFromBuffer<float>(a);

    for (size_t i = 0; i < mAnchorSizeNum; ++i)
    {
        mAnchorSizes.push_back(readFromBuffer<float>(a));
    }

    for (size_t i = 0; i < mAnchorRatioNum; ++i)
    {
        mAnchorRatios.push_back(readFromBuffer<float>(a));
    }

    ASSERT(a == d + serial_size);
}

ProposalDynamicPlugin::ProposalDynamicPlugin(const void* serial_buf, size_t serial_size) noexcept
{
    const char* d = reinterpret_cast<const char*>(serial_buf);
    const char* a = d;
    mInputHeight = readFromBuffer<size_t>(a);
    mInputWidth = readFromBuffer<size_t>(a);
    mRpnHeight = readFromBuffer<size_t>(a);
    mRpnWidth = readFromBuffer<size_t>(a);
    mRpnStride = readFromBuffer<size_t>(a);
    mPreNmsTopN = readFromBuffer<size_t>(a);
    mMaxBoxNum = readFromBuffer<size_t>(a);
    mAnchorSizeNum = readFromBuffer<size_t>(a);
    mAnchorRatioNum = readFromBuffer<size_t>(a);
    mRpnStdScaling = readFromBuffer<float>(a);
    mBboxMinSize = readFromBuffer<float>(a);
    mNmsIouThreshold = readFromBuffer<float>(a);

    for (size_t i = 0; i < mAnchorSizeNum; ++i)
    {
        mAnchorSizes.push_back(readFromBuffer<float>(a));
    }

    for (size_t i = 0; i < mAnchorRatioNum; ++i)
    {
        mAnchorRatios.push_back(readFromBuffer<float>(a));
    }

    ASSERT(a == d + serial_size);
}

ProposalPlugin::~ProposalPlugin() noexcept {}

ProposalDynamicPlugin::~ProposalDynamicPlugin() noexcept {}

const char* ProposalPlugin::getPluginType() const noexcept
{
    return PROPOSAL_PLUGIN_NAMES[0];
}

const char* ProposalDynamicPlugin::getPluginType() const noexcept
{
    return PROPOSAL_PLUGIN_NAMES[1];
}

const char* ProposalPlugin::getPluginVersion() const noexcept
{
    return PROPOSAL_PLUGIN_VERSION;
}

const char* ProposalDynamicPlugin::getPluginVersion() const noexcept
{
    return PROPOSAL_PLUGIN_VERSION;
}

int ProposalPlugin::getNbOutputs() const noexcept
{
    return 1;
}

int ProposalDynamicPlugin::getNbOutputs() const noexcept
{
    return 1;
}

Dims ProposalPlugin::getOutputDimensions(int index, const Dims* inputs, int nbInputDims) noexcept
{
    // Validate input arguments
    ASSERT(index == 0);
    ASSERT(nbInputDims == 2);
    ASSERT(inputs->nbDims == 3);
    ASSERT((inputs + 1)->nbDims == 3);
    int channels = mMaxBoxNum;
    int height = 4;
    int width = 1;
    return Dims3(channels, height, width);
}

DimsExprs ProposalDynamicPlugin::getOutputDimensions(
    int outputIndex, const DimsExprs* inputs, int nbInputs, IExprBuilder& exprBuilder) noexcept
{
    // Validate input arguments
    ASSERT(outputIndex == 0);
    ASSERT(nbInputs == 2);
    ASSERT(inputs[0].nbDims == 4);
    ASSERT(inputs[1].nbDims == 4);
    DimsExprs out_dim;
    out_dim.nbDims = 4;
    out_dim.d[0] = inputs[0].d[0];
    out_dim.d[1] = exprBuilder.constant(mMaxBoxNum);
    out_dim.d[2] = exprBuilder.constant(4);
    out_dim.d[3] = exprBuilder.constant(1);
    return out_dim;
}

int ProposalPlugin::initialize() noexcept
{
    return STATUS_SUCCESS;
}

int ProposalDynamicPlugin::initialize() noexcept
{
    return STATUS_SUCCESS;
}

size_t ProposalPlugin::getWorkspaceSize(int max_batch_size) const noexcept
{
    return _get_workspace_size(max_batch_size, mAnchorSizeNum, mAnchorRatioNum, mRpnHeight, mRpnWidth, mMaxBoxNum);
}

size_t ProposalDynamicPlugin::getWorkspaceSize(
    const PluginTensorDesc* inputs, int nbInputs, const PluginTensorDesc* outputs, int nbOutputs) const noexcept
{
    int batch_size = inputs[0].dims.d[0];
    return _get_workspace_size(batch_size, mAnchorSizeNum, mAnchorRatioNum, mRpnHeight, mRpnWidth, mMaxBoxNum);
}

int ProposalPlugin::enqueue(
    int batchSize, const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept
{
    int status = -1;
    // Our plugin outputs only one tensor
    void* output = outputs[0];
    status = proposalInference_gpu(stream, inputs[0], inputs[1], batchSize, mInputHeight, mInputWidth, mRpnHeight,
        mRpnWidth, mMaxBoxNum, mPreNmsTopN, &mAnchorSizes[0], mAnchorSizeNum, &mAnchorRatios[0], mAnchorRatioNum,
        mRpnStdScaling, mRpnStride, mBboxMinSize, mNmsIouThreshold, workspace, output);
    ASSERT(status == STATUS_SUCCESS);
    return status;
}

int ProposalDynamicPlugin::enqueue(const PluginTensorDesc* inputDesc, const PluginTensorDesc* outputDesc,
    const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept
{
    int status = -1;
    // Our plugin outputs only one tensor
    void* output = outputs[0];
    int batchSize = inputDesc[0].dims.d[0];
    status = proposalInference_gpu(stream, inputs[0], inputs[1], batchSize, mInputHeight, mInputWidth, mRpnHeight,
        mRpnWidth, mMaxBoxNum, mPreNmsTopN, &mAnchorSizes[0], mAnchorSizeNum, &mAnchorRatios[0], mAnchorRatioNum,
        mRpnStdScaling, mRpnStride, mBboxMinSize, mNmsIouThreshold, workspace, output);
    ASSERT(status == STATUS_SUCCESS);
    return status;
}

size_t ProposalPlugin::getSerializationSize() const noexcept
{
    return sizeof(size_t) * 9 + sizeof(float) * 3 + sizeof(float) * mAnchorSizeNum + sizeof(float) * mAnchorRatioNum;
}

size_t ProposalDynamicPlugin::getSerializationSize() const noexcept
{
    return sizeof(size_t) * 9 + sizeof(float) * 3 + sizeof(float) * mAnchorSizeNum + sizeof(float) * mAnchorRatioNum;
}

void ProposalPlugin::serialize(void* buffer) const noexcept
{
    char* d = reinterpret_cast<char*>(buffer);
    char* a = d;
    writeToBuffer<size_t>(a, mInputHeight);
    writeToBuffer<size_t>(a, mInputWidth);
    writeToBuffer<size_t>(a, mRpnHeight);
    writeToBuffer<size_t>(a, mRpnWidth);
    writeToBuffer<size_t>(a, mRpnStride);
    writeToBuffer<size_t>(a, mPreNmsTopN);
    writeToBuffer<size_t>(a, mMaxBoxNum);
    writeToBuffer<size_t>(a, mAnchorSizeNum);
    writeToBuffer<size_t>(a, mAnchorRatioNum);
    writeToBuffer<float>(a, mRpnStdScaling);
    writeToBuffer<float>(a, mBboxMinSize);
    writeToBuffer<float>(a, mNmsIouThreshold);

    for (size_t i = 0; i < mAnchorSizeNum; ++i)
    {
        writeToBuffer<float>(a, mAnchorSizes[i]);
    }

    for (size_t i = 0; i < mAnchorRatioNum; ++i)
    {
        writeToBuffer<float>(a, mAnchorRatios[i]);
    }

    ASSERT(a == d + getSerializationSize());
}

void ProposalDynamicPlugin::serialize(void* buffer) const noexcept
{
    char* d = reinterpret_cast<char*>(buffer);
    char* a = d;
    writeToBuffer<size_t>(a, mInputHeight);
    writeToBuffer<size_t>(a, mInputWidth);
    writeToBuffer<size_t>(a, mRpnHeight);
    writeToBuffer<size_t>(a, mRpnWidth);
    writeToBuffer<size_t>(a, mRpnStride);
    writeToBuffer<size_t>(a, mPreNmsTopN);
    writeToBuffer<size_t>(a, mMaxBoxNum);
    writeToBuffer<size_t>(a, mAnchorSizeNum);
    writeToBuffer<size_t>(a, mAnchorRatioNum);
    writeToBuffer<float>(a, mRpnStdScaling);
    writeToBuffer<float>(a, mBboxMinSize);
    writeToBuffer<float>(a, mNmsIouThreshold);

    for (size_t i = 0; i < mAnchorSizeNum; ++i)
    {
        writeToBuffer<float>(a, mAnchorSizes[i]);
    }

    for (size_t i = 0; i < mAnchorRatioNum; ++i)
    {
        writeToBuffer<float>(a, mAnchorRatios[i]);
    }

    ASSERT(a == d + getSerializationSize());
}

bool ProposalPlugin::supportsFormat(DataType type, PluginFormat format) const noexcept
{
    // This plugin only supports ordinary floats, and NCHW input format
    if (type == DataType::kFLOAT && format == PluginFormat::kLINEAR)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool ProposalDynamicPlugin::supportsFormatCombination(
    int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) noexcept
{
    // 2 inputs, 1 outputs, so 3 input/output in total
    ASSERT(0 <= pos && pos < 3);
    const auto* in = inOut;
    const auto* out = inOut + nbInputs;
    const bool consistentFloatPrecision = (in[0].type == in[pos].type);
    switch (pos)
    {
    case 0: return in[0].type == DataType::kFLOAT && in[0].format == PluginFormat::kLINEAR && consistentFloatPrecision;
    case 1: return in[1].type == DataType::kFLOAT && in[1].format == PluginFormat::kLINEAR && consistentFloatPrecision;
    case 2:
        return out[0].type == DataType::kFLOAT && out[0].format == PluginFormat::kLINEAR && consistentFloatPrecision;
    }
    return false;
}

void ProposalPlugin::terminate() noexcept {}

void ProposalDynamicPlugin::terminate() noexcept {}

void ProposalPlugin::destroy() noexcept
{
    // This gets called when the network containing plugin is destroyed
    delete this;
}

void ProposalDynamicPlugin::destroy() noexcept
{
    // This gets called when the network containing plugin is destroyed
    delete this;
}

IPluginV2Ext* ProposalPlugin::clone() const noexcept
{
    IPluginV2Ext* plugin = new ProposalPlugin(mInputHeight, mInputWidth, mRpnHeight, mRpnWidth, mRpnStdScaling,
        mRpnStride, mBboxMinSize, mNmsIouThreshold, mPreNmsTopN, mMaxBoxNum, &mAnchorSizes[0], mAnchorSizeNum,
        &mAnchorRatios[0], mAnchorRatioNum);
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}

IPluginV2DynamicExt* ProposalDynamicPlugin::clone() const noexcept
{
    auto* plugin = new ProposalDynamicPlugin(mInputHeight, mInputWidth, mRpnHeight, mRpnWidth, mRpnStdScaling,
        mRpnStride, mBboxMinSize, mNmsIouThreshold, mPreNmsTopN, mMaxBoxNum, &mAnchorSizes[0], mAnchorSizeNum,
        &mAnchorRatios[0], mAnchorRatioNum);
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}

void ProposalPlugin::setPluginNamespace(const char* libNamespace) noexcept
{
    mNamespace = libNamespace;
}

void ProposalDynamicPlugin::setPluginNamespace(const char* libNamespace) noexcept
{
    mNamespace = libNamespace;
}

const char* ProposalPlugin::getPluginNamespace() const noexcept
{
    return mNamespace.c_str();
}

const char* ProposalDynamicPlugin::getPluginNamespace() const noexcept
{
    return mNamespace.c_str();
}

// Return the DataType of the plugin output at the requested index.
DataType ProposalPlugin::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const noexcept
{
    // one outputs
    ASSERT(index == 0);
    return DataType::kFLOAT;
}

DataType ProposalDynamicPlugin::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const
    noexcept
{
    // one outputs
    ASSERT(index == 0);
    return DataType::kFLOAT;
}

// Return true if output tensor is broadcast across a batch.
bool ProposalPlugin::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const
    noexcept
{
    return false;
}

// Return true if plugin can use input that is broadcast across batch without replication.
bool ProposalPlugin::canBroadcastInputAcrossBatch(int inputIndex) const noexcept
{
    return false;
}

void ProposalPlugin::configurePlugin(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,
    const DataType* inputTypes, const DataType* outputTypes, const bool* inputIsBroadcast,
    const bool* outputIsBroadcast, PluginFormat floatFormat, int maxBatchSize) noexcept
{
    ASSERT(nbInputs == 2);
    ASSERT(nbOutputs == 1);
    mRpnHeight = inputDims->d[1];
    mRpnWidth = inputDims->d[2];
}

void ProposalDynamicPlugin::configurePlugin(
    const DynamicPluginTensorDesc* in, int nbInputs, const DynamicPluginTensorDesc* out, int nbOutputs) noexcept
{
    ASSERT(nbInputs == 2);
    ASSERT(nbOutputs == 1);
    mRpnHeight = in[0].desc.dims.d[2];
    mRpnWidth = in[0].desc.dims.d[3];
}

// Attach the plugin object to an execution context and grant the plugin the access to some context resource.
void ProposalPlugin::attachToContext(
    cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) noexcept
{
}

// Detach the plugin object from its execution context.
void ProposalPlugin::detachFromContext() noexcept {}

ProposalBasePluginCreator::ProposalBasePluginCreator() noexcept
{
    mPluginAttributes.clear();
    mPluginAttributes.emplace_back(PluginField("input_height", nullptr, PluginFieldType::kINT32, 1));
    mPluginAttributes.emplace_back(PluginField("input_width", nullptr, PluginFieldType::kINT32, 1));
    mPluginAttributes.emplace_back(PluginField("rpn_stride", nullptr, PluginFieldType::kINT32, 1));
    mPluginAttributes.emplace_back(PluginField("roi_min_size", nullptr, PluginFieldType::kFLOAT32, 1));
    mPluginAttributes.emplace_back(PluginField("nms_iou_threshold", nullptr, PluginFieldType::kFLOAT32, 1));
    mPluginAttributes.emplace_back(PluginField("pre_nms_top_n", nullptr, PluginFieldType::kINT32, 1));
    mPluginAttributes.emplace_back(PluginField("post_nms_top_n", nullptr, PluginFieldType::kINT32, 1));
    mPluginAttributes.emplace_back(PluginField("anchor_sizes", nullptr, PluginFieldType::kFLOAT32, 1));
    mPluginAttributes.emplace_back(PluginField("anchor_ratios", nullptr, PluginFieldType::kFLOAT32, 1));
    mFC.nbFields = mPluginAttributes.size();
    mFC.fields = mPluginAttributes.data();
}

ProposalPluginCreator::ProposalPluginCreator() noexcept
{
    mPluginName = PROPOSAL_PLUGIN_NAMES[0];
}

ProposalDynamicPluginCreator::ProposalDynamicPluginCreator() noexcept
{
    mPluginName = PROPOSAL_PLUGIN_NAMES[1];
}

const char* ProposalBasePluginCreator::getPluginName() const noexcept
{
    return mPluginName.c_str();
}

const char* ProposalBasePluginCreator::getPluginVersion() const noexcept
{
    return PROPOSAL_PLUGIN_VERSION;
}

const PluginFieldCollection* ProposalBasePluginCreator::getFieldNames() noexcept
{
    return &mFC;
}

IPluginV2Ext* ProposalPluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc) noexcept
{
    const PluginField* fields = fc->fields;
    int nbFields = fc->nbFields;
    int input_height = 0, input_width = 0, rpn_stride = 0, pre_nms_top_n = 0, post_nms_top_n = 0;
    float roi_min_size = 0.0f, nms_iou_threshold = 0.0f;
    std::vector<float> anchor_sizes;
    std::vector<float> anchor_ratios;

    for (int i = 0; i < nbFields; ++i)
    {
        const char* attr_name = fields[i].name;

        if (!strcmp(attr_name, "input_height"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            input_height = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "input_width"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            input_width = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "rpn_stride"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            rpn_stride = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "roi_min_size"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            roi_min_size = *(static_cast<const float*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "nms_iou_threshold"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            nms_iou_threshold = *(static_cast<const float*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "pre_nms_top_n"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            pre_nms_top_n = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "post_nms_top_n"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            post_nms_top_n = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "anchor_sizes"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            const float* as = static_cast<const float*>(fields[i].data);

            for (int j = 0; j < fields[i].length; ++j)
            {
                ASSERT(*as > 0.0f);
                anchor_sizes.push_back(*as);
                ++as;
            }
        }
        else if (!strcmp(attr_name, "anchor_ratios"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            const float* ar = static_cast<const float*>(fields[i].data);

            // take the square root.
            for (int j = 0; j < fields[i].length; ++j)
            {
                ASSERT(*ar > 0.0f);
                anchor_ratios.push_back(std::sqrt(*ar));
                ++ar;
            }
        }
    }

    ASSERT(input_height > 0 && input_width > 0 && rpn_stride > 0 && pre_nms_top_n > 0 && post_nms_top_n
        && roi_min_size >= 0.0f && nms_iou_threshold > 0.0f);

    IPluginV2Ext* plugin = new ProposalPlugin(input_height, input_width, RPN_STD_SCALING, rpn_stride, roi_min_size,
        nms_iou_threshold, pre_nms_top_n, post_nms_top_n, &anchor_sizes[0], anchor_sizes.size(), &anchor_ratios[0],
        anchor_ratios.size());
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}

IPluginV2DynamicExt* ProposalDynamicPluginCreator::createPlugin(
    const char* name, const PluginFieldCollection* fc) noexcept
{
    const PluginField* fields = fc->fields;
    int nbFields = fc->nbFields;
    int input_height = 0, input_width = 0, rpn_stride = 0, pre_nms_top_n = 0, post_nms_top_n = 0;
    float roi_min_size = 0.0f, nms_iou_threshold = 0.0f;
    std::vector<float> anchor_sizes;
    std::vector<float> anchor_ratios;

    for (int i = 0; i < nbFields; ++i)
    {
        const char* attr_name = fields[i].name;

        if (!strcmp(attr_name, "input_height"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            input_height = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "input_width"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            input_width = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "rpn_stride"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            rpn_stride = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "roi_min_size"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            roi_min_size = *(static_cast<const float*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "nms_iou_threshold"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            nms_iou_threshold = *(static_cast<const float*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "pre_nms_top_n"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            pre_nms_top_n = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "post_nms_top_n"))
        {
            ASSERT(fields[i].type == PluginFieldType::kINT32);
            post_nms_top_n = *(static_cast<const int*>(fields[i].data));
        }
        else if (!strcmp(attr_name, "anchor_sizes"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            const float* as = static_cast<const float*>(fields[i].data);

            for (int j = 0; j < fields[i].length; ++j)
            {
                ASSERT(*as > 0.0f);
                anchor_sizes.push_back(*as);
                ++as;
            }
        }
        else if (!strcmp(attr_name, "anchor_ratios"))
        {
            ASSERT(fields[i].type == PluginFieldType::kFLOAT32);
            const float* ar = static_cast<const float*>(fields[i].data);

            // take the square root.
            for (int j = 0; j < fields[i].length; ++j)
            {
                ASSERT(*ar > 0.0f);
                anchor_ratios.push_back(std::sqrt(*ar));
                ++ar;
            }
        }
    }

    ASSERT(input_height > 0 && input_width > 0 && rpn_stride > 0 && pre_nms_top_n > 0 && post_nms_top_n
        && roi_min_size >= 0.0f && nms_iou_threshold > 0.0f);

    IPluginV2DynamicExt* plugin = new ProposalDynamicPlugin(input_height, input_width, RPN_STD_SCALING, rpn_stride,
        roi_min_size, nms_iou_threshold, pre_nms_top_n, post_nms_top_n, &anchor_sizes[0], anchor_sizes.size(),
        &anchor_ratios[0], anchor_ratios.size());
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}

IPluginV2Ext* ProposalPluginCreator::deserializePlugin(
    const char* name, const void* serialData, size_t serialLength) noexcept
{
    // This object will be deleted when the network is destroyed,
    IPluginV2Ext* plugin = new ProposalPlugin(serialData, serialLength);
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}

IPluginV2DynamicExt* ProposalDynamicPluginCreator::deserializePlugin(
    const char* name, const void* serialData, size_t serialLength) noexcept
{
    // This object will be deleted when the network is destroyed,
    IPluginV2DynamicExt* plugin = new ProposalDynamicPlugin(serialData, serialLength);
    plugin->setPluginNamespace(mNamespace.c_str());
    return plugin;
}