Function rep

dnn/src/naive/warp_affine/opr_impl.cpp:37–76

    sptr += n * C * IH * IW;

    rep(ow, OW) {
        float alphaw = mptr[0] * ow + mptr[1] * oh + mptr[2];
        float alphah = mptr[3] * ow + mptr[4] * oh + mptr[5];

        int iw0 = get_real_coord(std::floor(alphaw) + 0, IW);
        int iw1 = get_real_coord(std::floor(alphaw) + 1, IW);
        int ih0 = get_real_coord(std::floor(alphah) + 0, IH);
        int ih1 = get_real_coord(std::floor(alphah) + 1, IH);

        alphaw -= floor(alphaw);
        alphah -= floor(alphah);
        if (bmode != BorderMode::CONSTANT) {
            rep(c, C) {
                dptr[c * OH * OW + oh * OW + ow] = output_converter(
                        sptr[c * IH * IW + ih0 * IW + iw0] * (1.0f - alphaw) *
                                (1.0f - alphah) +
                        sptr[c * IH * IW + ih0 * IW + iw1] * alphaw * (1.0f - alphah) +
                        sptr[c * IH * IW + ih1 * IW + iw0] * (1.0f - alphaw) * alphah +
                        sptr[c * IH * IW + ih1 * IW + iw1] * alphaw * alphah);
            }
        } else {
            rep(c, C) {
                const float b = border_val;
                auto val = (ih0 != -1 && iw0 != -1 ? sptr[c * IH * IW + ih0 * IW + iw0]
                                                   : b) *
                                   (1.0f - alphaw) * (1.0f - alphah) +
                           (ih0 != -1 && iw1 != -1 ? sptr[c * IH * IW + ih0 * IW + iw1]
                                                   : b) *
                                   alphaw * (1.0f - alphah) +
                           (ih1 != -1 && iw0 != -1 ? sptr[c * IH * IW + ih1 * IW + iw0]
                                                   : b) *
                                   (1.0f - alphaw) * alphah +
                           (ih1 != -1 && iw1 != -1 ? sptr[c * IH * IW + ih1 * IW + iw1]
                                                   : b) *
                                   alphaw * alphah;
                dptr[c * OH * OW + oh * OW + ow] =
                        output_converter(std::isfinite(val) ? val : b);
            }
        }
    }
}

template <typename ctype, typename mtype>