attributes.hh

// Copyright (C) 2001, 2002, 2003, 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 OLN_MORPHO_ATTRIBUTES_HH
# define OLN_MORPHO_ATTRIBUTES_HH
# include <oln/basics.hh>
# include <mlc/type.hh>
# include <vector>
# include <oln/morpho/environments.hh>

// attribute dedicated macros
# define attr_lambda_type(T)    typename oln::morpho::attr::attr_traits< T >::lambda_type
# define attr_env_type(T)       typename oln::morpho::attr::attr_traits< T >::env_type
# define attr_value_type(T)     typename oln::morpho::attr::attr_traits< T >::value_type

# define attr_lambda_type_(T)    oln::morpho::attr::attr_traits< T >::lambda_type
# define attr_env_type_(T)       oln::morpho::attr::attr_traits< T >::env_type
# define attr_value_type_(T)     oln::morpho::attr::attr_traits< T >::value_type


# define attr_type_decl(self_type) \
      typedef mlc_exact_vt_type(self_type, Exact)       exact_type; \
      typedef attr_value_type(exact_type)               value_type; \
      typedef attr_env_type(exact_type)                 env_type; \
      typedef attr_lambda_type(exact_type)              lambda_type

namespace oln {
  namespace morpho {
    namespace attr {
      namespace tools {

        template <class T>
        T diffabs(const T &v1, const T &v2)
        {
          return v1 > v2 ? v1 - v2 : v2 - v1;
        }
      } // !tools


      // the traits fwd declaration
      template <class T>
      struct attr_traits;

      template <class In, class Exact>
      struct change_exact;


      // the attributes hierarchy

      /*------------*
        | attribute |
        *-----------*/
      template <class Exact>
      class attribute: public mlc_hierarchy::any<Exact>
      {
      public:
        typedef attribute<Exact>        self_type; /*< Self type of the class.*/
        attr_type_decl(self_type);

        void operator+=(const exact_type &rhs)
        {
          mlc_dispatch(pe)(rhs);
        };

        bool operator>=(const lambda_type &lambda) const
        {
          mlc_dispatch(ge)(lambda);
        };

        bool operator<(const lambda_type &lambda) const
        {
          mlc_dispatch(less)(lambda);
        };

        bool operator<(const exact_type &x) const
        {
          mlc_dispatch(less2)(x);
        };

        bool operator!=(const lambda_type &lambda) const
        {
          mlc_dispatch(ne)(lambda);
        };

        const lambda_type &toLambda() const
        {
          mlc_dispatch(toLambda)();
        };

        bool ge_impl(const lambda_type &lambda) const
        {
          return !(*this < lambda);
        };

        bool less2_impl(const exact_type &x) const
        {
          return *this < x.toLambda();
        };



      protected:
        attribute() {};

      };

      /*-----------*
        |   card    |
        *-----------*/

      template <class T = unsigned, class Exact = mlc::final>
      class card_type:
        public attribute<mlc_2_exact_vt_type(card_type, T, Exact)>
      {
      public:
        typedef card_type<T, Exact>                     self_type; 
        attr_type_decl(self_type);

        card_type()
          {
          };

        card_type(const lambda_type &lambda): value_(lambda)
          {
          };

        template <class I>
          card_type(const abstract::image<I>&,
                    const oln_point_type(I)&,
                    const env_type&):
          value_(ntg_unit_val(value_type))
          {
          };


        void pe_impl(const self_type &rhs)
          {
            value_ += rhs.value_;
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

        const lambda_type &toLambda_impl() const
        {
          return value_;
        };

      protected:
        value_type value_; 
      };

      /*-------------------------------*
        | card with info on other image |
        *------------------------------*/
      template <class I, class T = unsigned, class Exact = mlc::final>
      class card_full_type: public card_type<T,
                                             typename mlc::exact_vt<card_full_type<I,
                                                                                   T,
                                                                                   Exact>,
                                                                    Exact>::ret>
      {
      public:
        typedef card_full_type<I, T, Exact>                     self_type; 
        attr_type_decl(self_type);
        typedef card_type<T, exact_type>                        super_type; 

        card_full_type(): super_type()
          {
          };

        card_full_type(const lambda_type &lambda): super_type(lambda)
          {
          };

        template <class I2>
          card_full_type(const abstract::image<I2> &im,
                    const oln_point_type(I2) &p,
                    const env_type &env): super_type(im, p, env)
          {
          };
      };

      /*--------------*
        |  integral   |
        *------------*/

      template <class T = unsigned, class Exact = mlc::final>
      class integral_type:
        public attribute<mlc_2_exact_vt_type(integral_type, T, Exact)>
      {
      public:
        typedef integral_type<T, Exact>                 self_type; 
        attr_type_decl(self_type);

        integral_type()
          {
          };

        integral_type(const lambda_type &lambda): value_(lambda)
          {
          };

        template <class I>
          integral_type(const abstract::image<I> &input,
                        const oln_point_type(I) &p,
                        const env_type &) :
          reflevel_(input[p]),
          area_(ntg_unit_val(value_type)),
          value_(ntg_unit_val(value_type))
          {
          };

        // interface part
        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };

        const value_type &getReflevel() const
          {
            mlc_dispatch(getReflevel)();
          };

        const value_type &getArea() const
          {
            mlc_dispatch(getArea)();
          };

        // impl part
        const value_type &getValue_impl() const
          {
            return value_;
          };

        const value_type &getReflevel_impl() const
          {
            return reflevel_;
          };

        const value_type &getArea_impl() const
          {
            return area_;
          };

        void pe_impl(const self_type &rhs)
          {
            value_ += rhs.getValue() + area_ * tools::diffabs(reflevel_, rhs.getReflevel());
            area_ += rhs.getArea();
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        value_type reflevel_; 
        value_type area_; 
        value_type value_; 
      };

      /*-------------------*
        | other image_type |
        ------------------*/
      template <class Dad, class I, class Exact = mlc::final>
      class other_image:
        public change_exact<Dad, typename mlc::exact_vt<other_image<Dad, I, Exact>, Exact>::ret >::ret
      {
      public:
        typedef other_image<Dad, I,  Exact>                                             self_type; /*< Self type of the class.*/
        typedef typename abstract::image<mlc_exact_type(I)>                             im_type; /*< Type of substituted image.*/
        attr_type_decl(self_type);
        typedef typename change_exact<Dad,
                                      typename mlc::exact_vt<other_image<Dad, I, Exact>,
                                                             Exact>::ret >::ret         super_type; /*< Mother class type.*/

        other_image(): super_type()
        {
        };

        other_image(const lambda_type &lambda): super_type(lambda)
        {
        };

        template <typename IM>
        other_image(const abstract::image<IM> &,
                    const oln_point_type(I) &p,
                    const env_type & e): super_type(e.getImage(), p, e)
        {
        };
      };

      /*----------------------*
        | ball_parent_change |
        *--------------------*/
      template <class I, class Exact = mlc::final>
      class ball_parent_change:
        public attribute<mlc_2_exact_vt_type(ball_parent_change, I, Exact)>
      {
      public:
        typedef ball_parent_change<I,  Exact>                   self_type; /*< Self type of the class.*/
        typedef typename abstract::image<mlc_exact_type(I)>     im_type; /*< Type of substituted image.*/
        attr_type_decl(self_type);
        typedef oln_value_type(I)                               pts_type; 
        typedef typename pts_type::const_iterator               cst_iter_type; 
        typedef typename pts_type::value_type                   point_type; 
        typedef oln_dpoint_type(point_type)     dpoint_type; 

        ball_parent_change(): value_(ntg_zero_val(value_type)), points_()
        {
        };

        ball_parent_change(const lambda_type &lambda): value_(lambda), points_()
        {
        };

        template <typename IM>
        ball_parent_change(const abstract::image<IM> &,
                           const oln_point_type(IM) &p,
                           const env_type &e): points_()//: super_type(/*e.getImage(), */e.getPoint(p), e)
        {
          std::copy(e.getParent()[p].begin(),
                    e.getParent()[p].end(),
                    std::back_inserter(points_));
        };

        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };


        const pts_type &getPts() const
          {
            mlc_dispatch(getPts)();
          };

        // impl
        const value_type &getValue_impl() const
          {
            return value_;
          };

        const pts_type &getPts_impl() const
          {
            return points_;
          };

        void pe_impl(const self_type &rhs)
          {
            precondition(points_.size() < (128 * 128 * 128 + 1));
            std::copy(rhs.getPts().begin(),
                      rhs.getPts().end(),
                      std::back_inserter(points_));
            compute_value();
            value_ = ntg::max(value_, rhs.getValue());
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        void compute_value()
          {
            value_type  last = value_;
            value_ = ntg_zero_val(value_type);
            for (cst_iter_type p1 = points_.begin(); p1 != points_.end(); ++p1)
              for (cst_iter_type p2 = points_.begin(); p2 != points_.end(); ++p2)
                {
                  unsigned d = 0;
                  dpoint_type   p = *p1 - *p2;
                  for (int i = 0; i < point_traits<point_type>::dim; ++i)
                    d += p.nth(i) * p.nth(i);
                  if (d > value_)
                    value_ = d;
                }
            value_ /= 2;
            value_ = ntg::max(value_, last);
          }

        value_type      value_;
        pts_type        points_;
      };

      /*-----------*
        |  height   |
        *-----------*/
      template <class T = unsigned, class Exact = mlc::final>
      class height_type:
        public attribute<mlc_2_exact_vt_type(height_type, T, Exact)>
      {
      public:
        typedef height_type<T, Exact>                   self_type;
        attr_type_decl(self_type);

        height_type()
          {
          };

        height_type(const lambda_type &lambda):
          value_(lambda),
          min_(ntg_zero_val(value_type)),
          max_(lambda)
          {
          };

        template <class I>
          height_type(const abstract::image<I> &input,
                      const oln_point_type(I) &p,
                      const env_type&):
          value_(ntg_zero_val(value_type)),
          min_(input[p]),
          max_(input[p])
          {
          };

        const value_type &getMin() const
          {
            mlc_dispatch(getMin)();
          };

        const value_type &getMax() const
          {
            mlc_dispatch(getMax)();
          };

        // impl part
        const value_type &getMin_impl() const
          {
            return min_;
          };

        const value_type &getMax_impl() const
          {
            return max_;
          };

        void pe_impl(const height_type &rhs)
          {
            min_ = ntg::min(min_, rhs.getMin());
            max_ = ntg::max(max_, rhs.getMax());
            value_ = max_ - min_;
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        value_type      value_; 
        value_type      min_; 
        value_type      max_; 
      };


      /*-----------*
        | maxvalue  |
        *-----------*/
      template <class T = unsigned, class Exact = mlc::final>
      class maxvalue_type:
        public attribute<mlc_2_exact_vt_type(maxvalue_type, T, Exact)>
      {
      public:
        typedef maxvalue_type<T, Exact>                 self_type; 
        attr_type_decl(self_type);

        maxvalue_type()
          {
          };

        maxvalue_type(const lambda_type &lambda): value_(lambda)
          {
          };

        template <class I>
          maxvalue_type(const abstract::image<I> &input,
                        const oln_point_type(I) &p,
                        const env_type &):
          value_(input[p])
          {
          };

        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };

        const value_type &getValue_impl() const
          {
            return value_;
          };

        void pe_impl(const maxvalue_type &rhs)
          {
            value_ = ntg::max(value_, rhs.getValue());
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        value_type value_; 
      };


      /*-----------*
        | minvalue  |
        *-----------*/
      template <class T = unsigned, class Exact = mlc::final>
      class minvalue_type:
        public attribute<mlc_2_exact_vt_type(minvalue_type, T, Exact)>
      {
      public:
        typedef minvalue_type<T, Exact>                 self_type;
        attr_type_decl(self_type);

        minvalue_type()
          {
          };

        minvalue_type(const lambda_type &lambda): value_(lambda)
          {
          };

        template <class I>
          minvalue_type(const abstract::image<I> &input,
                        const oln_point_type(I) &p,
                        const env_type &) :
          value_(input[p])
          {
          };

        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };

        const value_type &getValue_impl() const
          {
            return value_;
          };

        void pe_impl(const minvalue_type &rhs)
          {
            value_ = ntg::min(value_, rhs.getValue());
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ > lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        value_type value_; 
      };


      /*-----------*
        |   ball    |
        *-----------*/
      template <class I, class Exact = mlc::final>
      class ball_type:
        public attribute<mlc_2_exact_vt_type(ball_type, I, Exact)>
      {
      public:
        typedef ball_type<I, Exact>                     self_type; 
        attr_type_decl(self_type);
        typedef abstract::image<mlc_exact_type(I)>      im_type; 
        typedef oln_point_type(im_type)                 point_type; 
        typedef oln_dpoint_type(im_type)                        dpoint_type; 
        typedef std::vector<point_type>                 pts_type; 
        typedef typename pts_type::const_iterator               cst_iter_type; 

        ball_type()
          {
          };

        ball_type(const lambda_type &lambda): value_(lambda), pts_()
          {
          };


        ball_type(const im_type&, const point_type &p, const env_type &) :
          value_(ntg_zero_val(value_type)), pts_()

          {
            pts_.push_back(p);
          };

        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };


        const pts_type &getPts() const
          {
            mlc_dispatch(getPts)();
          };

        // impl
        const value_type &getValue_impl() const
          {
            return value_;
          };

        const pts_type &getPts_impl() const
          {
            return pts_;
          };

        void pe_impl(const ball_type &rhs)
          {
            value_type  last = value_;
            std::copy(rhs.getPts().begin(),
                      rhs.getPts().end(),
                      std::back_inserter(pts_));
            value_ = ntg_zero_val(value_type);
            for (cst_iter_type p1 = pts_.begin(); p1 != pts_.end(); ++p1)
              for (cst_iter_type p2 = pts_.begin(); p2 != pts_.end(); ++p2)
                {
                  unsigned d = 0;
                  dpoint_type   p = *p1 - *p2;
                  for (int i = 0; i < point_traits<point_type>::dim; ++i)
                    d += p.nth(i) * p.nth(i);
                  if (d > value_)
                    value_ = d;
                }
            value_ /= 2;
            value_ = ntg::max(value_, last);
            value_ = ntg::max(value_, rhs.getValue());
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return lambda != value_;
          };

      protected:
        value_type      value_; 
        pts_type                pts_; 
      };



      /*-----------*
        |   dist    |
        *-----------*/
      template <class I, class Exact = mlc::final>
      class dist_type:
        public attribute<mlc_2_exact_vt_type(dist_type, I, Exact)>
      {
      public:
        typedef dist_type<I, Exact>                     self_type; 
        attr_type_decl(self_type);
        typedef abstract::image<mlc_exact_type(I)>      im_type; 
        typedef oln_point_type(im_type)                 point_type; 
        typedef oln_dpoint_type(im_type)                        dpoint_type; 

        dist_type()
          {
          };

        dist_type(const im_type&,
                  const point_type &p,
                  const env_type &):
          value_(ntg_zero_val(value_type)),
          center_(p)
          {
          };

        const value_type &getValue() const
          {
            mlc_dispatch(getValue)();
          };

        dist_type(const lambda_type lambda): value_(lambda)
          {
          };

        const point_type &getCenter() const
          {
            mlc_dispatch(getCenter)();
          };

        // impl
        const point_type &getCenter_impl() const
          {
            return center_;
          };

        const value_type &getValue_impl() const
          {
            return value_;
          };

        void pe_impl(const dist_type &rhs)
          {
            value_type  last = value_;
            dpoint_type p = center_ - rhs.getCenter();

            value_ = ntg_zero_val(value_type);
            for (int i = 0; i < point_traits<point_type>::dim; ++i)
              value_ += p.nth(i) * p.nth(i);
            value_ = sqrt(value_);
            value_ = ntg::max(value_, last);
            value_ = ntg::max(value_, rhs.getValue());
          };

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          };

        bool ne_impl(const lambda_type &lambda) const
          {
            return value_ != lambda;
          };

      protected:
        value_type value_; 
        point_type center_; 

      };



      /*-----------*
        |  cube   |
        *-----------*/
      template <class I, class Exact = mlc::final>
      class cube_type:
        public attribute<mlc_2_exact_vt_type(cube_type, I, Exact)>
      {
      public:
        typedef cube_type<I, Exact>                     self_type; 
        attr_type_decl(self_type);
        typedef abstract::image<mlc_exact_type(I)>      im_type; 
        typedef oln_point_type(im_type)                 point_type; 
        typedef oln_dpoint_type(im_type)                        dpoint_type; 

        enum {dim = point_traits<point_type>::dim};

        cube_type()
          {
          }

        cube_type(const lambda_type &lambda):
          mins_(dim),
          maxs_(dim),
          value_(lambda)
          {
            for (int i = 0; i < point_traits<point_type>::dim; ++i)
              {
                maxs_[i] = lambda;
                mins_[i] = ntg_zero_val(coord);
              }
          };

        cube_type(const im_type&,
                  const point_type &p,
                  const env_type &):
          mins_(dim), maxs_(dim), value_(ntg_zero_val(value_type))
          {
            for (int i = 0; i < dim; ++i)
              mins_[i] = maxs_[i] = p.nth(i);
          }

        int getMin(int i) const
          {
            mlc_dispatch(getMin)(i);
          };

        int getMax(int i) const
          {
            mlc_dispatch(getMax)(i);
          };

        // impl
        int getMin_impl(int i) const
          {
            precondition(i < dim);
            return mins_[i];
          };

        int getMax_impl(int i) const
          {
            precondition(i < dim);
            return maxs_[i];
          };

        void pe_impl(const cube_type &rhs)
          {
            for (int i = 0; i < dim; ++i)
              {
                mins_[i] = ntg::min(mins_[i], rhs.getMin(i));
                maxs_[i] = ntg::max(maxs_[i], rhs.getMax(i));
              }
            value_ = maxs_[0] - mins_[0];
            for (int i = 1; i < dim; ++i)
              if (value_ < value_type(maxs_[i] - mins_[i]))
                value_ = maxs_[i] - mins_[i];
          }

        bool less_impl(const lambda_type &lambda) const
          {
            return value_ < lambda;
          }

        bool ne_impl(const lambda_type &lambda) const
          {
            return value_ != lambda;
          };

      protected:
        std::vector<coord>      mins_;
        std::vector<coord>      maxs_;
        value_type              value_;
      };



      /*------*
        | box |
        *-----*/
      template <class I, class Exact = mlc::final>
      class box_type:
        public attribute<mlc_2_exact_vt_type(box_type, I, Exact)>
      {
      public:
        typedef box_type<I, Exact>                      self_type; 
        attr_type_decl(self_type);
        typedef abstract::image<mlc_exact_type(I)>      im_type; 
        typedef oln_point_type(im_type)                 point_type; 
        typedef oln_dpoint_type(im_type)                        dpoint_type; 
        enum {dim = point_traits<point_type>::dim };

        box_type(const lambda_type &lambda): maxs_(dim), mins_(dim)
          {
            for (int i = 0; i < dim; ++i)
              {
                mins_[i] = ntg_zero_val(value_type);
                maxs_[i] = lambda[i];
              }
          };

        box_type()
          {
          };

        box_type(const im_type&, const point_type &p, const env_type &): maxs_(dim), mins_(dim)
          {
            for (int i = 0; i < dim; ++i)
              mins_[i] = maxs_[i] = p.nth(i);
          };

        value_type getMin(int i) const
          {
            mlc_dispatch(getMin)(i);
          };


        value_type getMax(int i) const
          {
            mlc_dispatch(getMax)(i);
          };

        // impl
        value_type getMin_impl(int i) const
          {
            precondition(i < point_traits<point_type>::dim);
            return mins_[i];
          };

        value_type getMax_impl(int i) const
          {
            precondition(i < point_traits<point_type>::dim);
            return maxs_[i];
          };

        void pe_impl(const box_type &rhs)
          {
            for (int i = 0; i < dim; ++i)
              {
                mins_[i] = ntg::min(mins_[i], rhs.getMin(i));
                maxs_[i] = ntg::max(maxs_[i], rhs.getMax(i));
              }
          }

        bool less_impl(const lambda_type &lambda) const
          {
            for (int i = 0; i < dim; ++i)
              if ((maxs_[i] - mins_[i]) >= lambda[i])
                return false;
            return true;
          }

        bool ne_impl(const lambda_type &lambda) const
          {
            for (int i = 0; i < dim; ++i)
              if ((maxs_[i] - mins_[i]) == lambda[i])
                return false;
            return true;
          };

      protected:
        std::vector<value_type> maxs_; 
        std::vector<value_type> mins_; 
      };

      /*-------------------------
        | traits specializations |
        \------------------------*/


      template <class T, class Exact>
      struct attr_traits<integral_type<T, Exact> >
      {
        typedef T               value_type; 
        typedef value_type      lambda_type; 
        typedef env::NullEnv    env_type; 
      };

      template <class T, class Exact>
      struct attr_traits<height_type<T, Exact> >
      {
        typedef T               value_type; 
        typedef value_type      lambda_type; 
        typedef env::NullEnv    env_type; 
      };

      template <class T, class Exact>
      struct attr_traits<card_type<T, Exact> >
      {
        typedef T               value_type; 
        typedef value_type      lambda_type; 
        typedef env::NullEnv    env_type; 
      };

      template <class I, class T, class Exact>
      struct attr_traits<card_full_type<I, T, Exact> >
      {
        typedef T                       value_type; 
        typedef value_type              lambda_type; 
        typedef env::OtherImageEnv<I>   env_type; 
      };

      template <class T, class Exact>
      struct attr_traits<maxvalue_type<T, Exact> >
      {
        typedef T               value_type; 
        typedef value_type      lambda_type; 
        typedef env::NullEnv    env_type; 
      };

      template <class T, class Exact>
      struct attr_traits<minvalue_type<T, Exact> >
      {
        typedef T               value_type; 
        typedef value_type      lambda_type; 
        typedef env::NullEnv    env_type; 
      };

      template <class I, class Exact>
      struct attr_traits<ball_type<I, Exact> >
      {
        typedef unsigned                        value_type; 
        typedef value_type                      lambda_type; 
        typedef oln::morpho::env::NullEnv       env_type; 
      };

      template <class I, class Exact>
      struct attr_traits<dist_type<I, Exact> >
      {
        typedef float                           value_type; 
        typedef value_type                      lambda_type; 
        typedef oln::morpho::env::NullEnv       env_type; 
      };

      template <class I, class Exact>
      struct attr_traits<cube_type<I, Exact> >
      {
        typedef unsigned                        value_type; 
        typedef value_type                      lambda_type; 
        typedef oln::morpho::env::NullEnv       env_type; 
      };

      template <class I, class Exact>
      struct attr_traits<box_type<I, Exact> >
      {
        typedef unsigned                                        value_type; 
        typedef ntg::vec<I::dim, value_type, mlc::final>        lambda_type; 
        typedef oln::morpho::env::NullEnv                       env_type; 
      };

      template <class Dad, class I, class Exact>
      struct attr_traits<other_image<Dad, I, Exact> >
      {
        //typedef typename change_exact<Dad, other_image<Dad, I, Exact> >::ret  super_type;
        typedef typename change_exact<Dad,
                                      typename mlc::exact_vt<other_image<Dad, I, Exact>,
                                                             Exact>::ret>::ret          super_type; 
        typedef attr_value_type(super_type)                                             value_type; 
        typedef attr_lambda_type(super_type)                                            lambda_type; 
        typedef oln::morpho::env::OtherImageEnv<I>                                      env_type; 
      };

      template <class I, class Exact>
      struct attr_traits<ball_parent_change<I, Exact> >
      {
        typedef unsigned                value_type; 
        typedef value_type              lambda_type; 
        typedef env::ParentEnv<I>       env_type; 
      };

      // traits for other_image derivation

      template <class NewExact, class OldExact, class T>
      struct change_exact<integral_type<T, OldExact>, NewExact>
      {
        typedef integral_type<T, NewExact>      ret;
      };

    }// !attr
  } // !morpho
} 

  /*-----------*
    |  diamond  |
    *-----------*/

  // FIXME: to be written...


#endif // !OLN_MORPHO_ATTRIBUTES

---