ivl/details/image/impl/specialization/image_class.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */


//--------------------------------------------------------------
// CLASS image

namespace data {

template <class HAS_RANDOM_ACCESS, class IS_2D>
struct get_pixel { };

template <>
struct get_pixel<types::t_true, types::t_false>
{
        template<class A>
        static inline
        typename A::pixel from(A& a, size_t row, size_t col)
        {
                return typename A::pixel(
                        a._iter(2, a.begin() + (col * a.rows() + row)), a.channels());
        }
        template<class A>
        static inline
        typename A::const_pixel from(const A& a, size_t row, size_t col)
        {
                return typename A::const_pixel(
                        a._iter(2, a.begin() + (col * a.rows() + row)), a.channels());
        }
};

template <>
struct get_pixel<types::t_false, types::t_false>
{
        template<class A>
        static inline
        typename A::pixel from(A& a, size_t row, size_t col)
        {
                return typename A::pixel(
                        a._iter(2,
                                array<size_t, data::fixed<2> >(row, col)), a.channels());
        }
        template<class A>
        static inline
        typename A::const_pixel from(const A& a, size_t row, size_t col)
        {
                return typename A::const_pixel(
                        a._iter(2,
                                array<size_t, data::fixed<2> >(row, col)), a.channels());
        }
        /*
        typename A::pixel from(A& a, size_t row, size_t col)
        {
                return typename A::pixel(a._iter(2, a._begin(0) + row, col));
        }
        template<class A>
        static inline
        typename A::const_pixel from(const A& a, size_t row, size_t col)
        {
                return typename A::const_pixel(a._iter(2, a._begin(0) + row, col));
        }
        */
};

template <class ANY>
struct get_pixel<ANY, types::t_true>
{
        template<class A>
        static inline
        typename A::pixel from(A& a, size_t row, size_t col)
        {
                return a(row, col);
        }
        template<class A>
        static inline
        typename A::const_pixel from(const A& a, size_t row, size_t col)
        {
                return a(row, col);
        }
};


} /* namespace data */

template <class T,
                 class OPTS = data::normal_image<0>
             >
class image :
        public
                array_common_base<image<T, OPTS> >
{
private:
        typedef array_common_base<image<T, OPTS> > common_base_class;

        using common_base_class::Ch;
        enum { N = common_base_class::im_channels::value };

        typedef typename image_details::cv<true, T>::iplimage_t iplimage_t;

        void copy_from(const iplimage_t* src)
        {
                image_details::cv<true, T>::copy_from(*this, src);
        }

        void copy_to(iplimage_t* ipl) const
        {
                image_details::cv<true, T>::copy_to(*this, ipl);
        }

public:
        typedef image this_type;

        typedef typename this_type::derived_type derived_type;

        typedef typename common_base_class::base_class base_class;

        typedef this_type this_image_type;

        typedef this_type array_type;

        typedef typename this_type::size_type size_type;

        using base_class::derived;

        typedef typename this_type::all_init_arg_base all_init_arg;
        typedef typename this_type::data_init_arg_base data_init_arg;


// image types
        typedef typename types::best_iterator<base_class>::type best_iterator;
        typedef typename base_class::const_iterator const_iterator;

        typedef typename types::best_iterator_nd<base_class>::type best_iterator_nd;
        typedef typename base_class::const_iterator_nd const_iterator_nd;

        typedef typename types::t_if<types::t_expr<N != 1>,
                array<T,
                        data::ref_iterator<const_iterator_nd, types::term, N> >,
                typename const_iterator::reference>::type
                        const_pixel;

        typedef typename types::t_if<types::t_expr<N != 1>,
                array<T,
                        data::ref_iterator<best_iterator_nd, const_iterator_nd, N> >,
                typename best_iterator::reference>::type pixel;

        typedef ivl::color<T, OPTS::Ch> color_type;


        image() : common_base_class(size_dims<3>(0, 0, (!N ? 1 : N))) { };

        image(size_t rows, size_t cols, size_t channels = (!N ? 3 : N)) :
                common_base_class(size_dims<3>(rows, cols, channels))
                { CHECK(!N || channels == N, edims); };

        image(size_t rows, size_t cols, size_t channels, const T& value) :
                common_base_class(size_dims<3>(rows, cols, channels), value)
                { CHECK(!N || channels == N, edims); }

        /*image(size_t rows, size_t cols, size_t channels, const T* ptr) :
                common_base_class(size_dims<3>(rows, cols, channels), ptr)
                { CHECK(!N || channels == N, edims); }*/

        template <class J, class D>
        image(size_t rows, size_t cols, size_t channels, const array<J, D>& a) :
                common_base_class(size_dims<3>(rows, cols, channels), a)
                { CHECK(!N || channels == N, edims); }

        template <class S>
        image(const array<size_t, S>& sz) :
                common_base_class(sz) {} ;

        template <class S>
        image(const array<size_t, S>& sz, const T& value) :
                common_base_class(sz, value) {} ;

        template <class S>
        image(const array<size_t, S>& sz, const T* ptr) :
                common_base_class(sz, ptr) {} ;

        template <class S>
        image(const array<size_t, S>& sz, const data_init_arg& data) :
                common_base_class(sz, data) {} ;


        template <class S, class J, class D>
        image(const array<size_t, S>& sz, const array<J, D>& a) :
                common_base_class(sz, a) {} ;

        image(const std::string& filename, image_channels channels = ic_auto);

        image(const iplimage_t* ipl);

        template <class J, class S>
        image(const array_nd<J, S>& a) : common_base_class(a) {}

        template <class J, class S>
        image(array_nd<J, S>& a) : common_base_class(a) {}

        image(const this_type& a) : common_base_class(a) {}

        // Destructor
        ~image() {}


        //using common_base_class::operator=;
        template<class K>
        derived_type& operator=(const K& k)
        { common_base_class::operator=(k); return derived(); }

        this_type& operator=(const this_type& a) // copy operator
        { common_base_class::operator=(a); return *this; }

        derived_type& operator=(const iplimage_t* src)
        { copy_from(src); return this->derived(); }
        // sorry, but that's the effect of free template argument
        derived_type& operator=(iplimage_t* src)
                { return ((*this) = static_cast<const iplimage_t*>(src)); }
/*
        derived_type& operator=(const T& s)
                { return base_class::operator=(s); };

        template<class S, class K>
        derived_type& operator=(const array_nd<T, S, K>& a)  { return base_class::operator=(a); }

        template<int M, class S, class K>
        derived_type& operator=(const image<T, M, S, K>& a) { return base_class::operator=(a); }

        this_type& operator=(const this_type& a) { return base_class::operator=(a); }
*/

        // Member Accessors
        using base_class::size_nd;
        size_t rows() const { return size_nd()[0]; }
        size_t cols() const { return size_nd()[1]; }
        size_t channels() const
                { return data::get_channels<N>::from(this->size_nd()); }

        size_t width() const { return cols(); }
        size_t height() const { return rows(); }

        inline const_pixel col(size_t row, size_t col) const
        {
                return data::get_pixel<
                        typename this_type::data_type::has_random_access,
                        typename types::t_expr<N == 1>::type>::
                        from(*this, row, col);
        }
        inline pixel col(size_t row, size_t col)
        {
                return data::get_pixel<
                        typename this_type::data_type::has_random_access,
                        typename types::t_expr<N == 1>::type>::
                        from(*this, row, col);
        }
        inline const_pixel col(const const_iterator& it) const { return pixel(it); }

        inline pixel col(const best_iterator& it) { return pixel(it); }

        color_type black() const
                { return color_type(channels(), color_values<T>::min()); }
        color_type white() const
                { return color_type(channels(), color_values<T>::max()); }

        iplimage_t* ipl() const
        {
                return image_details::cv<true, T>::ipl(*this);
        }

        // OpenCV functions
        void load(const std::string& filename, image_channels channels = ic_auto)
        {
                image_details::cv<true, T>::load(*this, filename, channels);
        }
        void save(const std::string& filename) const
        {
                image_details::cv<true, T>::save(*this, filename);
        }

        // Image processing functions


        derived_type& put_pixel(double_point<2> a, color_type col = ivl::white<T, rgb>()) { this->col(a.y, a.x) = col; }
        color_type get_pixel(double_point<2> a) { return this->col(a.y, a.x); }

        derived_type& line(double_point<2> a, double_point<2> b, color_type col = ivl::white<T, rgb>(), double thickness = 1.5, double opacity = 1.)
        { line_on(*this, a, b, col, thickness, opacity); return this->derived(); }
        derived_type& circle(double_point<2> a, double radius, color_type col = ivl::white<T, rgb>(), double thickness = 1.5, double opacity = 1.)
        { return circle_on(*this, a, radius, col, thickness, opacity); }
        derived_type& rect(double_point<2> a, double_point<2> b, color_type col = ivl::white<T, rgb>(), double thickness = 1.5, double opacity = 1.)
        { return rect_on(*this, a, b, col, thickness, opacity); }
        derived_type& ellipse(double_point<2> a, double_point<2> b, double radius, color_type col = ivl::white<T, rgb>(), double thickness = 1.5, double opacity = 1.)
        { return ellipse_on(*this, a, b, radius, col, thickness, opacity); }
        derived_type& ellipse(double_point<2> c, double radius1, double radius2, double angle, color_type col = ivl::white<T, rgb>(), double thickness = 1.5, double opacity = 1.)
        { return ellipse_on(*this, c, radius1, radius2, angle, col, thickness, opacity); }

        derived_type& fill_circle(double_point<2> a, double radius, color_type col = ivl::white<T, rgb>(), double opacity = 1.)
        { return fill_circle_on(*this, a, radius, col, opacity); }
        derived_type& fill_rect(double_point<2> a, double_point<2> b, color_type col = ivl::white(ivl::color_type<T, rgb>()), double opacity = 1.)
        { return fill_rect_on(*this, a, b, col, opacity); }
        derived_type& fill_ellipse(double_point<2> a, double_point<2> b, double radius, color_type col = ivl::white(ivl::color_type<T, rgb>()), double opacity = 1.)
        { return fill_ellipse_on(*this, a, b, radius, col, opacity); }
        derived_type& fill_ellipse(double_point<2> c, double radius1, double radius2, double angle, color_type col = ivl::white(ivl::color_type<T, rgb>()), double opacity = 1.)
        { return fill_ellipse_on(*this, c, radius1, radius2, angle, col, opacity); }
        derived_type& fill_triangle(double_point<2> a, double_point<2> b, double_point<2> c, color_type col = ivl::white(ivl::color_type<T, rgb>()), double opacity = 1.)
        { return fill_triangle_on(*this, a, b, c, col, opacity); }
        derived_type& fill_quad(double_point<2> a, double_point<2> b, double_point<2> c, double_point<2> d, color_type col = ivl::white(ivl::color_type<T, rgb>()), double opacity = 1.)
        { return fill_quad_on(*this, a, b, c, d, col, opacity); }
};