attribute_closing_opening.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 OLENA_ATTRIBUTE_CLOSING_OPENING_HH
# define OLENA_ATTRIBUTE_CLOSING_OPENING_HH

#include <oln/morpho/attribute_union_find.hh>


namespace oln {
  namespace morpho {
    namespace fast {
      namespace tarjan {
        namespace internal {

          template<class I, class N, class A>
          oln_concrete_type(I)
            attr_closing_(const abstract::non_vectorial_image<I>& input,
                          const abstract::neighborhood<N>& Ng,
                          const attr_lambda_type(A) &lambda,
                          const attr_env_type(A) &env = attr_env_type(A)())
          {
            typedef tarjan::tarjan_set<oln_concrete_type(I), A > tarjan_set_type;
            tarjan_set_type attr_closing(input.exact(), env);
            return attr_closing.template get_comptute<true>(lambda, Ng);
          }

          template<class I, class N, class A>
          oln_concrete_type(I)
            attr_opening_(const abstract::non_vectorial_image<I>& input,
                          const abstract::neighborhood<N>& Ng,
                          const attr_lambda_type(A) &lambda,
                          const attr_env_type(A) &env = attr_env_type(A)())
          {
            typedef tarjan::tarjan_set<oln_concrete_type(I), A > tarjan_set_type;
            tarjan_set_type attr_opening(input.exact(), env);
            return attr_opening.template get_comptute<false>(lambda, Ng);
          }

        } // !internal
      } // !tarjan
      // macro for some attribute opening/closing declarations
# define xxx_opening_decl(T) \
      template<class I, class N> \
      oln_concrete_type(I) \
        T##_opening(const abstract::non_vectorial_image<I>& input, \
                       const abstract::neighborhood<N>& Ng, \
                       const attr_lambda_type(attr::T##_type<unsigned>) &lambda) \
      { \
        return tarjan::internal::attr_opening_<I, N, attr::T##_type<unsigned> >(input, Ng, lambda); \
      }

# define xxx_closing_decl(T) \
      template<class I, class N> \
      oln_concrete_type(I) \
        T##_closing(const abstract::non_vectorial_image<I>& input, \
                       const abstract::neighborhood<N>& Ng, \
                       const attr_lambda_type(attr::T##_type<unsigned>) &lambda) \
      { \
        return tarjan::internal::attr_closing_<I, N, attr::T##_type<unsigned> >(input, Ng, lambda); \
      }


      // same as previous, but for attribute based on image types
# define xxx_opening_im_decl(T) \
      template<class I, class N> \
      oln_concrete_type(I) \
        T##_opening(const abstract::non_vectorial_image<I>& input, \
                       const abstract::neighborhood<N>& Ng, \
                       const attr_lambda_type(attr::T##_type<I>) &lambda) \
      { \
        return tarjan::internal::attr_opening_<I, N, attr::T##_type<I> >(input, Ng, lambda); \
      }

# define xxx_closing_im_decl(T) \
      template<class I, class N> \
      oln_concrete_type(I) \
        T##_closing(const abstract::non_vectorial_image<I>& input, \
                       const abstract::neighborhood<N>& Ng, \
                       const attr_lambda_type(attr::T##_type<I>) &lambda) \
      { \
        return tarjan::internal::attr_closing_<I, N, attr::T##_type<I> >(input, Ng, lambda); \
      }

      xxx_closing_decl(card);

      xxx_opening_decl(card);

      xxx_closing_decl(integral);

      xxx_opening_decl(integral);

      xxx_opening_decl(height);

      xxx_closing_decl(height);


      xxx_closing_decl(maxvalue);

      xxx_opening_decl(maxvalue);

      xxx_opening_decl(minvalue);

      xxx_closing_decl(minvalue);

      xxx_opening_im_decl(ball);

      xxx_closing_im_decl(ball);

      xxx_opening_im_decl(dist);

      xxx_closing_im_decl(dist);

      xxx_closing_im_decl(cube);

      xxx_opening_im_decl(cube);

      xxx_closing_im_decl(box);

      xxx_opening_im_decl(box);

    } // !fast
  } // !morpho
} // !oln

#endif

---