/homes/esi30/DCS339/coursework/src/Processes/convolution.hpp

Go to the documentation of this file.

#ifndef PROCESSES_CONVOLUTION_HPP_INCLUDED
#define PROCESSES_CONVOLUTION_HPP_INCLUDED

#include <cmath>
#include <array>

#include "../progress.hpp"
#include "../display_unit.hpp"

template<int N>
class Advancement{
    public:
        Advancement(){}
        void advance(double d){ p.advance(d); }
    private:
        Progress p;
};

template<>
class Advancement<1>{
    public:
        void advance(double){}
};

template<int N>
Image_unit* apply(const Image_unit *in, const std::array<std::array<double, 2*N+1>, 2*N+1> &kernel, double divisor){
    Advancement<N> adv;
    Image_unit *out=new Image_unit(*in);

    for(unsigned y=0; y<out->height(); ++y){
        adv.advance(static_cast<double>(y)/out->height());
        for(unsigned x=0; x<out->width(); ++x){
            double vr=0, vg=0, vb=0;
            for(int dy=-N; dy<=N; ++dy)
                for(int dx=-N; dx<=N; ++dx){
                    // @todo error if the kernel is bigger than the image
                    vr+=in->m_red(y+dy, x+dx)*kernel[dy+N][dx+N];
                    vg+=in->m_green(y+dy, x+dx)*kernel[dy+N][dx+N];
                    vb+=in->m_blue(y+dy, x+dx)*kernel[dy+N][dx+N];
                }
            vr/=divisor;
            vg/=divisor;
            vb/=divisor;
            vr=vr<0?0:vr>255?255:vr;
            vg=vg<0?0:vg>255?255:vg;
            vb=vb<0?0:vb>255?255:vb;
            out->red(y, x, vr);
            out->green(y, x, vg);
            out->blue(y, x, vb);
        }
    }
    return out;
}

    /* Iterator version :

    for(Image::const_iterator it=in->begin(); it!=in->end(); ++it){
        double vr=0, vg=0, vb=0;
        for(int dy=-N; dy<=N; ++dy)
            for(int dx=-N; dx<=N; ++dx){
                Image::const_iterator ti(it+dy*in->width()+dx);
                if(ti.valid()){
                    vr+=ti->r*kernel[dy+N][dx+N];
                    vg+=ti->g*kernel[dy+N][dx+N];;
                    vb+=ti->b*kernel[dy+N][dx+N];;
                }
            }
        
        Image::iterator to=(out->begin()+(it-in->begin()));
        to->r=static_cast<unsigned char>(std::abs(vr/divisor));
        to->g=static_cast<unsigned char>(std::abs(vg/divisor));
        to->b=static_cast<unsigned char>(std::abs(vb/divisor));
    }
    */

#endif