Best way to apply a function to each element of Mat.

edit

@maythe4thbewithu already gave a pretty good answer to the question, but there still few missing points that I would like to address.

1) The image is not necessarily continuous in memory (for example if ROI is used). Thus single 'for' loop that runs on width*height values may give wrong results. As a result two 'for' loops are needed, only one of which is parallel_for_. There many ways to implement them, and most of those implementations are pretty inefficient. So knowing how to do it properly is important.

2) Dereferencing pointer is faster than accessing it by index. Thus if you need really good performance you should use *p and ++p instead of p[i] and ++i.

3) And last but definitely not the least: use lookup tables. You have an image of unsigned char. That means 256 possible inputs to your function. Calculate them once, and store result in lookup table. Then you will be able to assign values to each pixel in your image from the lookup table without performing any calculations. It may give you speedup of more than order of magnitude if your function requires heavy computations (cos for example).

Getting back to example that was used by maythe4thbewithu. Faster code should look like this:

class Parallel_Cos: public ParallelLoopBody
{   
public:
Parallel_Cos(Mat &imgg) : img(imgg)
{
    for(int i=0; i<256; i++)
        lookupTable[i] = (uchar)cos( (float) i );
}

void operator() (const Range &r) const
{
    for(int j=r.start; j<r.end; ++j)
    {
        unsigned char* current = const_cast<unsigned char*>(img.ptr(j));
        unsigned char* last = current + img.cols;
        for (; current != last; ++current)
            *current = lookupTable[*current];
    }
}

private:
    Mat img;
    unsigned char lookupTable[256];
};

// notice that the range is height of the image
parallel_for_( Range(0,old2.rows) , Parallel_Cos(old2)) ;

The fastest way to access all Mat elements is:

Size contSize = mat.size();
if (mat.isContinous())
{
    contSize.width *= contSize.height;
    contSize.height = 1;
}
for (int i = 0; i < contSize.height; ++i)
{
    T* ptr = mat.ptr<T>(y);
    for (int j = 0; j < contSize.width; ++j)
    {
        ptr[j] = ...;
    }
}

I could offer you a generic for_each loop, you could design you own generic algorithms by your own needs.

/**
 *@brief apply stl like for_each algorithm on a channel
 *
 * @param T : the type of the channel(ex, uchar, float, double and so on)
 * @param func : Unary function that accepts an element in the range as argument
 *
 *@return :
 *  return func
 */
template<typename T, typename UnaryFunc, typename Mat>
inline UnaryFunc for_each_channels(Mat &&input, UnaryFunc func)
{
    int rows = input.rows;
    int cols = input.cols;

    if(input.isContinuous()){
        cols = input.total() * input.channels();
        rows = 1;
    }

    for(int row = 0; row != rows; ++row){
        auto input_ptr = input.template ptr<T>(row);
        for(int col = 0; col != cols; ++col){
            func(input_ptr[col]);
        }
    }

    return func;
}

you could do your transform like this

for_each_channels<T>(input, [](T &data){ data = std::tanh(data); })

with the helps of c++11 lambda(c++14 will become even better), stl like algorithms become much more easier to use.

There are still rooms to speed up the algorithms, like vectorize?(I don't know how to do it yet) Multithread, although I can develop it with std::thread, but don't know how to make a thread pool, without a decent thread pool the parallel for_each algorithm is not ready yet.Although other language do not support template, I think this kind of generic algorithm could speed up the development speed of the openCV source and make the life of the c++ programmers easier.

I use && to make sure it could accept cv::Mat& and cv::Mat const&. This link explain the principle of the algorithm with details(only principle) generic algorithm