subq_morpher.hh

// Copyright (C) 2004  EPITA Research and Development Laboratory
//
// This file is part of the Olena Library.  This library is free
// software; 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.
//
// This library 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
// along with this library; see the file COPYING.  If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.
//
// As a special exception, you may use this file as part of a free
// software library without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to
// produce an executable, this file does not by itself cause the
// resulting executable to be covered by the GNU General Public
// License.  This exception does not however invalidate any other
// reasons why the executable file might be covered by the GNU General
// Public License.



#ifndef OLENA_MORPHER_SUBQ_MORPHER_HH
# define OLENA_MORPHER_SUBQ_MORPHER_HH

# include "generic_morpher.hh"

namespace oln {

  namespace morpher {

    template <class SrcType, unsigned N, class Exact = mlc::final>
    struct subq_morpher;


    template <class T, unsigned N>
    struct color_mute
    {
    };

    template <unsigned nbcomps_,
              unsigned nbits_,
              template <unsigned> class color_system,
              unsigned N>
    struct color_mute<ntg::color<nbcomps_, nbits_, color_system>, N>
    {
      typedef ntg::color<nbcomps_, N, color_system> ret;
      enum { nbcomps = nbcomps_ };
    };



  } // end of namespace morpher

  template <class SrcType, unsigned N, class Exact>
  struct image_id<oln::morpher::subq_morpher<SrcType, N, Exact> >
  {
    enum {dim = SrcType::dim};
    typedef oln_impl_type(SrcType) impl_type;
    typedef typename oln::morpher::color_mute<oln_value_type(SrcType), N>::ret value_type;
    typedef typename mlc::exact_vt<oln::morpher::subq_morpher<SrcType, N, Exact>,
                                    Exact>::ret exact_type;

    typedef oln_point_type(SrcType) point_type;
  };

  template <class SrcType, unsigned N, class Exact>
  struct image_traits <oln::morpher::subq_morpher<SrcType, N, Exact> > :
    public image_traits<oln::morpher::abstract::generic_morpher<SrcType,
                                                                typename image_id<oln::morpher::subq_morpher<SrcType, N, Exact> >::exact_type> >
  {
  };

  namespace morpher {



    template <class SrcType, unsigned N, class Exact>
    struct subq_morpher:
      public abstract::generic_morpher<SrcType,
                                       typename oln::image_id<subq_morpher<SrcType, N, Exact> >::exact_type>
    {

      typedef typename oln::image_id<subq_morpher<SrcType, N, Exact> >::exact_type exact_type;


      typedef abstract::generic_morpher<SrcType,
                                        exact_type> super_type;

      typedef typename image_id<exact_type>::value_type value_type;
      typedef typename image_id<exact_type>::point_type point_type;
      typedef typename image_id<exact_type>::impl_type impl_type;
      enum { nbcomps = color_mute<oln_value_type(SrcType), N>::nbcomps };

      subq_morpher(const SrcType &ima)
        : super_type(ima)
      {}

      subq_morpher(const subq_morpher<SrcType, N>& r)
        : super_type(r.get_ima())
      {}

      subq_morpher() {}

      const value_type
      at(const point_type& p) const
      {
        value_type      tmp;
        unsigned int    i;

        for (i = 0; i < nbcomps; i++)
          {
            tmp[i] = this->ima_[p][i] / ((ntg_max_val(ntg_comp_type(oln_value_type(SrcType))) + 1)
                                         / (ntg_max_val(ntg_comp_type(value_type)) + 1));
          }
        return tmp;
      }

      const impl_type*
      impl() const
      {
        return ima_.impl();
      }

      static std::string
      name()
      {
        return "subq_morpher<" + SrcType::name() + ">";
      }

    };

    template <unsigned S, class I>
    const subq_morpher<I, S> sqmorph(I &ima)
    {
      return subq_morpher<I, S>(ima);
    }

  } // end of namespace morpher

} // end of namespace morpher




#endif // !OLENA_MORPHER_SUBQ_MORPHER_HH

---