nagao.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 OLN_CONVOL_NAGAO_HH
# define OLN_CONVOL_NAGAO_HH

# include <oln/utils/se_stat.hh>
# include <oln/core/abstract/struct_elt.hh>
# include <oln/core/abstract/image.hh>
# include <oln/core/image.hh>
# include <oln/core/abstract/image_with_type_with_dim.hh>
# include <mlc/array/1d.hh>
# include <mlc/cmp.hh>


namespace oln {
  namespace convol{
    namespace internal {
      template <unsigned Size, class S>
      struct se_array
      {
        typedef mlc_exact_type(oln::abstract::struct_elt<S>) struct_elt_type;

        typedef typename mlc::array1d<typename mlc::array1d_info<Size>,
                                      struct_elt_type > array_type;

        enum {size = Size};

        se_array():delta_(0){}

        struct_elt_type&
        operator[](int i)
        {
          delta_ = -1;
          precondition(0 <= i < Size);
          return tab[i];
        }

        struct_elt_type
        operator[](int i) const
        {
          precondition(0 <= i < Size);
          return tab[i];
        }

        coord
        delta() const
        {
          // if not updated, compute the maximum.
          if (delta_ <= 0)
            {
              for (unsigned i = 0; i < Size; ++i)
                if (tab[i].delta() > delta_)
                  delta_ = tab[i].delta();
            }
          postcondition (delta_ >= 0);
          return delta_;
        }
      protected:
        array_type tab;
        mutable coord delta_;
      };

      template<class I, class SE, unsigned Size, typename Sum>
      inline Sum
      mean_of_smaller_variance(const oln::abstract::image<I> &im,
                               const oln_point_type(I) &p,
                               const internal::se_array<Size, SE> &w);
    } // end namespace internal

    template <class I, unsigned Size, typename SE, typename Sum>
    inline oln_concrete_type(I)
    nagao_generalized(const oln::abstract::image<I>& in,
                      const internal::se_array<Size, SE> &sa);

    template <class I>
    inline oln_concrete_type(I)
    nagao(const oln::abstract::non_vectorial_image_with_dim<2, I>& in);


    template <class I>
    inline oln_concrete_type(I)
    nagao(const oln::abstract::vectorial_image_with_dim<2, I>& in);
  } // end namespace convol

} // end namespace oln

#include "nagao.hxx"

#endif // OLENA_CONVOL_NAGAO_HH

---