Function roi_align_layer

tests/validation/reference/ROIAlignLayer.cpp:142–211

template <>
SimpleTensor<float> roi_align_layer(const SimpleTensor<float> &src,
                                    const SimpleTensor<float> &rois,
                                    const ROIPoolingLayerInfo &pool_info,
                                    const QuantizationInfo    &output_qinfo)
{
    ARM_COMPUTE_UNUSED(output_qinfo);

    const size_t values_per_roi = rois.shape()[0];
    const size_t num_rois       = rois.shape()[1];
    DataType     dst_data_type  = src.data_type();

    const auto *rois_ptr = static_cast<const float *>(rois.data());

    TensorShape         input_shape = src.shape();
    TensorShape         output_shape(pool_info.pooled_width(), pool_info.pooled_height(), src.shape()[2], num_rois);
    SimpleTensor<float> dst(output_shape, dst_data_type);

    // Iterate over every pixel of the input image
    for (size_t px = 0; px < pool_info.pooled_width(); ++px)
    {
        for (size_t py = 0; py < pool_info.pooled_height(); ++py)
        {
            for (size_t pw = 0; pw < num_rois; ++pw)
            {
                const unsigned int roi_batch = rois_ptr[values_per_roi * pw];
                const auto         x1        = float(rois_ptr[values_per_roi * pw + 1]);
                const auto         y1        = float(rois_ptr[values_per_roi * pw + 2]);
                const auto         x2        = float(rois_ptr[values_per_roi * pw + 3]);
                const auto         y2        = float(rois_ptr[values_per_roi * pw + 4]);

                const float roi_anchor_x = x1 * pool_info.spatial_scale();
                const float roi_anchor_y = y1 * pool_info.spatial_scale();
                const float roi_dims_x   = std::max((x2 - x1) * pool_info.spatial_scale(), 1.0f);
                const float roi_dims_y   = std::max((y2 - y1) * pool_info.spatial_scale(), 1.0f);

                float bin_size_x     = roi_dims_x / pool_info.pooled_width();
                float bin_size_y     = roi_dims_y / pool_info.pooled_height();
                float region_start_x = px * bin_size_x + roi_anchor_x;
                float region_start_y = py * bin_size_y + roi_anchor_y;
                float region_end_x   = (px + 1) * bin_size_x + roi_anchor_x;
                float region_end_y   = (py + 1) * bin_size_y + roi_anchor_y;

                region_start_x = utility::clamp(region_start_x, 0.0f, float(input_shape[0]));
                region_start_y = utility::clamp(region_start_y, 0.0f, float(input_shape[1]));
                region_end_x   = utility::clamp(region_end_x, 0.0f, float(input_shape[0]));
                region_end_y   = utility::clamp(region_end_y, 0.0f, float(input_shape[1]));

                const int roi_bin_grid_x =
                    (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_x));
                const int roi_bin_grid_y =
                    (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_y));

                // Move input and output pointer across the fourth dimension
                const size_t input_stride_w  = input_shape[0] * input_shape[1] * input_shape[2];
                const size_t output_stride_w = output_shape[0] * output_shape[1] * output_shape[2];
                const float *input_ptr       = src.data() + roi_batch * input_stride_w;
                float       *output_ptr      = dst.data() + px + py * output_shape[0] + pw * output_stride_w;