https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud &lt;thierry.geraud(a)lrde.epita.fr&gt; Add routines to deal with images of accumulators. * mln/accu/image: New directory. * mln/accu/image/init.hh: New. * mln/accu/image/take.hh: New. * mln/accu/image/set_value.hh: New. * mln/accu/image/all.hh: New. * mln/accu/image/take_as_init.hh: New. * mln/accu/image/to_result.hh: New. * mln/accu/all.hh: Update. * tests/accu/image: New. * tests/accu/image/to_result.cc: New. * tests/accu/image/init.cc: New. * tests/accu/image/take.cc: New. * tests/accu/image/Makefile.am: New. * tests/accu/image/set_value.cc: New. * tests/accu/image/take_as_init.cc: New. * tests/accu/Makefile.am: Update. mln/accu/all.hh | 8 + mln/accu/image/all.hh | 56 +++++++++++ mln/accu/image/init.hh | 162 +++++++++++++++++++++++++++++++++ mln/accu/image/set_value.hh | 166 ++++++++++++++++++++++++++++++++++ mln/accu/image/take.hh | 186 +++++++++++++++++++++++++++++++++++++++ mln/accu/image/take_as_init.hh | 166 ++++++++++++++++++++++++++++++++++ mln/accu/image/to_result.hh | 178 +++++++++++++++++++++++++++++++++++++ tests/accu/Makefile.am | 3 tests/accu/image/Makefile.am | 18 +++ tests/accu/image/init.cc | 45 +++++++++ tests/accu/image/set_value.cc | 48 ++++++++++ tests/accu/image/take.cc | 58 ++++++++++++ tests/accu/image/take_as_init.cc | 48 ++++++++++ tests/accu/image/to_result.cc | 49 ++++++++++ 14 files changed, 1189 insertions(+), 2 deletions(-) Index: mln/accu/image/init.hh --- mln/accu/image/init.hh (revision 0) +++ mln/accu/image/init.hh (revision 0) @@ -0,0 +1,162 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_INIT_HH +# define MLN_ACCU_IMAGE_INIT_HH + +/// \file mln/accu/image/init.hh +/// +/// Initialize an image of accumulators. + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace accu + { + + namespace image + { + + template <typename I> + void + init(Image<I>& input); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Generic version. + + namespace generic + { + + template <typename I> + void + init(Image<I>& input_) + { + trace::entering("accu::impl::image::generic::init"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_piter(I) p(input.domain()); + for_all(p) + input(p).init(); + + trace::exiting("accu::impl::image::generic::init"); + } + + } // end of namespace mln::accu::image::impl::generic + + + // Fastest version. + + template <typename I> + void + init_fastest(Image<I>& input_) + { + trace::entering("accu::impl::image::init_fastest"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_pixter(I) px(input); + for_all(px) + px.val().init(); + + trace::exiting("accu::impl::image::init_fastest"); + } + + } // end of namespace mln::accu::image::impl + + + + // Dispatch. + + namespace internal + { + + template <typename I> + void + init_dispatch(trait::image::speed::any, + Image<I>& input) + { + impl::generic::init(input); + } + + template <typename I> + void + init_dispatch(trait::image::speed::fastest, + Image<I>& input) + { + impl::init_fastest(input); + } + + template <typename I> + void + init_dispatch(Image<I>& input) + { + init_dispatch(mln_trait_image_speed(I)(), + input); + } + + } // end of namespace mln::accu::image::internal + + + // Facade. + + template <typename I> + void + init(Image<I>& input) + { + trace::entering("accu::image::init"); + + mlc_is_a(mln_value(I), Accumulator)::check(); + + mln_precondition(exact(input).is_valid()); + internal::init_dispatch(input); + + trace::exiting("accu::image::init"); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu::image + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_IMAGE_INIT_HH Index: mln/accu/image/take.hh --- mln/accu/image/take.hh (revision 0) +++ mln/accu/image/take.hh (revision 0) @@ -0,0 +1,186 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_TAKE_HH +# define MLN_ACCU_IMAGE_TAKE_HH + +/// \file mln/accu/image/take.hh +/// +/// Update an image of accumulators by taking the contents of another +/// image. + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace accu + { + + namespace image + { + + template <typename I, typename J> + void + take(Image<I>& input, const Image<J>& arg); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Generic version. + + namespace generic + { + + template <typename I, typename J> + void + take(Image<I>& input_, const Image<J>& arg_) + { + trace::entering("accu::impl::image::generic::take"); + + I& input = exact(input_); + const J& arg = exact(arg_); + + mln_precondition(input.is_valid()); + mln_precondition(arg.is_valid()); + mln_precondition(arg.domain() <= input.domain()); + + mln_piter(J) p(arg.domain()); + for_all(p) + input(p).take(arg(p)); + + trace::exiting("accu::impl::image::generic::take"); + } + + } // end of namespace mln::accu::image::impl::generic + + + // Fastest version. + + template <typename I, typename J> + void + take_fastest(Image<I>& input_, const Image<J>& arg_) + { + trace::entering("accu::impl::image::take_fastest"); + + I& input = exact(input_); + const J& arg = exact(arg_); + + mln_precondition(input.is_valid()); + mln_precondition(arg.is_valid()); + mln_precondition(arg.domain() == input.domain()); + + mln_pixter(I) p_in(input); + mln_pixter(const J) p_arg(arg); + for_all_2(p_in, p_arg) + p_in.val().take( p_arg.val() ); + + trace::exiting("accu::impl::image::take_fastest"); + } + + } // end of namespace mln::accu::image::impl + + + + // Dispatch. + + namespace internal + { + + template <typename I, typename J> + void + take_dispatch(trait::image::speed::any, + trait::image::speed::any, + Image<I>& input, const Image<J>& arg) + { + impl::generic::take(input, arg); + } + + template <typename I, typename J> + void + take_dispatch(trait::image::speed::fastest, + trait::image::speed::fastest, + Image<I>& input, const Image<J>& arg) + { + if (exact(arg).domain() == exact(input).domain()) + impl::take_fastest(input, arg); + else + impl::generic::take(input, arg); + } + + template <typename I, typename J> + void + take_dispatch(Image<I>& input, const Image<J>& arg) + { + take_dispatch(mln_trait_image_speed(I)(), + mln_trait_image_speed(J)(), + input, arg); + } + + } // end of namespace mln::accu::image::internal + + + // Facade. + + template <typename I, typename J> + void + take(Image<I>& input_, const Image<J>& arg_) + { + trace::entering("accu::image::take"); + + mlc_is_a(mln_value(I), Accumulator)::check(); + mlc_converts_to(mln_value(J), + mln_deduce(I, value, argument))::check(); + + I& input = exact(input_); + const J& arg = exact(arg_); + + mln_precondition(input.is_valid()); + mln_precondition(arg.is_valid()); + mln_precondition(arg.domain() <= input.domain()); + + internal::take_dispatch(input, arg); + + trace::exiting("accu::image::take"); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu::image + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_IMAGE_TAKE_HH Index: mln/accu/image/set_value.hh --- mln/accu/image/set_value.hh (revision 0) +++ mln/accu/image/set_value.hh (revision 0) @@ -0,0 +1,166 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_SET_VALUE_HH +# define MLN_ACCU_IMAGE_SET_VALUE_HH + +/// \file mln/accu/image/set_value.hh +/// +/// Set the values of an image of accumulators. + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace accu + { + + namespace image + { + + template <typename I> + void + set_value(Image<I>& input, + const mln_deduce(I, value, result)& res); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Generic version. + + namespace generic + { + + template <typename I> + void + set_value(Image<I>& input_, + const mln_deduce(I, value, result)& res) + { + trace::entering("accu::impl::image::generic::set_value"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_piter(I) p(input.domain()); + for_all(p) + input(p).set_value(res); + + trace::exiting("accu::impl::image::generic::set_value"); + } + + } // end of namespace mln::accu::image::impl::generic + + + // Fastest version. + + template <typename I> + void + set_value_fastest(Image<I>& input_, + const mln_deduce(I, value, result)& res) + { + trace::entering("accu::impl::image::set_value_fastest"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_pixter(I) px(input); + for_all(px) + px.val().set_value(res); + + trace::exiting("accu::impl::image::set_value_fastest"); + } + + } // end of namespace mln::accu::image::impl + + + + // Dispatch. + + namespace internal + { + + template <typename I, typename V> + void + set_value_dispatch(trait::image::speed::any, + Image<I>& input, const V& res) + { + impl::generic::set_value(input, res); + } + + template <typename I, typename V> + void + set_value_dispatch(trait::image::speed::fastest, + Image<I>& input, const V& res) + { + impl::set_value_fastest(input, res); + } + + template <typename I, typename V> + void + set_value_dispatch(Image<I>& input, const V& res) + { + set_value_dispatch(mln_trait_image_speed(I)(), + input, res); + } + + } // end of namespace mln::accu::image::internal + + + // Facade. + + template <typename I> + void + set_value(Image<I>& input, + const mln_deduce(I, value, result)& res) + { + trace::entering("accu::image::set_value"); + + mlc_is_a(mln_value(I), Accumulator)::check(); + + mln_precondition(exact(input).is_valid()); + internal::set_value_dispatch(input, res); + + trace::exiting("accu::image::set_value"); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu::image + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_IMAGE_SET_VALUE_HH Index: mln/accu/image/all.hh --- mln/accu/image/all.hh (revision 0) +++ mln/accu/image/all.hh (revision 0) @@ -0,0 +1,56 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_ALL_HH +# define MLN_ACCU_IMAGE_ALL_HH + +/// \file mln/accu/image/all.hh +/// +/// File that includes all accumulator image routines. + + +namespace mln +{ + + /// Namespace of accumulators. + namespace accu + { + /// Namespace of accumulator image routines. + namespace image {} + + } +} + + +# include <mln/accu/image/init.hh> +# include <mln/accu/image/set_value.hh> +# include <mln/accu/image/take_as_init.hh> +# include <mln/accu/image/take.hh> +# include <mln/accu/image/to_result.hh> + + +#endif // ! MLN_ACCU_IMAGE_ALL_HH Index: mln/accu/image/take_as_init.hh --- mln/accu/image/take_as_init.hh (revision 0) +++ mln/accu/image/take_as_init.hh (revision 0) @@ -0,0 +1,166 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_TAKE_AS_INIT_HH +# define MLN_ACCU_IMAGE_TAKE_AS_INIT_HH + +/// \file mln/accu/image/take_as_init.hh +/// +/// Initialize an image of accumulators by taking a first value. + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace accu + { + + namespace image + { + + template <typename I> + void + take_as_init(Image<I>& input, + const mln_deduce(I, value, argument)& v); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Generic version. + + namespace generic + { + + template <typename I> + void + take_as_init(Image<I>& input_, + const mln_deduce(I, value, argument)& v) + { + trace::entering("accu::impl::image::generic::take_as_init"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_piter(I) p(input.domain()); + for_all(p) + input(p).take_as_init(v); + + trace::exiting("accu::impl::image::generic::take_as_init"); + } + + } // end of namespace mln::accu::image::impl::generic + + + // Fastest version. + + template <typename I> + void + take_as_init_fastest(Image<I>& input_, + const mln_deduce(I, value, argument)& v) + { + trace::entering("accu::impl::image::take_as_init_fastest"); + + I& input = exact(input_); + mln_precondition(input.is_valid()); + + mln_pixter(I) px(input); + for_all(px) + px.val().take_as_init(v); + + trace::exiting("accu::impl::image::take_as_init_fastest"); + } + + } // end of namespace mln::accu::image::impl + + + + // Dispatch. + + namespace internal + { + + template <typename I, typename V> + void + take_as_init_dispatch(trait::image::speed::any, + Image<I>& input, const V& v) + { + impl::generic::take_as_init(input, v); + } + + template <typename I, typename V> + void + take_as_init_dispatch(trait::image::speed::fastest, + Image<I>& input, const V& v) + { + impl::take_as_init_fastest(input, v); + } + + template <typename I, typename V> + void + take_as_init_dispatch(Image<I>& input, const V& v) + { + take_as_init_dispatch(mln_trait_image_speed(I)(), + input, v); + } + + } // end of namespace mln::accu::image::internal + + + // Facade. + + template <typename I> + void + take_as_init(Image<I>& input, + const mln_deduce(I, value, argument)& v) + { + trace::entering("accu::image::take_as_init"); + + mlc_is_a(mln_value(I), Accumulator)::check(); + + mln_precondition(exact(input).is_valid()); + internal::take_as_init_dispatch(input, v); + + trace::exiting("accu::image::take_as_init"); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu::image + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_IMAGE_TAKE_AS_INIT_HH Property changes on: mln/accu/image/take_as_init.hh ___________________________________________________________________ Added: svn:mergeinfo Index: mln/accu/image/to_result.hh --- mln/accu/image/to_result.hh (revision 0) +++ mln/accu/image/to_result.hh (revision 0) @@ -0,0 +1,178 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_ACCU_IMAGE_TO_RESULT_HH +# define MLN_ACCU_IMAGE_TO_RESULT_HH + +/// \file mln/accu/image/to_result.hh +/// +/// Convert an image of accumulators into a result image. + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace accu + { + + namespace image + { + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result(const Image<I>& input); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Generic version. + + namespace generic + { + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result(const Image<I>& input_) + { + trace::entering("accu::impl::image::generic::to_result"); + + const I& input = exact(input_); + mln_precondition(input.is_valid()); + + typedef mln_deduce(I, value, result) R; + mln_ch_value(I, R) output; + initialize(output, input); + + mln_piter(I) p(input.domain()); + for_all(p) + output(p) = input(p).to_result(); + + trace::exiting("accu::impl::image::generic::to_result"); + return output; + } + + } // end of namespace mln::accu::image::impl::generic + + + // Fastest version. + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result_fastest(const Image<I>& input_) + { + trace::entering("accu::impl::image::to_result_fastest"); + + const I& input = exact(input_); + mln_precondition(input.is_valid()); + + typedef mln_deduce(I, value, result) R; + typedef mln_ch_value(I, R) O; + O output; + initialize(output, input); + + mln_pixter(const I) p_in(input); + mln_pixter(O) p_out(output); + for_all_2(p_in, p_out) + p_out.val() = p_in.val().to_result(); + + trace::exiting("accu::impl::image::to_result_fastest"); + return output; + } + + } // end of namespace mln::accu::image::impl + + + + // Dispatch. + + namespace internal + { + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result_dispatch(trait::image::speed::any, + const Image<I>& input) + { + return impl::generic::to_result(input); + } + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result_dispatch(trait::image::speed::fastest, + const Image<I>& input) + { + return impl::to_result_fastest(input); + } + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result_dispatch(const Image<I>& input) + { + return to_result_dispatch(mln_trait_image_speed(I)(), + input); + } + + } // end of namespace mln::accu::image::internal + + + // Facade. + + template <typename I> + mln_ch_value(I, mln_deduce(I, value, result)) + to_result(const Image<I>& input) + { + trace::entering("accu::image::to_result"); + + mlc_is_a(mln_value(I), Accumulator)::check(); + + mln_precondition(exact(input).is_valid()); + + typedef mln_deduce(I, value, result) R; + mln_ch_value(I, R) output; + output = internal::to_result_dispatch(input); + + trace::exiting("accu::image::to_result"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu::image + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_IMAGE_TO_RESULT_HH Property changes on: mln/accu/image/to_result.hh ___________________________________________________________________ Added: svn:mergeinfo Index: mln/accu/all.hh --- mln/accu/all.hh (revision 3531) +++ mln/accu/all.hh (working copy) @@ -1,5 +1,5 @@ -// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory -// (LRDE) +// Copyright (C) 2007, 2008, 2009 EPITA Research and Development +// Laboratory (LRDE) // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -93,5 +93,9 @@ # include <mln/accu/transform_line.hh> # include <mln/accu/transform_snake.hh> +// Sub-directories + +# include <mln/accu/image/all.hh> + #endif // ! MLN_ACCU_ALL_HH Index: tests/accu/image/to_result.cc --- tests/accu/image/to_result.cc (revision 0) +++ tests/accu/image/to_result.cc (revision 0) @@ -0,0 +1,49 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/accu/image/to_result.cc +/// +/// Tests on mln::accu::image::to_result. + +#include <mln/core/image/image2d.hh> +#include <mln/accu/count.hh> +#include <mln/accu/image/init.hh> +#include <mln/accu/image/to_result.hh> +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + typedef accu::count<int> A; + image2d<A> ima(2, 2); + + accu::image::init(ima); + image2d<unsigned> res = accu::image::to_result(ima); + debug::println(res); +} Property changes on: tests/accu/image/to_result.cc ___________________________________________________________________ Added: svn:mergeinfo Index: tests/accu/image/init.cc --- tests/accu/image/init.cc (revision 0) +++ tests/accu/image/init.cc (revision 0) @@ -0,0 +1,45 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/accu/image/init.cc +/// +/// Tests on mln::accu::image::init. + +#include <mln/core/image/image2d.hh> +#include <mln/accu/count.hh> +#include <mln/accu/image/init.hh> + + +int main() +{ + using namespace mln; + + typedef accu::count<int> A; + image2d<A> ima(2, 2); + + accu::image::init(ima); +} Index: tests/accu/image/take.cc --- tests/accu/image/take.cc (revision 0) +++ tests/accu/image/take.cc (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/accu/image/take.cc +/// +/// Tests on mln::accu::image::take. + +#include <mln/core/image/image2d.hh> +#include <mln/data/fill.hh> +#include <mln/accu/sum.hh> +#include <mln/accu/image/init.hh> +#include <mln/accu/image/take.hh> + +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + typedef accu::sum<int> A; + image2d<A> ima(2, 2); + accu::image::init(ima); + debug::println(ima); + + image2d<int> dta(2, 2); + data::fill(dta, 7); + + accu::image::take(ima, dta); + debug::println(ima); + + accu::image::take(ima, ima); + debug::println(ima); +} Index: tests/accu/image/Makefile.am --- tests/accu/image/Makefile.am (revision 0) +++ tests/accu/image/Makefile.am (revision 0) @@ -0,0 +1,18 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include $(top_srcdir)/milena/tests/tests.mk + +check_PROGRAMS = \ + init \ + set_value \ + take \ + take_as_init \ + to_result + +init_SOURCES = init.cc +set_value_SOURCES = set_value.cc +take_SOURCES = take.cc +take_as_init_SOURCES = take_as_init.cc +to_result_SOURCES = to_result.cc + +TESTS = $(check_PROGRAMS) Index: tests/accu/image/set_value.cc --- tests/accu/image/set_value.cc (revision 0) +++ tests/accu/image/set_value.cc (revision 0) @@ -0,0 +1,48 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/accu/image/set_value.cc +/// +/// Tests on mln::accu::image::set_value. + +#include <mln/core/image/image2d.hh> +#include <mln/accu/count.hh> +#include <mln/accu/image/set_value.hh> + +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + typedef accu::count<int> A; + image2d<A> ima(2, 2); + + accu::image::set_value(ima, 3); + debug::println(ima); +} Index: tests/accu/image/take_as_init.cc --- tests/accu/image/take_as_init.cc (revision 0) +++ tests/accu/image/take_as_init.cc (revision 0) @@ -0,0 +1,48 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/accu/image/take_as_init.cc +/// +/// Tests on mln::accu::image::take_as_init. + +#include <mln/core/image/image2d.hh> +#include <mln/accu/sum.hh> +#include <mln/accu/image/take_as_init.hh> + +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + typedef accu::sum<int> A; + image2d<A> ima(2, 2); + + accu::image::take_as_init(ima, 3); + debug::println(ima); +} Property changes on: tests/accu/image/take_as_init.cc ___________________________________________________________________ Added: svn:mergeinfo Index: tests/accu/Makefile.am --- tests/accu/Makefile.am (revision 3531) +++ tests/accu/Makefile.am (working copy) @@ -2,6 +2,9 @@ include $(top_srcdir)/milena/tests/tests.mk +SUBDIRS = \ + image + check_PROGRAMS = \ all_accus \ bbox \