Function resize_linear_8u

dnn/src/naive/resize/resize_cv.cpp:307–336

}

void resize_linear_8u(const Mat8u& src, Mat8u& dst) {
    AlignedVector<int> tabsx(dst.rows());
    AlignedVector<int> tabsy(dst.cols());
    AlignedVector<int> tabrx(dst.rows());
    AlignedVector<int> tabry(dst.cols());
    build_tabs_linear_8u(src, dst, tabsx, tabsy, tabrx, tabry);
    const size_t ch = src.channels();
    const int ONE = 1 << SCALE;
    // brute-force
    for (size_t dx = 0; dx < dst.rows(); ++dx) {
        const uchar* psrc0 = src.ptr(tabsx[dx] + 0);
        const uchar* psrc1 = src.ptr(tabsx[dx] + 1);
        uchar* pdst = dst.ptr(dx);
        for (size_t dy = 0; dy < dst.cols(); ++dy) {
            uchar* pcdst = pdst + dy * ch;
            const uchar* pcsrc00 = psrc0 + (tabsy[dy] + 0) * ch;
            const uchar* pcsrc01 = psrc0 + (tabsy[dy] + 1) * ch;
            const uchar* pcsrc10 = psrc1 + (tabsy[dy] + 0) * ch;
            const uchar* pcsrc11 = psrc1 + (tabsy[dy] + 1) * ch;
            for (size_t c = 0; c < ch; ++c) {
                int res = pcsrc11[c] * tabrx[dx] * tabry[dy] +
                          pcsrc10[c] * tabrx[dx] * (ONE - tabry[dy]) +
                          pcsrc01[c] * (ONE - tabrx[dx]) * tabry[dy] +
                          pcsrc00[c] * (ONE - tabrx[dx]) * (ONE - tabry[dy]);
                pcdst[c] = static_cast<uchar>(
                        (res + (1 << (SCALE + SCALE - 1))) >> SCALE >> SCALE);
            }
        }
    }
}

const int INTER_RESIZE_COEF_BITS = 11;
const int INTER_RESIZE_COEF_SCALE = 1 << INTER_RESIZE_COEF_BITS;