FunctorAccessor.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _FUNCTORACCESSOR_H
#define _FUNCTORACCESSOR_H

#include <vigra/numerictraits.hxx>

namespace vigra_ext {


template <class Functor, class Accessor>
class ReadFunctorAccessor
{
  public:
    typedef typename Functor::result_type value_type;
    ReadFunctorAccessor(Functor f, Accessor a)
        : m_f(f), m_a(a)
    {
    }

    template <typename ITERATOR_, typename DIFFERENCE_>
    typename Functor::result_type operator()(ITERATOR_ const & i, DIFFERENCE_ d) const
    {
        return m_f(m_a(i,d));
    }

    template <class ITERATOR>
    typename Functor::result_type operator()(ITERATOR const & i) const {
                return m_f(m_a(i)); }


protected:
    Functor m_f;
    Accessor m_a;
};

template <class Functor, class Accessor, class ValueType>
class WriteFunctorAccessor
{
public:

    typedef ValueType value_type;

    WriteFunctorAccessor(Functor f, Accessor a)
        : m_f(f), m_a(a)
    {
    }

    template <class Value, class ITERATOR>
    void set(Value const & v, ITERATOR const & i) const
    {
        m_a.set(m_f(v), i);
    }

    template <class Value, class ITERATOR_, class DIFFERENCE_>
    void set(Value const & v, ITERATOR_ const & i, DIFFERENCE_ d) const
    {
        m_a.set(m_f(v),i,d);
    }

    Functor m_f;
    Accessor m_a;
};



template <class Iter1, class Acc1, class Iter2, class Acc2>
class SplitVector2Accessor
{
public:
    typedef vigra::TinyVector<typename Acc1::value_type, 2> value_type;
    typedef typename value_type::value_type component_type;

    SplitVector2Accessor(Iter1 i1, Acc1 a1, Iter2 i2, Acc2 a2)
        : i1_(i1), a1_(a1), i2_(i2), a2_(a2)
        {}

    template <class V, class ITERATOR>
    void setComponent( V const & value, ITERATOR const & i, int idx ) const
    {
        switch (idx) {
        case 0:
            a1_.set(value, i1_, *i);
            break;
        case 1:
            a2_.set(value, i2_, *i);
            break;
        default:
            vigra_fail("too many components in input value");
        }
    }

        template <class ITERATOR>
        unsigned int size(ITERATOR const & i) const
        {
                return 2;
        }

    Iter1 i1_;
    Acc1  a1_;
    Iter2 i2_;
    Acc2  a2_;
};

template <class Iter1, class Acc1, class Iter2, class Acc2, int SIZE>
class SplitVectorNAccessor
{
public:
    typedef vigra::TinyVector<typename Acc1::value_type, SIZE> value_type;
    typedef typename value_type::value_type component_type;

    SplitVectorNAccessor(Iter1 i1, Acc1 a1, Iter2 i2, Acc2 a2)
        : i1_(i1), a1_(a1), i2_(i2), a2_(a2)
        {}

    template <class V, class ITERATOR>
    void setComponent( V const & value, ITERATOR const & i, int idx ) const
    {
        if ( idx < SIZE - 1 ) {
            a1_.setComponent(value, i1_, *i, idx);
        } else if ( idx == SIZE - 1 ) {
            a2_.set(value, i2_, *i);
        } else {
            vigra_fail("too many components in input value");
        }
    }

        template <class ITERATOR>
        unsigned int size(ITERATOR const & i) const
        {
                return SIZE;
        }

    Iter1 i1_;
    Acc1  a1_;
    Iter2 i2_;
    Acc2  a2_;
};

template <class Iter1, class Acc1, class Iter2, class Acc2>
class MergeScalarScalar2VectorAccessor
{
public:
    typedef vigra::TinyVector<typename Acc1::value_type, 2> value_type;
    typedef typename value_type::value_type component_type;

    MergeScalarScalar2VectorAccessor(Iter1 i1, Acc1 a1, Iter2 i2, Acc2 a2)
        : i1_(i1), a1_(a1), i2_(i2), a2_(a2)
        {}

    template <class DIFFERENCE_>
    value_type operator()(DIFFERENCE_ const & d) const
    {
        return value_type(a1_(i1_, d), a2_(i2_, d));
    }

    template <class ITERATOR>
    component_type getComponent(ITERATOR const & i, int idx) const
    {
        switch (idx) {
        case 0:
            return a1_( i1_, *i );
        case 1:
            return a2_( i2_, *i );
        default:
            vigra_fail("too many components in input value");
            // never reached, but here to silence compiler
            exit(1);
        }
    }

    template <class ITERATOR, class DIFFERENCE_>
    component_type const & getComponent(ITERATOR const & i, DIFFERENCE_ const & d, int idx) const
    {
        i += d;
        switch (idx) {
        case 0:
            return a1_.getComponent(i1_, *i, idx);
        case 1:
            return a2_.getComponent(i2_, *i, idx);
        default:
            vigra_fail("too many components in input value");
        }
    }

        template <class ITERATOR>
        unsigned int size(ITERATOR const & i) const
        {
                return 2;
        }

    Iter1 i1_;
    Acc1  a1_;
    Iter2 i2_;
    Acc2  a2_;
};


template <class Iter1, class Acc1, class Iter2, class Acc2, int SIZE>
class MergeVectorScalar2VectorAccessor
{
public:
    typedef typename Acc1::value_type image1_type;
    typedef typename Acc2::value_type image2_type;

    typedef typename image1_type::value_type component_type;

    typedef vigra::TinyVector<component_type, SIZE> value_type;

    MergeVectorScalar2VectorAccessor(Iter1 i1, Acc1 a1, Iter2 i2, Acc2 a2)
        : i1_(i1), a1_(a1), i2_(i2), a2_(a2)
        {}

    template <class DIFFERENCE_>
    value_type operator()(DIFFERENCE_ const & d) const
    {
        value_type ret;
        typename value_type::iterator it = ret.begin();
        const image1_type & i1 = a1_(i1_, d);
        for ( typename image1_type::const_iterator it1 = i1.begin();
             it1 != i1.end(); ++it1 )
        {
            *it = *it1;
            it++;
        }
        *it = a2_(i2_, d);
        return ret;
    }

    template <class ITERATOR>
    component_type getComponent(ITERATOR const & i, int idx) const
    {
        if ( idx < SIZE - 1 ) {
            return a1_.getComponent(i1_, *i, idx);
        } else if ( idx == SIZE - 1 ) {
            return a2_(i2_, *i);
        } else {
            vigra_fail("too many components in input value");
            // just to silence the compiler warning. this is
            // never reached, since vigra_fail will always
            // throw an exception.
            throw 0;
        }
    }

    template <class ITERATOR, class DIFFERENCE_>
    component_type const getComponent(ITERATOR i, DIFFERENCE_ const & d, int idx) const
    {
        i += d;
        if ( idx < SIZE - 1 ) {
            return a1_.getComponent(i1_, *i, idx);
        } else if ( idx == SIZE - 1 ) {
            return a2_(i2_, *i);
        } else {
            vigra_fail("too many components in input value");
            // just to silence the compiler warning. this is
            // never reached, since vigra_fail will always
            // throw an exception.
            throw 0;
        }
    }


        template <class ITERATOR>
        unsigned int size(ITERATOR const & i) const
        {
                return SIZE;
        }

    Iter1 i1_;
    Acc1  a1_;
    Iter2 i2_;
    Acc2  a2_;
};


template <class Iter1, class Acc1, class Iter2, class Acc2, int SIZE>
class ImageSplittingAccessor
{
public:
    typedef typename Acc1::value_type image_type1;

    typedef typename Acc2::value_type image_type2;

    //    typedef image_type1 value_type;

    ImageSplittingAccessor(Iter1 i1, Acc1 a1, Iter2 i2, Acc2 a2)
        : i1_(i1), a1_(a1), i2_(i2), a2_(a2)
    {}

    template <class V, class ITERATOR>
    void setComponent(V const & value, ITERATOR const & i, int idx) const
    {
        setComponentIsScalar(value, i, idx,
                             vigra::NumericTraits<image_type1>::isScalar() );
    }


#if 0

    template <class V, class ITERATOR>
    void setVector2VectorVector(V const & value, ITERATOR const & i) const
    {
        // get pixels at current position indicated by iterator
        image_type1 & v1 = a1_(i);
        image_type2 & v2 = a2_(i2_, i - i1_);
        // TODO: check if the size of both images is correct

        // copy into first image
        typename V::iterator vIt = value.begin();
        typename image_type1::iterator v1It = v1.begin();
        while ( v1It != v1.end() && vIt != value.end()) {
            *v1It = detail::RequiresExplicitCast<VALUETYPE>::cast(*vIt);
            ++v1It;
            ++vIt;
        }
        // copy rest into second image
        typename image_type2::iterator v2It = v2.begin();
        while ( v2It != v1.end() && vIt != value.end()) {
            *v2It = detail::RequiresExplicitCast<VALUETYPE>::cast(*vIt);
            ++v2It;
            ++vIt;
        }
        
        

        for (int i=0; i < value.size(); i++) {
            if (i <

        *i = detail::RequiresExplicitCast<VALUETYPE>::cast(value); }

    template <class V, class ITERATOR, class DIFFERENCE_>
    void set(V const & value, ITERATOR const & i, DIFFERENCE_ const & diff) const
    {
        i[diff]= detail::RequiresExplicitCast<VALUETYPE>::cast(value);
    }

#endif

protected:
    template <class V, class ITERATOR>
    void setComponentIsScalar(V const & value, ITERATOR const & i, int idx,
                              vigra::VigraTrueType) const
    {
        setComponentScalarIsScalar(value, i, idx,
                                   vigra::NumericTraits<image_type2>::isScalar() );
    }

    template <class V, class ITERATOR>
    void setComponentIsScalar(V const & value, ITERATOR const & i, int idx,
                              vigra::VigraFalseType) const
    {
        setComponentVectorIsScalar(value, i, idx,
                                   vigra::NumericTraits<image_type2>::isScalar() );
    }

    template <class V, class ITERATOR>
    void setComponentScalarIsScalar(V const & value, ITERATOR const & i, int idx,
                                    vigra::VigraTrueType) const
    {
        switch (idx) {
        case 0:
            a1_.set(value, i);
            break;
        case 1:
            a2_.set(value, i2_, i - i1_);
            break;
        default:
            vigra_fail("too many components in input value");
        }
    }

    template <class V, class ITERATOR>
    void setComponentScalarIsVector(V const & value, ITERATOR const & i, int idx,
                                    vigra::VigraTrueType) const
    {
        vigra_fail("vector -> scalar, vector accessor not implemented");
    }

    template <class V, class ITERATOR>
    void setComponentVectorIsScalar(V const & value, ITERATOR const & i, int idx,
                                    vigra::VigraTrueType) const
    {
        image_type1 & v1 = a1_(i);
        typename image_type1::size_type s1 = v1.size();
        if (idx < s1) {
            a1_.setComponent(value, i, idx);
        } else if ( idx == s1) {
            a2_.set(value, i2_, i - i1_);
        } else {
            vigra_fail("too many components in input value");
        }
    }

    template <class V, class ITERATOR>
    void setComponentVectorIsVector(V const & value, ITERATOR const & i, int idx,
                                    vigra::VigraTrueType) const
    {
        vigra_fail("vector -> vector, vector accessor not implemented");
    }

    Iter1 i1_;
    Acc1  a1_;
    Iter2 i2_;
    Acc2  a2_;
};

template <class T>
struct Multiply
{
    typedef T result_type;

    Multiply(T factor)
        : m_factor(factor)
    {}

    template <class PixelType>
    PixelType operator()(PixelType const& v) const
    {
        return vigra::NumericTraits<result_type>::fromRealPromote(v * m_factor);
    }

    T m_factor;
};

}  // namespace



#endif // _FUNCTORACCESSOR_H