Method operator()

dnn/src/common/cv/filter.h:245–288

            : RowFilter<ST, DT, VecOp>(kernel_, anchor_, vec_op_) {}

    void operator()(const uchar* src, uchar* dst, int width, int cn) {
        int ksize2 = this->ksize / 2, ksize2n = ksize2 * cn;
        const DT* kx = this->kernel.ptr() + ksize2;
        DT* D = reinterpret_cast<DT*>(dst);
        int i = this->vec_op(src, dst, width, cn), j, k;

        //! The center
        const ST* S = reinterpret_cast<const ST*>(src) + i + ksize2n;
        width *= cn;

        if (this->ksize == 1 && kx[0] == 1) {
            for (; i <= width - 2; i += 2) {
                DT s0 = S[i], s1 = S[i + 1];
                D[i] = s0;
                D[i + 1] = s1;
            }
            S += i;
        } else if (this->ksize == 3) {
            DT k0 = kx[0], k1 = kx[1];
            for (; i <= width - 2; i += 2, S += 2) {
                DT s0 = S[0] * k0 + (S[-cn] + S[cn]) * k1,
                   s1 = S[1] * k0 + (S[1 - cn] + S[1 + cn]) * k1;
                D[i] = s0;
                D[i + 1] = s1;
            }
        } else if (this->ksize == 5) {
            DT k0 = kx[0], k1 = kx[1], k2 = kx[2];
            for (; i <= width - 2; i += 2, S += 2) {
                DT s0 = S[0] * k0 + (S[-cn] + S[cn]) * k1 +
                        (S[-cn * 2] + S[cn * 2]) * k2;
                DT s1 = S[1] * k0 + (S[1 - cn] + S[1 + cn]) * k1 +
                        (S[1 - cn * 2] + S[1 + cn * 2]) * k2;
                D[i] = s0;
                D[i + 1] = s1;
            }
        }

        for (; i < width; i++, S++) {
            DT s0 = kx[0] * S[0];
            for (k = 1, j = cn; k <= ksize2; k++, j += cn)
                s0 += kx[k] * (S[j] + S[-j]);
            D[i] = s0;
        }
    }
};

template <class CastOp, class VecOp>