Function roi_align_1x1

tests/validation/reference/ROIAlignLayer.cpp:44–108

Average pooling over an aligned window */

{
/** Average pooling over an aligned window */
inline float roi_align_1x1(const float *input,
                           TensorShape  input_shape,
                           float        region_start_x,
                           float        bin_size_x,
                           int          grid_size_x,
                           float        region_end_x,
                           float        region_start_y,
                           float        bin_size_y,
                           int          grid_size_y,
                           float        region_end_y,
                           int          pz)
{
    if ((region_end_x <= region_start_x) || (region_end_y <= region_start_y))
    {
        return 0;
    }
    else
    {
        float avg = 0;
        // Iterate through the aligned pooling region
        for (int iy = 0; iy < grid_size_y; ++iy)
        {
            for (int ix = 0; ix < grid_size_x; ++ix)
            {
                // Align the window in the middle of every bin
                float y = region_start_y + (iy + 0.5) * bin_size_y / float(grid_size_y);
                float x = region_start_x + (ix + 0.5) * bin_size_x / float(grid_size_x);

                // Interpolation in the [0,0] [0,1] [1,0] [1,1] square
                const int y_low  = y;
                const int x_low  = x;
                const int y_high = y_low + 1;
                const int x_high = x_low + 1;

                const float ly = y - y_low;
                const float lx = x - x_low;
                const float hy = 1. - ly;
                const float hx = 1. - lx;

                const float w1 = hy * hx;
                const float w2 = hy * lx;
                const float w3 = ly * hx;
                const float w4 = ly * lx;

                const size_t idx1  = coord2index(input_shape, Coordinates(x_low, y_low, pz));
                float        data1 = input[idx1];

                const size_t idx2  = coord2index(input_shape, Coordinates(x_high, y_low, pz));
                float        data2 = input[idx2];

                const size_t idx3  = coord2index(input_shape, Coordinates(x_low, y_high, pz));
                float        data3 = input[idx3];

                const size_t idx4  = coord2index(input_shape, Coordinates(x_high, y_high, pz));
                float        data4 = input[idx4];

                avg += w1 * data1 + w2 * data2 + w3 * data3 + w4 * data4;
            }