This is a toy example, which was tested on macOS 10.15.6 with Apple's Clang 11 and GCC 9.2.0 from hpc.sourceforge.net. It should compile and run with any C++ 11 compiler; with C++14 or later it uses aggregate initialization feature

Update: in Visual Studio "/std:c++latest" option should be set in order to use the proposed method of passing parameters. However, the parameter declaration and the function itself compile fine when older standards are used.

Update 2: added 'call chain' method to set properties in the case of older standards. It's less crisp than C++ 20 version, but shorter than the manual parameter initialization one by one. Hopefully, compilers can optimize such a chain of calls and will not copy the structure each time. But in any case it's very little overhead

Update 3: added diagnostic messages, which method we use, and also defined a helper macro to illustrate how it could have been used in OpenCV

#include <assert.h>
#include <stdio.h>
#include <inttypes.h>
#include <math.h>
#include <limits>
#include <string>

template<typename T> struct matrix_t
{
    matrix_t() = default;
    ~matrix_t()
    {
        release();
    }
    matrix_t(const matrix_t& m)
        : rows(m.rows), cols(m.cols),
        data(m.data), refcount(m.refcount)
    {
        if(refcount)
            ++*refcount;
    }
    matrix_t(int rows_, int cols_)
    {
        init();
        create(rows_, cols_);
    }
    matrix_t(int rows_, int cols_, std::initializer_list<T> elems)
    {
        init();
        create(rows_, cols_);
        assert((size_t)rows_*cols_ == elems.size());
        
        T* ptr = data;
        for( auto x: elems )
            *ptr++ = x;
    }
    matrix_t& operator = (const matrix_t& m)
    {
        if(this != &m)
        {
            release();
            rows = m.rows; cols = m.cols;
            data = m.data; refcount = m.refcount;
            if(refcount)
                ++*refcount;
        }
        return *this;
    }
    void init()
    {
        data = 0;
        refcount = 0;
        rows = 0; cols = 0;
    }
    void release()
    {
        if(refcount && --*refcount == 0)
        {
            if(data)
                delete[] data;
            delete refcount;
        }
        init();
    }
    void create(int rows_, int cols_)
    {
        assert(rows_ >= 0 && cols_ >= 0);
        if(rows == rows_ && cols == cols_)
            return;
        release();
        int total = rows_*cols_;
        rows = rows_; cols = cols_;
        if(total > 0)
            data = new T[rows_*cols_];
        else
            data = 0;
        refcount = new int(1);
    }
    int rows = 0;
    int cols = 0;
    T* data = 0;
    int* refcount = 0;
};

enum BorderMode
{
    BORDER_REPLICATE = 0,
    BORDER_REFECT_101 = 1,
    BORDER_WRAP = 2,
    BORDER_CONSTANT = 3
};

struct filter2DParams
{
    int anchor_x = -1;
    int anchor_y = -1;
    BorderMode border_mode = BORDER_REPLICATE;
    double border_value = 0.;
    double scale = 1.;
    double shift = 0.;

    filter2DParams& _anchor_x(int ax) { anchor_x = ax; return *this; }
    filter2DParams& _anchor_y(int ay) { anchor_y = ay; return *this; }
    filter2DParams& _border_mode(BorderMode bm) { border_mode = bm; return *this; }
    filter2DParams& _border_value(double bv) { border_value = bv; return *this; }
    filter2DParams& _scale(double sc) { scale = sc; return *this; }
    filter2DParams& _shift(double sh) { shift = sh; return *this; }
};

template<typename T> static inline T saturate_cast(double v)
{
    int iv = (int)round(v);
    const T minval = std::numeric_limits<T>::min();
    const T maxval = std::numeric_limits<T>::max();
    return iv < minval ? minval : iv > maxval ? maxval : (T)iv;
}

template<typename T1, typename T2>
    void filter2D(const matrix_t<T1>& src, matrix_t<T2>& dst,
                  const matrix_t<float>& kernel,
                  const filter2DParams& params=filter2DParams())
{
    int rows = src.rows, cols = src.cols, krows = kernel.rows, kcols = kernel.cols;
    int anchor_x = params.anchor_x, anchor_y = params.anchor_y;
    int border_mode = params.border_mode;
    double border_value = params.border_value;
    double scale = params.scale, shift = params.shift;
    
    if (anchor_x < 0)
        anchor_x = kcols/2;
    if (anchor_y < 0)
        anchor_y = krows/2;
    
    dst.create(rows, cols);
    
    const T1* srcdata = src.data;
    T2* dstdata = dst.data;
    const float* kdata = kernel.data;
    
    for( int i = 0; i < rows; i++ )
        for( int j = 0; j < cols; j++ )
    {
        double s = 0;
        for(int ki = 0; ki < krows; ki++)
            for(int kj = 0; kj < kcols; kj++)
        {
            int sy = i + ki - anchor_y;
            int sx = j + kj - anchor_x;
            double v;

            if( (unsigned)sx < (unsigned)cols &&
                (unsigned)sy < (unsigned)rows )
                v = srcdata[sy*cols + sx];
            else
            {
                if(border_mode == BORDER_REPLICATE)
                {
                    sx = sx < 0 ? 0 : sx >= cols ? cols-1 : sx;
                    sy = sy < 0 ? 0 : sy >= rows ? rows-1 : sy;
                    v = srcdata[sy*cols + sx];
                }
                else
                {
                    assert(border_mode == BORDER_CONSTANT);
                    v = border_value;
                }
            }
                
            s += kdata[ki*kcols + kj]*v;
        }
        dstdata[i*cols + j] = saturate_cast<T2>(s*scale + shift);
    }
}

template<typename T>
static void randu(matrix_t<T>& m, int a, int b)
{
    for( int i = 0; i < m.rows; i++ )
        for( int j = 0; j < m.cols; j++ )
            m.data[i*m.cols + j] = (T)(rand()%(b - a + 1) + a);
}

template<typename T>
static void print(const char* mname, const matrix_t<T>& m)
{
    printf("\n%s:\n\t", mname);
    for( int i = 0; i < m.rows; i++ )
        for( int j = 0; j < m.cols; j++ )
    {
        // assume matrix is integer
        printf("%3d%s", (int)m.data[m.cols*i + j],
            j < m.cols-1 ? ", " : i < m.rows - 1 ?"\n\t" : "\n");
    }
}

#if __cplusplus > 201703L || \
    ((defined __GNUC__ || defined __clang__) && __cplusplus >= 201402L) || \
    _MSVC_LANG > 201703L
    #define CV_USE_NAMED_ARGS 1
#else
    #undef CV_USE_NAMED_ARGS
#endif

int main(int, char**)
{
    matrix_t<uint8_t> a(5, 5);
    matrix_t<uint8_t> b, b0;
    matrix_t<float> k(3, 3, {1.f, 2.f, 1.f, 2.f, 4.f, 2.f, 1.f, 2.f, 1.f});
    
    randu(a, 0, 9);
    filter2D(a, b0, k); // call with all default parameters

#if CV_USE_NAMED_ARGS
    printf("using 'named args'...\n");
    filter2D(a, b, k, {.border_mode=BORDER_CONSTANT, .border_value=5, .scale=1./16});
#elif 0
    printf("using direct parameter assignment...\n");
    filter2DParams p;
    p.border_mode = BORDER_CONSTANT;
    p.border_value = 5;
    p.scale = 1./16;
    filter2D(a, b, k, p);
#else
    printf("using 'call chain' method...\n");
    filter2D(a, b, k, filter2DParams().
        _border_mode(BORDER_CONSTANT).
        _border_value(5).
        _scale(1./16));
#endif
    
    print("a", a);
    print("b0", b0);
    print("b", b);
    
    return 0;
}

Uh oh!

Extendible parameters in OpenCV functions #17997

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions