Index: integre/ChangeLog from Niels Van Vliet &lt;niels(a)lrde.epita.fr&gt; * integre/ntg/core/macros.hh: Add macros ntg_if_vectorial_nb_comp and ntg_compare_nb_comp. * integre/tests/types/tests/ntg_compare_nb_comp: Add file. Index: olena/ChangeLog from Niels Van Vliet &lt;niels(a)lrde.epita.fr&gt; * olena/oln/math/macros.hh: Add dot_product. * olena/oln/utils/se_stat.hh: Add file. Mean and variance using a structuring element. * olena/oln/utils/se_stat.hxx: Add file. * olena/oln/convol/nagao.hh: Add file. Nagao filter. * olena/oln/convol/nagao.hxx: Add file. * olena/tests/convol/tests/nagao : Add file. Index: olena/oln/math/macros.hh --- olena/oln/math/macros.hh Mon, 15 Mar 2004 17:40:54 +0100 van-vl_n (oln/b/21_macros.hh 1.6.1.14 600) +++ olena/oln/math/macros.hh Fri, 26 Mar 2004 19:15:36 +0100 van-vl_n (oln/b/21_macros.hh 1.6.1.14 600) @@ -85,6 +85,68 @@ return f(val); } + /// Internal purpose only. + namespace internal { + /// Dot product for non-vectorial types. + template<typename DestValue, typename I, typename J> + struct f_dot_product_nv + { + typedef typename ntg_is_a(I, ntg::non_vectorial)::ensure_type t; + + static DestValue + product(const I &i, const J &j) + { + return i * j; + } + }; + + /// Dot product for vectorial types. + template<typename DestValue, typename I, typename J> + struct f_dot_product_v + { + typedef typename ntg_is_a(I, ntg::vectorial)::ensure_type t; + //typedef typename mlc::eq<ntg_nb_comp(I), ntg_nb_comp(J)>::ensure_type t; + + static DestValue + product(const I &i, const J &j) + { + DestValue d(ntg_zero_val(DestValue)); + + for (unsigned k = 0; k < ntg_nb_comp(I); ++k) + d += i[k] * j[k]; + return d; + } + }; + } + + /*! \brief Dot product. + ** + ** \code + ** #include <oln/math/macros.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** ntg::int_u8 i(3), j(4); + ** // Print "12" + ** std::cout << oln::math::dot_product<ntg::float_s>(i, j) << std::endl; + ** + ** ntg::rgb_8 blue(0, 0, 200), yellow(0, 30, 10); + ** // Print "2000" + ** std::cout << oln::math::dot_product<ntg::float_s>(blue, yellow) + ** << std::endl; + ** } + ** \endcode + */ + template<typename DestValue, typename I, typename J> + DestValue + dot_product(const I &i, const J &j) + { + typedef typename mlc::if_<ntg_is_a(I, ntg::vectorial)::ret, + internal::f_dot_product_v<DestValue, I, J>, + internal::f_dot_product_nv<DestValue, I, J> >::ret fctor; + return fctor::product(i, j); + } + } // end of math } // end of oln Index: integre/ntg/core/macros.hh --- integre/ntg/core/macros.hh Fri, 19 Mar 2004 15:52:57 +0100 palma_g (oln/s/19_macros.hh 1.10 600) +++ integre/ntg/core/macros.hh Fri, 26 Mar 2004 20:01:55 +0100 van-vl_n (oln/s/19_macros.hh 1.10 600) @@ -160,4 +160,49 @@ `-----*/ #define ntg_nbits(T) ntg::internal::typetraits<T>::size + +/*! Return the number of components of T if T is vectorial. +** +** If T is non vectorial, the value returned should not be considered. +*/ +#define ntg_if_vectorial_nb_comp(T) \ + ntg::type_traits<typename mlc::if_<ntg_is_a(T, ntg::vectorial)::ret, \ + T, \ + ntg::vec<42, bool> >::ret>::nb_comp + +/*! Same as \a ntg_if_vectorial_nb_comp but without 'typename' +** +** \see ntg_if_vectorial_nb_comp +*/ +#define ntg_if_vectorial_nb_comp_(T) \ + ntg::type_traits<mlc::if_<ntg_is_a_(T, ntg::vectorial)::ret, \ + T, \ + ntg::vec<42, bool> >::ret>::nb_comp + +/*! Compare the number of components. +** +** - If \a A and \a B are non_vectorial, then +** \a {ntg_compare_nb_comp(A, B)::ret = true} +** - If \a A and \a B are vectorial, then +** \a {ntg_compare_nb_comp(A, B)::ret = (ntg_nb_comp(A) = ntg_nb_comp(B))} +** - Otherwise, it returns false +*/ +#define ntg_compare_nb_comp(A, B) \ + mlc::if_< \ + ntg_is_a(A, ntg::non_vectorial)::ret, \ + ntg_is_a(B, ntg::non_vectorial), \ + mlc::eq<ntg_if_vectorial_nb_comp(A), \ + ntg_if_vectorial_nb_comp(B)> >::ret + +/*! Same as \a ntg_compare_nb_comp but without 'typename' +** +** \see ntg_compare_nb_comp +*/ +#define ntg_compare_nb_comp_(A, B) \ + mlc::if_< \ + ntg_is_a_(A, ntg::non_vectorial)::ret, \ + ntg_is_a_(B, ntg::non_vectorial), \ + mlc::eq<ntg_if_vectorial_nb_comp_(A), \ + ntg_if_vectorial_nb_comp_(B)> >::ret + #endif // !NTG_CORE_MACROS_HH Index: olena/tests/convol/tests/nagao --- olena/tests/convol/tests/nagao Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ olena/tests/convol/tests/nagao Fri, 26 Mar 2004 20:26:49 +0100 van-vl_n (oln/m/19_nagao 644) @@ -0,0 +1,37 @@ +// -*- c++ -*- +#include <oln/convol/nagao.hh> +#include <oln/basics2d.hh> +#include <ntg/all.hh> + +#include <oln/utils/md5.hh> +#include "data.hh" +#include "check.hh" +int main() +{ + bool fail (false); + oln::utils::key::value_type data_key_c[16] + = {0x69, 0xa7, 0xce, 0xf0, 0x4b, 0x88, 0x9e, 0xd4, 0x77, 0x63, 0x40, + 0xd6, 0x79, 0x42, 0x6a, 0x48}; + oln::image2d<ntg::rgb_8> imc = oln::load(rdata("lena.ppm")); + oln::image2d<ntg::rgb_8> nc = oln::convol::nagao(imc); + + std::cout << oln::utils::md5(nc) << std::endl; + fail = fail | (oln::utils::md5(nc) != oln::utils::key(data_key_c)); + + oln::utils::key::value_type data_key_g[16] + = {0x27, 0xbc, 0xab, 0x48, 0x45, 0x2f, 0xe9, 0xc5, 0x6e, 0x2e, 0x57, + 0x27, 0xf, 0x80, 0xfe, 0xaa}; + + oln::image2d<ntg::int_u8> im = oln::load(rdata("lena256.pgm")); + oln::image2d<ntg::int_u8> ng = oln::convol::nagao(im); + + fail = fail | (oln::utils::md5(ng) != oln::utils::key(data_key_g)); + if (!fail) + std::cout << "OK" << std::endl; + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} + Index: integre/tests/types/tests/ntg_compare_nb_comp --- integre/tests/types/tests/ntg_compare_nb_comp Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ integre/tests/types/tests/ntg_compare_nb_comp Fri, 26 Mar 2004 20:49:31 +0100 van-vl_n (oln/m/20_ntg_compar 644) @@ -0,0 +1,14 @@ +bool should_just_compile; +should_just_compile = ntg_if_vectorial_nb_comp_(int); + +bool fail = false; +fail = fail || ntg_if_vectorial_nb_comp_(ntg::rgb_8) != 3; +typedef ntg::vec<3, bool> vec3; +typedef ntg::vec<4, bool> vec4; +fail = fail || ntg_if_vectorial_nb_comp_(vec3) != 3; +fail = fail || ntg_if_vectorial_nb_comp_(vec4) != 4; +fail = fail || ntg_compare_nb_comp_(int, ntg::rgb_8)::ret != 0; +fail = fail || ntg_compare_nb_comp_(int, float)::ret != 1; +fail = fail || ntg_compare_nb_comp_(vec3, ntg::rgb_8)::ret != 1; +fail = fail || ntg_compare_nb_comp_(vec4, ntg::rgb_8)::ret != 0; +return fail; Index: olena/oln/convol/nagao.hxx --- olena/oln/convol/nagao.hxx Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ olena/oln/convol/nagao.hxx Fri, 26 Mar 2004 20:29:16 +0100 van-vl_n (oln/m/21_nagao.hxx 644) @@ -0,0 +1,205 @@ +// 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_HXX +# define OLN_CONVOL_NAGAO_HXX +# include <oln/core/window2d.hh> + +namespace oln { + namespace convol { + namespace internal { + + 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) + { + ntg_compare_nb_comp(Sum, oln_value_type(I))::ensure(); + + precondition(Size > 0); + precondition(im.border() >= w.delta()); + + typedef typename oln::utils::se_stat<Sum, ntg::float_s> se_stat_type; + typedef typename se_stat_type::sum_type sum_type; + typedef typename se_stat_type::variance_type variance_type; + + se_stat_type s(im, p, w[0]); + variance_type min_variance = s.variance(); + sum_type mean = s.mean(); + for (unsigned i = 1; i < Size; ++i) + { + variance_type tmp = s.compute(im, p, w[i]).variance(); + if (tmp < min_variance) + { + min_variance = tmp; + mean = s.mean(); + } + } + return mean; + } + + /*! \brief build 9 windows corresponding to the standard + ** 5x5 Nagao filter. + */ + static + se_array<9, window2d> + mk_nagao_windows_5x5() + { + se_array<9, window2d> out; + //center //..... + out[0].add(-1, -1).add(-1, 0).add(-1, 1)//.XXX. + .add(0, -1).add(0, 0).add(0, 1) //.XCX. + .add(1, -1).add(1, 0).add(1, 1); //.XXX. + //..... + + // upper //.XXX. + out[1].add(-2, -1).add(-2, 0).add(-2, 1)//.XXX. + .add(-1, -1).add(-1, 0).add(-1, 1) //..C.. + .add(0, 0); //..... + //..... + + // right //..... + out[2].add(-1, 1).add(-1, 2) //...XX + .add(0, 0).add(0, 1).add(0, 2) //..CXX + .add(1, 1).add(1, 2); //...XX + //..... + // bottom //..... + out[3].add(2, -1).add(2, 0).add(2, 1) //..... + .add(1, -1).add(1, 0).add(1, 1) //..C.. + .add(0, 0); //.XXX. + //.XXX. + + // left //..... + out[4].add(-1, -1).add(-1, -2) //XX... + .add(0, 0).add(0, -1).add(0, -2) //XXC.. + .add(1, -1).add(1, -2); //XX... + //..... + + // upper-left //XX... + out[5].add(-2, -2).add(-2, -1) //XXX.. + .add(-1, -2).add(-1, -1).add(-1, 0) //.XC.. + .add(0, -1).add(0, 0); //..... + //..... + + // upper-right //...XX + out[6].add(-2, 2).add(-2, 1) //..XXX + .add(-1, 2).add(-1, 1).add(-1, 0) //..CX. + .add(0, 1).add(0, 0); //..... + //..... + + // bottom-right //..... + out[7].add(2, 2).add(2, 1) //..... + .add(1, 2).add(1, 1).add(1, 0) //..CX. + .add(0, 1).add(0, 0); //..XXX + //...XX + + // bottom-left //..... + out[8].add(2, -2).add(2, -1) //..... + .add(1, -2).add(1, -1).add(1, 0) //.XC.. + .add(0, -1).add(0, 0); //XXX.. + //XX... + return out; + } + } // ! 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) + { + ntg_compare_nb_comp(Sum, oln_value_type(I))::ensure(); + in.border_adapt_width(sa.delta()); + oln_concrete_type(I) out(in.size()); + oln_iter_type(I) it(out); + for_all(it) + out[it] = internal::mean_of_smaller_variance<I, SE, Size, Sum> + (in, it, sa); + return out; + } + + /*! Standard Nagao filter 5x5. + ** + ** Apply the 5*5 nagao filter on a non vectorial image. + ** \code + ** #include <oln/convol/nagao.hh> + ** #include <oln/basics2d.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** oln::image2d<ntg::int_u8> imc = oln::load(IMG_IN "lena256.pgm"); + ** oln::save(oln::convol::nagao(imc), + ** IMG_OUT "oln_convol_nagao_256.pgm"); + ** } + ** \endcode + ** \image html lena256_pgm.png + ** \image latex lena256_pgm.png + ** => + ** \image html oln_convol_nagao_256.png + ** \image latex oln_convol_nagao_256.png + */ + template <class I> + inline oln_concrete_type(I) + nagao(const oln::abstract::non_vectorial_image_with_dim<2, I>& in) + { + return nagao_generalized<I, 9, window2d, ntg::float_s> + (in, internal::mk_nagao_windows_5x5()); + } + + /*! Standard Nagao filter 5x5. + ** + ** Apply the 5*5 nagao filter on a vectorial image. + ** + ** \code + ** #include <oln/convol/nagao.hh> + ** #include <oln/basics2d.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** oln::image2d<ntg::rgb_8> imc = oln::load(IMG_IN "lena.ppm"); + ** oln::save(oln::convol::nagao(imc), IMG_OUT "oln_convol_nagao.ppm"); + ** } + ** \endcode + ** \image html lena_ppm.png + ** \image latex lena_ppm.png + ** => + ** \image html oln_convol_nagao.png + ** \image latex oln_convol_nagao.png + */ + template <class I> + inline oln_concrete_type(I) + nagao(const oln::abstract::vectorial_image_with_dim<2, I>& in) + { + typedef ntg::rgb_8::float_vec_type float_vec_type; + return nagao_generalized<I, 9, window2d, float_vec_type> + (in, internal::mk_nagao_windows_5x5()); + } + } //! namespace convol +} //! namespace oln + +#endif Index: olena/oln/convol/nagao.hh --- olena/oln/convol/nagao.hh Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ olena/oln/convol/nagao.hh Fri, 26 Mar 2004 19:54:47 +0100 van-vl_n (oln/m/22_nagao.hh 644) @@ -0,0 +1,157 @@ +// 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 { + /*! array of structuring elements. + ** + ** \param Size Number of structuring elements. + ** \param S structuring element type. + */ + template <unsigned Size, class S> + struct se_array + { + /// Type of the struturing elements. + typedef mlc_exact_type(oln::abstract::struct_elt<S>) struct_elt_type; + + /// Type of the array. + typedef typename mlc::array1d<typename mlc::array1d_info<Size>, + struct_elt_type > array_type; + + /// Number of structuring elements. + enum {size = Size}; + + se_array():delta_(0){} + + /// nth struturing element. + struct_elt_type& + operator[](int i) + { + delta_ = -1; + precondition(0 <= i < Size); + return tab[i]; + } + + /// nth struturing element. + struct_elt_type + operator[](int i) const + { + precondition(0 <= i < Size); + return tab[i]; + } + + /// Maximum of the delta of the structuring elements. + 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 of structuring elements. + array_type tab; + /*! \brief Maximum delta. + ** + ** \note delta_ < 0 means that it must be updated before + ** a read access. + */ + mutable coord delta_; + }; + + /*! Return the mean of the windows that has the smallest variance. + ** + ** \arg im Input image. + ** \arg p Origin of the structuring elements. + ** \arg w array of structuring elements. + ** + ** \param I Input image type. + ** \param SE Structuring element type. + ** \param Size Number of windows in the array. + ** \param Sum Type use to add values of the input image. + ** + ** \note \a Sum might be a float_s if the image is an image + ** of integer, and might be an rgb_8::float_vec_type if I is + ** an image of rgb_8. + */ + 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 + + /*! A Nagao filter generalized. + ** + ** Each point in the input correspond to the mean of the + ** window in which has the smallest variance. + ** + ** \paran in Input image. + ** \param sa array of structuring elements. + ** + ** \see oln::convol::nagao + */ + 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 Index: olena/oln/utils/se_stat.hh --- olena/oln/utils/se_stat.hh Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ olena/oln/utils/se_stat.hh Fri, 26 Mar 2004 19:33:56 +0100 van-vl_n (oln/m/23_se_stat.hh 644) @@ -0,0 +1,172 @@ +// 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_UTILS_SE_STAT_HH +# define OLN_UTILS_SE_STAT_HH + +# include <oln/core/abstract/point.hh> +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/struct_elt.hh> + +# include <ntg/core/abstract_hierarchy.hh> +# include <ntg/all.hh> +# include <ntg/core/macros.hh> +# include <oln/math/macros.hh> + +namespace oln { + namespace utils { + namespace internal { + /*! This class is used to transform a type to a floating type equivalent. + ** + ** \todo FIXME: There should be a way to use the standard conversion, + ** but I failed to find a good one. The problem is that a color<...> + ** derived of vec<..> but the conversion between color and vec should be + ** done through c.to_float(). \n + ** Example: + ** \verbatim + ** rgb_u8::float_vec_type v = rgb_u8(127, 0, 255); + ** // v contains 127., 0., 255 but should contain 0.5, 0,1. + ** rgb_u8 c = v; + ** // c = (255., 255., 255). Error. + ** + ** rgb_u8::float_vec_type v2 = f_to_float_<rgb_u8::float_vec_type> + ** rgb_u8(127, 0, 255); + ** rgb_u8 c2 = v2; + ** // c2 = (127, 0, 255). Ok. + ** \endverbatim + */ + template <typename DestT, + typename SrcT> + struct f_to_float_ + { + static + DestT + doit(const SrcT& s) + { + return s; + } + }; + + /// Specialization of the \a f_to_float struct for the colors. + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct f_to_float_<typename ntg::color<ncomps, + qbits, + color_system>::float_vec_type, + ntg::color<ncomps, qbits, color_system> > + { + static + typename ntg::color<ncomps, qbits, color_system>::float_vec_type + doit(const ntg::color<ncomps, qbits, color_system>& s) + { + return s.to_float(); + } + }; + } // end namespace internal + + + /*! \brief Compute the variance and the mean within a window. + ** + ** \param Sum type used to compute the sum and the average. + ** \param Var type used to compute the variance. + ** + ** \note There is two parameters because for vectorial types the sum + ** is usually a vector, and the variance a non vectorial type. + */ + template <typename Sum = ntg::float_s, typename Var = ntg::float_s> + class se_stat + { + public: + /// type of used to sum the value (usually floating point values) + typedef Sum sum_type; + /// type of used for the variance (usually floating point values) + typedef Var variance_type; + + /*! Build a se stat. + ** \arg im Input image. + ** \arg p Origin of the structuring element. + ** \arg s Window. + */ + template <class I, class S> + se_stat(const oln::abstract::image<I> &im, + const oln_point_type(I) &p, + const oln::abstract::struct_elt<S> &s) + { + compute(im, p, s); + } + + /// Computes the mean and the variance. + template <class I, class S> + se_stat & + compute(const oln::abstract::image<I> &im, + const oln_point_type(I) &p, + const oln::abstract::struct_elt<S> &s); + + /// Mean. + inline Sum + mean() const + { + return mean_; + } + + /// Variance. + inline Var + variance() const + { + return variance_; + } + + /// Sum. + inline Sum + sum() const + { + return sum_; + } + + /// Cardinal of the structuring element. + inline unsigned + card() const + { + return card_; + } + + protected: + Var variance_; ///< Variance. + Sum mean_; ///< Mean. + Sum sum_; ///< Sum. + int card_; ///< Card of the input structuring element. + }; + + } // end namespace utils + +} // end namespace oln + +#include "se_stat.hxx" + +#endif //! OLN_UTILS_SE_STAT_HH Index: olena/oln/utils/se_stat.hxx --- olena/oln/utils/se_stat.hxx Fri, 26 Mar 2004 20:54:04 +0100 van-vl_n () +++ olena/oln/utils/se_stat.hxx Fri, 26 Mar 2004 19:59:59 +0100 van-vl_n (oln/m/24_se_stat.hx 644) @@ -0,0 +1,70 @@ +// 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_UTILS_SE_STAT_HXX +# define OLN_UTILS_SE_STAT_HXX + +namespace oln { + namespace utils { + + /// Computes the mean and the variance. + template <typename Sum, typename Var> + template <class I, class S> + inline se_stat<Sum, Var> & + se_stat<Sum, Var>::compute(const oln::abstract::image<I> &im, + const oln_point_type(I) &p, + const oln::abstract::struct_elt<S> &s) + { + sum_ = ntg_zero_val(Sum); + card_ = s.card(); + // Compute the mean + oln_iter_type(S) it(s); + { + for_all(it) + sum_ += internal::f_to_float_<Sum, + oln_value_type(I)>::doit(im[p + it]); + mean_ = sum_ / card_; + } + // Compute the variance + { + Var sum_2(ntg_zero_val(Var)); + for_all(it) + { + Sum tmp = mean_; + tmp -= im[p + it]; + sum_2 += oln::math::dot_product<Var>(tmp, tmp); + } + variance_ = sum_2 / card_; + } + return *this; + } + } // end namespace utils + +} // end namespace oln + +#endif //! OLN_UTILS_SE_STAT_HXX