Algos.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

namespace Imagine {

    // ===============================================
    // Scalings 

    template <typename T, int dim>
    Image<T,dim> scaleUp(const Image<T,dim>&I,int fact) 
    {
        Image<T,dim> I1(I.sizes() * fact);
        // coordinates aware iterator
        for (CoordsIterator<dim> r = I.coordsBegin() ; r != I.coordsEnd() ; ++r) {
            Coords<dim> o=*r;
            T b=I(o);
            for (CoordsIterator<dim> zr(o * fact, o * fact + Coords<dim>(fact-1));zr!=I.coordsEnd();++zr){
                I1(*zr)=b;
            }
        }
        return I1;
    }
    template <typename T, int dim>
    Image<T,dim> scaleDown(const Image<T,dim>&I,int fact) 
    {
        Image<T,dim> I1(I.sizes()/fact);
        // coordinates aware iterator
        for (CoordsIterator<dim> r = I1.coordsBegin() ; r != I1.coordsEnd() ; ++r)
            I1(*r)=I((*r)*fact);
        return I1;
    }
    template <typename T, int dim>
    Image<T,dim> reduce(const Image<T,dim>&I, int fact)  
    {
        typedef typename PixelTraits<T>::template CastPixel<double>::value_type doubleT;
        Coords<dim> d=I.sizes()/fact;
        double nb=pow(double(fact),dim);
        Image<T,dim> Ir(d);
        for (CoordsIterator<dim> r = Ir.coordsBegin() ; r != Ir.coordsEnd() ; ++r) {
            doubleT p(0.);
            for (CoordsIterator<dim> r2((*r)*fact,((*r)*fact+Coords<dim>(fact-1))); r2!=CoordsIterator<dim>(); ++r2) {
                p+=doubleT(I(*r2));
            }
            Ir(*r)=T(p/nb);
        }
        return Ir;
    }
    template <typename T, int dim>
    Image<T,dim> reduce(const Image<T,dim>&I,Coords<dim> nd,bool keepRatio=false)  
    {
        typedef typename PixelTraits<T>::template CastPixel<double>::value_type doubleT;
        Image<doubleT,dim> oI(I);
        Coords<dim> od=I.sizes();
        FVector<double,dim> f=div(FVector<double,dim>(od),FVector<double,dim>(nd));
        std::pair<double,double> mM = range(f);
        assert(mM.first>=1);
        if (keepRatio) {
            f.fill(mM.second);
            nd=Coords<dim>(FVector<double,dim>(od)/mM.second);
        }
        inPlaceBlur(oI,1.5*(sqrt(f)-.99)); // Todo: better filtering
        Image<T,dim> nI(nd);
        for (CoordsIterator<dim> r = nI.coordsBegin() ; r != nI.coordsEnd() ; ++r) {
            FVector<double,dim> x=mult(FVector<double,dim>(*r),f);
            nI(*r)=T(oI.interpolate(x));
        }
        return nI;
    }
    template <typename T> Image<T,2> inline reduce(const Image<T,2>&I,int w,int h,bool keepRatio=false) { return reduce(I,Coords<2>(w,h),keepRatio); }  // Reduce image (given dimensions), 3D alias.
    template <typename T> Image<T,3> inline reduce(const Image<T,3>&I,int w,int h,int d,bool keepRatio=false) { return reduce(I,Coords<3>(w,h,d),keepRatio); }  
    template <typename T,int dim>
    inline Image<T,dim> reduce(const Image<T,dim>&I,double fact)  
    {
        Coords<dim> nd=Coords<dim>(FVector<double,dim>(I.sizes())/fact);
        return reduce(I,nd);
    }
    template <typename T,int dim>
    Image<T,dim> enlarge(const Image<T,dim>&I,Coords<dim> nd,bool keepRatio=false)  
    {
        Coords<dim> od=I.sizes();
        FVector<double,dim> f=div(FVector<double,dim>(od),FVector<double,dim>(nd));
        std::pair<double,double> mM = range(f);
        assert(mM.second<=1);
        if (keepRatio) {
            f.fill(mM.second);
            nd=Coords<dim>(FVector<double,dim>(od)/mM.second);
        }
        Image<T,dim> nI(nd);
        for (CoordsIterator<dim> r = nI.coordsBegin() ; r != nI.coordsEnd() ; ++r) {
            FVector<double,dim> x=mult(FVector<double,dim>(*r),f);
            nI(*r)=T(I.interpolate(x));
        }
        return nI;
    }
    template <typename T> Image<T,2> inline enlarge(const Image<T,2>&I,int w,int h,bool keepRatio=false) { return enlarge(I,Coords<2>(w,h),keepRatio); }  
    template <typename T> Image<T,3> inline enlarge(const Image<T,3>&I,int w,int h,int d,bool keepRatio=false) { return enlarge(I,Coords<3>(w,h,d),keepRatio); }  
    template <typename T,int dim>
    inline Image<T,dim> enlarge(const Image<T,dim>&I,double fact)  
    {
        Coords<dim> nd=Coords<dim>(FVector<double,dim>(I.sizes())*fact);
        return enlarge(I,nd);
    }

    // ===============================================
    // Deriche 

    template <typename T,int dim>
    void inPlaceDeriche(Image<T,dim>&I,typename PixelTraits<T>::scalar_type sigma, int order, int d, bool neumann = true) {
        // Checks parameter values
        assert(sigma>0 && order>=0 && order<3 && d>=0 && d<dim);

        // Computes coefficients of the recursive filter
        const typename PixelTraits<T>::scalar_type
            alpha = 1.695f/sigma,
            ea = std::exp(alpha),
            ema = std::exp(-alpha),
            em2a = ema*ema,
            b1 = 2*ema,
            b2 = -em2a;

        typename PixelTraits<T>::scalar_type ek,ekn,parity,a1,a2,a3,a4,g0,sumg1,sumg0;

        switch(order) {

            // first-order derivative
                case 1:                 
                    ek = -(1-ema)*(1-ema)*(1-ema)/(2*(ema+1)*ema);
                    a1 = a4 = 0;
                    a2 = ek*ema;
                    a3 = -ek*ema;
                    parity = -1;
                    if (neumann) {
                        sumg1 = (ek*ea) / ((ea-1)*(ea-1));
                        g0 = 0;
                        sumg0 = g0 + sumg1;
                    }
                    else
                        g0 = sumg0 = sumg1 = 0;
                    break;

                    // second-order derivative
                case 2:               
                    ekn = ( -2*(-1+3*ea-3*ea*ea+ea*ea*ea)/(3*ea+1+3*ea*ea+ea*ea*ea) );
                    ek = -(em2a-1)/(2*alpha*ema);
                    a1 = ekn;
                    a2 = -ekn*(1+ek*alpha)*ema;
                    a3 = ekn*(1-ek*alpha)*ema;
                    a4 = -ekn*em2a;
                    parity = 1;
                    if (neumann) {
                        sumg1 = ekn/2;
                        g0 = ekn;
                        sumg0 = g0 + sumg1;
                    }
                    else
                        g0 = sumg0 = sumg1 = 0;
                    break;

                    // smoothing
                default:
                    ek = (1-ema)*(1-ema) / (1+2*alpha*ema - em2a);
                    a1 = ek;
                    a2 = ek*ema*(alpha-1);
                    a3 = ek*ema*(alpha+1);
                    a4 = -ek*em2a;
                    parity = 1;
                    if (neumann) {
                        sumg1 = ek*(alpha*ea+ea-1) / ((ea-1)*(ea-1));
                        g0 = ek;
                        sumg0 = g0 + sumg1;
                    }
                    else
                        g0 = sumg0 = sumg1 = 0;
                    break;
        }

        // filter init
        T *Y = new T[I.size(d)];
        const size_t offset = I.stride(d);
        const size_t nb = I.size(d);

        // Iterates on dimensions other than d
        Coords<dim> beg(0), end = I.sizes() - Coords<dim>(1);
        end[d]=0;
        for (CoordsIterator<dim> p(beg,end); p != CoordsIterator<dim>(); ++p) {
            T *ima = &(I(*p));
            T I2 = *ima; ima += offset;
            T I1 = *ima; ima += offset;
            T Y2 = *(Y++) = sumg0*I2;
            T Y1 = *(Y++) = g0*I1 + sumg1*I2;
            for (size_t i=2; i<nb; i++) {
                I1 = *ima; ima+=offset;
                T Y0 = *(Y++) = a1*I1 + a2*I2 + b1*Y1 + b2*Y2;
                I2=I1; Y2=Y1; Y1=Y0;
            }
            ima -= offset;
            I2 = *ima;
            Y2 = Y1 = (parity*sumg1)*I2;
            *ima = *(--Y)+Y2;
            ima-=offset;
            I1 = *ima;
            *ima = *(--Y)+Y1;
            for (size_t i=nb-3; ; i--) {
                T Y0 = a3*I1+a4*I2+b1*Y1+b2*Y2;
                ima-=offset;
                I2=I1;
                I1=*ima;
                *ima=*(--Y)+Y0;
                Y2=Y1;
                Y1=Y0;
                if (i==0)
                    break;
            } 
        }
        delete [] Y;

    }
    template <typename T,int dim>
    Image<T,dim> deriche(const Image<T,dim>&I,typename PixelTraits<T>::scalar_type sigma, int order, int d, bool neumann = true) {
        Image<T,dim> J=I.clone();
        inPlaceDeriche(J,sigma,order,d,neumann);
        return J;
    }
    template <typename T,int dim>
    void inPlaceBlur(Image<T,dim>&I,const FVector<typename PixelTraits<T>::scalar_type,dim>& sigmas, bool neumann = true) {
        for (int i=0;i<dim;i++) {
            inPlaceDeriche(I,sigmas[i], 0, i, neumann);
        }
    }
    template <typename T,int dim>
    void inPlaceBlur(Image<T,dim>&I,typename PixelTraits<T>::scalar_type sigma, bool neumann = true) {
        inPlaceBlur(I,FVector<typename PixelTraits<T>::scalar_type,dim>(sigma),neumann);
    }
    template <typename T,int dim>
    Image<T,dim> blur(const Image<T,dim>&I,typename PixelTraits<T>::scalar_type sigma, bool neumann = true) {
        Image<T,dim> J=I.clone();
        inPlaceBlur(J,sigma,neumann);
        return J;
    }
    template <typename T,int dim>
    Image<T,dim> blur(const Image<T,dim>&I,const FVector<typename PixelTraits<T>::scalar_type,dim>& sigmas, bool neumann = true) {
        Image<T,dim> J=I.clone();
        inPlaceBlur(J,sigmas,neumann);
        return J;
    }

}