February 2006 - Olena-patches

399: Add some documentation and types to Metalic.
by Roland Levillain 14 Feb '06

14 Feb '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add some documentation and types to Metalic. * mlc/cmp.hh: More documentation. (is_found, is_not_found, is_ok): New. * mlc/implies.hh, mlc/is_a.hh: Fix Doxygen comment. * mlc/flags.hh: More documentation. (dummy, locked): New. From Thierry G�raud. * mlc/value.hh: Remove dead code. cmp.hh | 35 ++++++++++++-- flags.hh | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++---------- implies.hh | 4 - is_a.hh | 4 - value.hh | 19 ------- 5 files changed, 162 insertions(+), 49 deletions(-) Index: mlc/implies.hh --- mlc/implies.hh (revision 398) +++ mlc/implies.hh (working copy) @@ -31,9 +31,9 @@ # include <mlc/bool.hh> -/*! \macro mlc_implies(Left_BExpr, Right_BExpr) +/*! \def mlc_implies(Left_BExpr, Right_BExpr) ** -** Macro correponding to mlc::implies_<L, R>, for use in a template +** Macro corresponding to mlc::implies_<L, R>, for use in a template ** context. ** ** \see mlc::implies_<L, R> Index: mlc/is_a.hh --- mlc/is_a.hh (revision 398) +++ mlc/is_a.hh (working copy) @@ -205,7 +205,7 @@ -/*! \macro mlc_is_a(T, U) +/*! \def mlc_is_a(T, U) ** ** Macro that answers if T is an U. T should be a type and U can have ** different forms: class, template class, etc. The result is a @@ -240,7 +240,7 @@ mlc::wrap_<typename mlc::internal::is_a<sizeof(mlc::form::of())>::ret<T,U > > -/*! \macro mlc_is_a_(T, U) +/*! \def mlc_is_a_(T, U) ** ** Macro equivalent as mlc_is_a(T, U) for use in a non templated ** context. The result is a Boolean expression type. Index: mlc/flags.hh --- mlc/flags.hh (revision 398) +++ mlc/flags.hh (working copy) @@ -38,9 +38,15 @@ /*! \class mlc::abstract::flag ** - ** Abstract base class for types that are only flags. + ** Abstract base class for types that are flags. A flag type + ** expresses a particular property translated by the name of the + ** type. For instance, mlc::undefined is a flag type which + ** means "declared but not defined". ** - ** Example: mlc::undefined is a mlc::abstract::flag. + ** Flag types have no interface; they only serve as types. + ** + ** The flags provided in mlc are: dummy, locked, none, not_found, + ** undefined, and unknown. */ struct flag : public type {}; @@ -48,37 +54,91 @@ } // end of namespace mlc::abstract - /*! \class mlc::undefined + /*! \class mlc::dummy ** - ** Flag class to state that a type is undefined, that is, declared - ** but not defined. + ** Flag class to value a type when one knows that this value does + ** not matter and will not be used. ** - ** Sample use: you want to define a trait to get the signed version - ** of a type T. For that, you write: + ** The dummy type appears typically in some part of meta-program + ** that are ignored. In mlc_typedef_onlyif, for instance, dummy is + ** returned when the guard value is false. When defining a + ** pattern matching meta-program, if a clause is not a match, the + ** returned type for this clause is evaluated into dummy. + */ + struct dummy : public abstract::flag {}; + + + /*! \class mlc::locked + ** + ** Flag class whose purpose is to state and ensure that a type + ** should not be re-defined (or specialized) by the client. + ** + ** Let us consider a type that should not be re-defined or + ** specialized by the client. Such a type is defined having + ** mlc::locked as base class. Inserting the static check + ** mlc_is_a(type, locked) then ensures that this type is untouched. + ** + ** Sample use: First a type (set_foo) is declared for the user to + ** specialize it: + ** + ** template <typename T> struct set_foo; + ** + ** and the access to this specialization (handled by the type + ** get_foo), for use in a meta-program, is written once for all. + ** The access code should not be re-defined by the client so it is + ** tagged as locked: ** ** template <typename T> - ** struct signed_type_of - ** { - ** typedef mlc::undefined ret; + ** struct get_foo : public mlc::locked, + ** public set_foo<T> { + ** using set_foo<T>::ret; ** }; ** - ** which means that the return type (ret) is not defined by default. - ** Put differently, this trait is just declared. So far, the - ** type "signed_type_of<unsigned short>::ret" is "mlc::undefined". - ** - ** Other flags are mlc::unknown, mlc::none, and mlc::not_found. + ** The meta-program that reads the value of get_foo<T>::ret also + ** checks that get_foo<T> derives from mlc::locked. That thus + ** ensures that the client has not confuse set_foo with get_foo. */ - struct undefined : public abstract::flag {}; + struct locked : public abstract::flag {}; - struct unknown : public abstract::flag {}; + /*! \class mlc::none + ** + ** Flag class to state that there is no type corresponding to a + ** request. + ** + ** Sample use 1: In the context of a variadic parameter list, none + ** is the default value for every parameter after the first one. + ** + ** With: + ** template <typename P1, + ** typename P2 = none, + ** typename P3 = none> + ** struct foo { + ** typedef P1 param1; + ** typedef P2 param2; + ** typedef P3 param3; + ** }; + ** + ** instantiated into foo<int, float>, we thus have param3 set to + ** none. + ** + ** Sample use 2: The type none can be used as a trait value. For + ** instance: + ** + ** template<> + ** struct super_type_of <int> { + ** typedef none ret; + ** }; + */ struct none : public abstract::flag {}; /*! \class mlc::not_found ** - ** Flag class to state that a type is not found (for use in the - ** context of trying to retrieve a type). + ** Flag class to state that a type is not found. This class is for + ** use in the context of trying to retrieve a type. More precisely, + ** this flag type should only appear as a return of a piece of + ** meta-program. ** ** Design issue: this flag is used in some meta-code to handle the ** case of an "absent" typedef. For instance it is used in the @@ -86,14 +146,59 @@ ** mlc_typedef(std::vector<int>, value_type) is int, whereas ** mlc_typedef(std::vector<int>, walue_type) is mlc::not_found. ** - ** Other flags are mlc::undefined, mlc::unknown, and mlc::none. - ** ** \see mlc_typedef */ struct not_found : public abstract::flag {}; - // FIXME: add corresponding is_* types + /*! \class mlc::undefined + ** + ** Flag class to state that a type is undefined, that is, declared + ** but not defined. + ** + ** Sample use: When you want to define a trait to get the signed + ** version of a type T, you write: + ** + ** template <typename T> + ** struct signed_type_of + ** { + ** typedef mlc::undefined ret; + ** }; + ** + ** meaning that the return type (ret) is not defined by default. + ** Put differently, this trait is just declared. So far, the trait + ** value signed_type_of<unsigned short>::ret is mlc::undefined. If + ** it happens that this trait value is not specialized in some + ** following code, this value thus remains mlc::undefined, which + ** clearly denotes an error. + ** + ** \see mlc::abstract::flag. + */ + struct undefined : public abstract::flag {}; + + + /*! \class mlc::unknown + ** + ** Flag class to state that a result is yet unknown. + ** + ** Sample use: This flag can be used in a meta-program to express + ** that a sub-program fails to give the expected result. For + ** instance in: + ** + ** template <class T> + ** struct foo { + ** typedef sub_program_1 ret1; + ** typedef sub_program_2 ret2; + ** typedef typename if_< neq_<ret1, unknown>, + ** ret1, + ** ret2 >::ret ret; + ** }; + */ + struct unknown : public abstract::flag {}; + + + // FIXME: Doc. + struct not_ok : public abstract::flag {}; } // end of namespace mlc Index: mlc/value.hh --- mlc/value.hh (revision 398) +++ mlc/value.hh (working copy) @@ -164,23 +164,4 @@ # include <mlc/bool.hh> -// FIXME: the following code causes inclusion recursion... - -// # include <mlc/is_a.hh> - -// namespace mlc { - -// template <typename T> -// struct is_value : public mlc_is_a(T, mlc::abstract::value) -// { -// }; - -// template <typename T> -// struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> -// { -// }; - -// } // end of namespace mlc - - #endif // ! METALIC_VALUE_HH Index: mlc/cmp.hh --- mlc/cmp.hh (revision 398) +++ mlc/cmp.hh (working copy) @@ -39,13 +39,14 @@ namespace mlc { - // FIXME: code moved from the end of value.hh + /// Check whether \a T is a mlc::abstract::value. template <typename T> struct is_value : public mlc_is_a(T, mlc::abstract::value) { }; + /// Check whether \a T is not a mlc::abstract::value. template <typename T> struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> { @@ -54,7 +55,7 @@ /// Equality test between a couple of types. - + /// \{ template <typename T1, typename T2> struct eq_ : private ensure_list_< is_not_value<T1>, is_not_value<T2> >, @@ -67,10 +68,10 @@ public true_ { }; - + /// \} /// Inequality test between a couple of types. - + /// \{ template <typename T1, typename T2> struct neq_ : private ensure_list_< is_not_value<T1>, is_not_value<T2> >, @@ -83,7 +84,33 @@ public false_ { }; + /// \} + + + /*--------------------------------------. + | Syntactic sugar for flag comparison. | + `--------------------------------------*/ + + /// Shortcuts for comparison with mlc::not_found. + /// \{ + template <typename T> + struct is_found : public neq_<T, not_found> + { + }; + + template <typename T> + struct is_not_found : public neq_<T, not_found> + { + }; + /// \} + + /// Check whether a type is a sound (supposedly before using it). + struct is_ok : public ands_< neq_<T, not_found>, + neq_<T, not_ok>, + neq_<T, undefined > > + { + }; } // end of namespace mlc

1 0

proto-1.0 398: Update Anisotropic diffusion for a generic use.
by Nicolas Widynski 13 Feb '06

13 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Update Anisotropic diffusion for a generic use. * oln/level/anisotropic_diffusion.hh: Update. * oln/makefile.src: Update. level/anisotropic_diffusion.hh | 90 ++++++++++++++++++++++++++--------------- makefile.src | 5 +- 2 files changed, 62 insertions(+), 33 deletions(-) Index: oln/level/anisotropic_diffusion.hh --- oln/level/anisotropic_diffusion.hh (revision 397) +++ oln/level/anisotropic_diffusion.hh (working copy) @@ -31,6 +31,7 @@ # include <oln/basics.hh> # include <oln/utils/clone.hh> # include <oln/morpho/gradient_morpho.hh> +# include <oln/utils/clean_boundaries.hh> # define SQR(u) u*u # define ABS(u) u >= 0 ? u : -u @@ -41,59 +42,82 @@ namespace impl { - template <typename I> - oln_ch_concrete_type(I, std::vector<double>) - gradient_on_each_side_(const abstract::image& input) + // version 2d of the 4nbhs gradient + template <typename T> + image2d<std::vector<double> > + gradient_on_each_side_(const image2d<T>& input) { - oln_ch_concrete_type(I, std::vector<double>) g(input.size(), "gradient"); - oln_type_of(I, fwd_piter) p(input.size()); - oln_type_of(I, point) pt; + image2d<std::vector<double> > g(input.size(), "gradient"); + fwd_piter2d p(input.size()); + point2d pt; for_all_p(p) { pt = p; // N - g.at(p).push_back((double)input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() - - input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value()); + g.at(p).push_back((input(pt.row() - 1, pt.col()) - input[p]) / 2); // S - g.at(p).push_back((double)input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - - input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value()); + g.at(p).push_back((input(pt.row() + 1, pt.col()) - input[p]) / 2); // E - g.at(p).push_back((double)input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - - input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value()); + g.at(p).push_back((input(pt.row(), pt.col() + 1) - input[p]) / 2); // W - g.at(p).push_back((double)input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() - - input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value()); + g.at(p).push_back((input(pt.row(), pt.col() - 1) - input[p]) / 2); } return g; } - template <typename T> - void clean_ima(image2d<T>& ima) + template <typename I> + double compute_capa(const abstract::image& input) { - for (int j = 0; j < ima.size().ncols(); j++) + // static version of cappa (near the variance) + return 6; + + + // 4 nbhs version of gradient + + /* + double K = 0; + double seuil = 0; + + oln_type_of(I, concrete) grad(input.size()); + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt; + + for_all_p(p) { - ima(-1, j) = ima(0, j); - ima(ima.size().nrows(), j) = ima(ima.size().nrows() - 1, j); + pt = p; + + grad[p] = (double) ((ABS((double) (input[oln_type_of(I, point)(pt.row() - 1, pt.col())].value()))) + + (ABS((double) (input[oln_type_of(I, point)(pt.row() + 1, pt.col())].value()))) + + (ABS((double) (input[oln_type_of(I, point)(pt.row(), pt.col() + 1)].value()))) + + (ABS((double) (input[oln_type_of(I, point)(pt.row(), pt.col() - 1)].value()))) + + (ABS((double) (- 4 * input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value())))) / 8; + + seuil = grad[p] > seuil ? grad[p] : seuil; } - for (int j = 0; j < ima.size().nrows(); j++) + seuil *= 0.9; + + for_all_p(p) { - ima(j, -1) = ima(j, 0); - ima(j, ima.size().ncols()) = ima(j, ima.size().ncols() - 1); - } + // if (grad[p] < (int)seuil) + if (grad[p] > (int)seuil) + K++; } + std::cout << K << std::endl; + return K; + */ - template <typename I> - double compute_capa(const abstract::image& input) - { + // morphologic version of gradient + + /* double K = 0; double seuil = 0.9 * 255; @@ -103,9 +127,11 @@ for_all_p(p) { if (grad[p] < (int)seuil) + // if (grad[p] > (int)seuil) K++; } return K; + */ } @@ -114,6 +140,7 @@ return 1 / (1 + SQR(grad / K)); } + // generic function of the anisotropic diffusion template <typename I> oln_type_of(I, concrete) anisotropic_diffusion_(const abstract::image& input, unsigned nb_it) @@ -134,8 +161,8 @@ while (conv == false) { - clean_ima(a_d.exact()); - grad = gradient_on_each_side_(a_d); + utils::clean_boundaries(a_d.exact()); + grad = gradient_on_each_side_(a_d.exact()); K = compute_capa(a_d); change = false; error = 0; @@ -162,7 +189,7 @@ std::cout << "error " << error << std::endl; - if (it >= nb_it or error < 0.1 or change == false) + if ((it >= nb_it and nb_it != 0) or error < 0.1 or change == false) conv = true; it++; @@ -171,14 +198,13 @@ return a_d; } - - } // end of namespace oln::level::impl + // nb_it = 0 signifies until algorithm convergence. template <typename I> oln_type_of(I, concrete) - anisotropic_diffusion(const abstract::image& input, unsigned nb_it) + anisotropic_diffusion(const abstract::image& input, unsigned nb_it = 0) { return impl::anisotropic_diffusion_(input.exact(), nb_it); } Index: oln/makefile.src --- oln/makefile.src (revision 397) +++ oln/makefile.src (working copy) @@ -12,6 +12,8 @@ \ appli/denoising/nl_means.hh \ \ + appli/inpainting/image_inpainting.hh \ + \ basics1d.hh \ basics2d.hh \ basics3d.hh \ @@ -170,6 +172,7 @@ io/vectorial.hh \ io/write_image.hh \ \ + level/anisotropic_diffusion.hh \ level/arith.hh \ level/compare.hh \ level/extrema_components.hh \ @@ -177,7 +180,6 @@ level/invert.hh \ level/level_components.hh \ level/logic.hh \ - level/anisotropic_diffusion.hh \ \ morpho/closing.hh \ morpho/dilation.hh \ @@ -209,6 +211,7 @@ \ utils/buffer.hh \ utils/clone.hh \ + utils/clean_boundaries.hh \ utils/invert.hh \ utils/key.hh \ utils/md5.hh \

1 0

proto-1.0 397: Util function : set outsides boundaries at the same value of image boundaries.
by Nicolas Widynski 13 Feb '06

13 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Util function : set outsides boundaries at the same value of image boundaries. * oln/utils/clean_boundaries.hh: New. To clean image boundaries. clean_boundaries.hh | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) Index: oln/utils/clean_boundaries.hh --- oln/utils/clean_boundaries.hh (revision 0) +++ oln/utils/clean_boundaries.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 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_CLEAN_BOUNDARIES_HH +# define OLN_UTILS_CLEAN_BOUNDARIES_HH + +# include <oln/core/abstract/image.hh> +# include <oln/core/1d/image1d.hh> +# include <oln/core/2d/image2d.hh> + +namespace oln { + + namespace utils { + + namespace impl { + + template <typename T> + void clean_boundaries_(image1d<T>& ima) + { + ima(-1) = ima(0); + ima(ima.size().nindices()) = ima(ima.size().nindices() - 1); + } + + template <typename T> + void clean_boundaries_(image2d<T>& ima) + { + for (int j = 0; j < ima.size().ncols(); j++) + { + ima(-1, j) = ima(0, j); + ima(ima.size().nrows(), j) = ima(ima.size().nrows() - 1, j); + } + for (int j = 0; j < ima.size().nrows(); j++) + { + ima(j, -1) = ima(j, 0); + ima(j, ima.size().ncols()) = ima(j, ima.size().ncols() - 1); + } + } + + + } // end of namespace oln::utils::impl + + + // set outsides boundaries of the image at the boundary value. + template <typename I> + void clean_boundaries(abstract::image& input) + { + if (input.size().border() != 0) + impl::clean_boundaries_(input.exact()); + } + + } // end of namespace oln::utils + +} // end of namespace oln + +#endif // ! OLN_UTILS_CLEAN_BOUNDARIES_HH

1 0

proto-1.0 396: Add Image Inpainting algorithm.
by Nicolas Widynski 10 Feb '06

10 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Add Image Inpainting algorithm. * oln/appli/inpainting/image_inpainting.hh: New. Based on Bertalmio algorithm. image_inpainting.hh | 330 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 330 insertions(+) Index: oln/appli/inpainting/image_inpainting.hh --- oln/appli/inpainting/image_inpainting.hh (revision 0) +++ oln/appli/inpainting/image_inpainting.hh (revision 0) @@ -0,0 +1,330 @@ +// Copyright (C) 2001-2006 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_IMAGE_INPAINTING_HH +# define OLENA_IMAGE_INPAINTING_HH + +# include <mlc/is_a.hh> +# include <oln/basics.hh> +# include <oln/basics2d.hh> +# include <ntg/all.hh> +# include <oln/convolution/laplacian.hh> +# include <oln/utils/clone.hh> +# include <oln/morpho/gradient_morpho.hh> +# include <oln/level/anisotropic_diffusion.hh> +# include <vector> + +# define get_data(STR, ITER, ATTR) STR[ITER].call(ATTR) +# define get_data2(STR, X, Y, ATTR) STR(X,Y).call(ATTR) +# define set_data(STR, ITER, ATTR, VAL) STR[ITER].call(ATTR, VAL) +# define SQUARE(u) u*u + +namespace oln { + + namespace inpainting { + + + // Fwd decl of the image inpainting computation + + template <typename I> + oln_type_of(I, concrete) + image_inpainting(const abstract::image& input); + + + namespace impl { + + + template <typename I, typename II> + oln_ch_concrete_type(I, std::vector<double>) + vect_laplacian_(const abstract::image& lpl, + const abstract::image<II>& mb) + { + oln_ch_concrete_type(I, std::vector<double>) v_lpl(lpl.size(), "laplacian_vector"); + oln_type_of(I, fwd_piter) p(lpl.size()); + oln_type_of(I, point) pt; + + for_all_p(p) + { + if (mb[p] == false) + { + pt = p; + set_data(v_lpl, p, &std::vector<double>::push_back, + (lpl[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - + lpl[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value()) / 2); + + set_data(v_lpl, p, &std::vector<double>::push_back, + (lpl[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - + lpl[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value()) / 2); + } + } + return v_lpl; + } + + + template <typename I, typename II> + oln_ch_concrete_type(I, std::vector<double>) + compute_direction_(const abstract::image& input, + const abstract::image<II>& mb) + { + oln_ch_concrete_type(I, std::vector<double>) n(input.size(), "direction_vector"); + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt; + double Iyn, Ixn; + + for_all_p(p) + { + if (mb[p] == false) + { + pt = p; + + Iyn = (-input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() + + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value()) / 2; + + Ixn = (input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - + input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value()) / 2; + + set_data(n, p, &std::vector<double>::push_back, Iyn); + set_data(n, p, &std::vector<double>::push_back, Ixn); + } + } + return n; + } + + // do the inner product between lpl and n + template <typename I, typename II, typename III> + oln_ch_concrete_type(I, double) + compute_b_(const abstract::image& v_lpl, + const abstract::image<II>& n, + const abstract::image<III>& mb) + { + oln_ch_concrete_type(I, double) b(v_lpl.size(), "beta"); + oln_type_of(I, fwd_piter) p(v_lpl.size()); + + for_all_p(p) + { + if (mb[p] == false) + b[p] = (double) get_data(n, p, &std::vector<double>::front) * get_data(v_lpl, p, &std::vector<double>::front) + + get_data(n, p, &std::vector<double>::back) * get_data(v_lpl, p, &std::vector<double>::back); + } + return b; + } + + double min(double a, double b) + { + return a b ? a : b; + } + + template <typename I, typename II> + oln_type_of(I, concrete) + compute_grad_(const abstract::image& input, + const abstract::image& b, + const abstract::image<II>& mb) + { + oln_type_of(I, concrete) g(input.size(), "gradient"); + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt; + + for_all_p(p) + { + if (mb[p] == false) + { + pt = p; + g[p] = 0; + + if (b[p] > 0) + { + + g[p] = (sqrt(SQUARE(min(input[p].value() - + input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value(), 0)) + + + SQUARE(max(input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - + input[p].value(), 0)) + + + SQUARE(min(input[p].value() - + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value(), 0)) + + + SQUARE(max(input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - + input[p].value(), 0))) / 2); + + if (g[p] > 10) + g[p] = 10; + } + + if (b[p] < 0) + { + g[p] = (sqrt(SQUARE(max(input[p].value() - + input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value(), 0)) + + + SQUARE(min(input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - + input[p].value(), 0)) + + + SQUARE(max(input[p].value() - + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value(), 0)) + + + SQUARE(min(input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - + input[p].value(), 0))) / 2); + + if (g[p] > 10) + g[p] = 10; + + } + } + } + return g; + } + + template <typename T> + std::ostream& operator<<(std::ostream& ostr, const image2d<std::vector<T> >& ima) + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + { + ostr << "(" << ima(i,j).value()[0] << "," << ima(i,j).value()[1] << ") " << "\t"; + if ((ima(i,j).value()[0] == 0 or ima(i,j).value()[0] == 1) and + (ima(i,j).value()[1] == 0 or ima(i,j).value()[1] == 1)) + ostr << "\t"; + } + + ostr << std::endl; + } + return ostr; + } + + + template <typename T> + std::ostream& operator<<(std::ostream& ostr, const image2d<T>& ima) + { + for (int i = 0; i < 9; i++) + { + for (int j = 0; j < 9; j++) + ostr << ima(i,j).value() << "\t"; + ostr << std::endl; + } + return ostr; + } + + + template <typename T> + void clean_ima(image2d<T>& ima) + { + for (int j = 0; j < ima.size().ncols(); j++) + { + ima(-1, j) = ima(0, j); + ima(ima.size().nrows(), j) = ima(ima.size().nrows() - 1, j); + } + + for (int j = 0; j < ima.size().nrows(); j++) + { + ima(j, -1) = ima(j, 0); + ima(j, ima.size().ncols()) = ima(j, ima.size().ncols() - 1); + } + } + + + template <typename I, typename II> + oln_ch_concrete_type(I, ntg::int_u8) + image_inpainting_(const abstract::image& input, + const abstract::image<II>& mask) + { + oln_ch_concrete_type(I, ntg::int_u8) res(input.size(), "res"); + oln_type_of(I, concrete) ii(input.size(), "image_inpainting"); + oln_type_of(II, concrete) dil = morpho::erosion(morpho::erosion(mask.exact(), win_c8p()), win_c8p()); + oln_type_of(I, concrete) lpl(input.size(), "laplacian"); + oln_ch_concrete_type(I, std::vector<double>) v_lpl(input.size(), "laplacian_vector"); + oln_ch_concrete_type(I, std::vector<double>) n(input.size(), "direction_vector"); + oln_type_of(I, concrete) g(input.size(), "gradient"); + oln_type_of(I, concrete) b(input.size(), "beta"); + oln_type_of(I, fwd_piter) p(input.size()); + + bool conv = false; + double error = 0; + double norm = 0; + int i = 0; + + ii = clone(input.exact()); + ii = level::anisotropic_diffusion(ii, 1); + + while (conv == false) + { + clean_ima(ii); + error = 0; + lpl = convolution::laplacian(ii); + v_lpl = vect_laplacian_(lpl, dil); + n = compute_direction_(ii, dil); + b = compute_b_(v_lpl, n, dil); + g = compute_grad_(ii, b, dil); + + for_all_p(p) + { + if (mask[p] == false) + { + ii[p] = ii[p] + 0.1 * (g[p] * b[p] > 0 ? (g[p] / 255.0) * b[p] : (g[p] / 255.0) * b[p]); + error += b[p] > 0 ? b[p] : -b[p]; + } + } + + std::cerr << "erreur :" << error << std::endl; + + if (i % 15 == 0) + ii = level::anisotropic_diffusion(ii, 1); + + if (error < 0.1 or ++i > 10000000) + { + for_all_p(p) + { + res[p] = ii[p].value() < 0 ? 0 : (ii[p].value() > 255 ? 255 : ii[p].value()); + } + conv = true; + } + + }; + return res; + } + + } // end of namespace oln::impl::inpainting + + template <typename I, typename II> + oln_ch_concrete_type(I, ntg::int_u8) + image_inpainting(const abstract::image& input, + const abstract::image2d<II>& mask) + { + return impl::image_inpainting_(input.exact(), mask.exact()); + } + + } // end of namespace oln::appli + +} // end of namespace oln + + +#endif // ! OLENA_IMAGE_INPAINTING_HH

1 0

proto-1.0 395: Update anisotropic diffusion filter.
by Nicolas Widynski 10 Feb '06

10 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Update anisotropic diffusion filter. * oln/level/anisotropic_diffusion.hh: Fix bug. anisotropic_diffusion.hh | 41 ++++++++++++++++++++++++++++------------- 1 file changed, 28 insertions(+), 13 deletions(-) Index: oln/level/anisotropic_diffusion.hh --- oln/level/anisotropic_diffusion.hh (revision 394) +++ oln/level/anisotropic_diffusion.hh (working copy) @@ -31,8 +31,9 @@ # include <oln/basics.hh> # include <oln/utils/clone.hh> # include <oln/morpho/gradient_morpho.hh> + # define SQR(u) u*u -# define ABS(u) u > 0 ? u : -u +# define ABS(u) u >= 0 ? u : -u namespace oln { @@ -94,7 +95,6 @@ double compute_capa(const abstract::image& input) { double K = 0; - // on admet un 255 dans l'image double seuil = 0.9 * 255; oln_type_of(I, concrete) grad = morpho::gradient_morpho(input); @@ -108,25 +108,27 @@ return K; } + double diffusion_coefficient(double grad, double K) { - std::cout << "----------------" << std::endl; - std::cout << grad << std::endl; - std::cout << K << std::endl; return 1 / (1 + SQR(grad / K)); } template <typename I> oln_type_of(I, concrete) - anisotropic_diffusion_(const abstract::image& input) + anisotropic_diffusion_(const abstract::image& input, unsigned nb_it) { oln_type_of(I, concrete) a_d(input.size(), "gradient"); oln_ch_concrete_type(I, std::vector<double>) grad(input.size(), "gradient"); oln_type_of(I, fwd_piter) p(input.size()); bool conv = false; + bool change = false; double K = 0; double modify = 0; + double error = 0; + double tmp = 0; + unsigned it = 1; a_d = clone(input.exact()); @@ -135,6 +137,8 @@ clean_ima(a_d.exact()); grad = gradient_on_each_side_(a_d); K = compute_capa(a_d); + change = false; + error = 0; for_all_p(p) { @@ -142,17 +146,28 @@ typename std::vector<double>::const_iterator it; - for (it = grad[p].value().begin(); it != grad[p].value().end(); it++) - modify += *it * diffusion_coefficient(ABS((double)*it), K); + for (it = grad.at(p).begin(); it != grad.at(p).end(); it++) + modify += (double)(*it) * diffusion_coefficient((double)*it, K); - if (a_d[p] + 0.14 * modify >= 0 and a_d[p] + 0.14 * modify <= 255) + if (modify != 0 and a_d[p] + 0.14 * modify >= 0 and a_d[p] + 0.14 * modify <= 255) + { + tmp = a_d[p]; a_d[p] = a_d[p] + 0.14 * modify; + if ((double)a_d[p] != tmp) + change = true; + } + + error += ABS(modify); } - std::cout << modify << std::endl; - if (not modify) + std::cout << "error " << error << std::endl; + + if (it >= nb_it or error < 0.1 or change == false) conv = true; + + it++; }; + return a_d; } @@ -163,9 +178,9 @@ template <typename I> oln_type_of(I, concrete) - anisotropic_diffusion(const abstract::image& input) + anisotropic_diffusion(const abstract::image& input, unsigned nb_it) { - return impl::anisotropic_diffusion_(input.exact()); + return impl::anisotropic_diffusion_(input.exact(), nb_it); } } // end of namespace oln::level

1 0

394: Add implies, comma, typedef ret handling; then update.
by Thierry Geraud 10 Feb '06

10 Feb '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add implies, comma, typedef ret handling; then update. * mlc/implies.hh: New file. * mlc/is_a.hh: Update. * mlc/comma.hh: New file. * mlc/typedef.hh (in_, in_onlyif_): Rename as... (from_, from_only_if_): ...this. (mlc_typedef_in, mlc_typedef_in_): New macros. (mlc_ret): New macro. comma.hh | 39 +++++++++++++++++++++++++++++++++ implies.hh | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ is_a.hh | 4 +-- typedef.hh | 41 +++++++++++++++++++++++++++-------- 4 files changed, 144 insertions(+), 11 deletions(-) Index: mlc/implies.hh --- mlc/implies.hh (revision 0) +++ mlc/implies.hh (revision 0) @@ -0,0 +1,71 @@ +// Copyright (C) 2005, 2006 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 METALIC_IMPLIES_HH +# define METALIC_IMPLIES_HH + +# include <mlc/bool.hh> + + +/*! \macro mlc_implies(Left_BExpr, Right_BExpr) +** +** Macro correponding to mlc::implies_<L, R>, for use in a template +** context. +** +** \see mlc::implies_<L, R> +*/ + +# define mlc_implies(Left_BExpr, Right_BExpr) \ + typename mlc::implies_<Left_BExpr, Right_BExpr>::ret + +# define mlc_implies_(Left_BExpr, Right_BExpr) \ + mlc::implies_<Left_BExpr, Right_BExpr>::ret + + +namespace mlc +{ + + /*! \class mlc::implies_<L, R> + ** + ** Logical implication "L => R" with L and R being Boolean + ** expression types. This class is also a Boolean expression type. + ** + ** Sample use: + ** mlc::implies_< mlc_is_builtin(T), mlc_eq(T, int) >::ensure(); + ** which means "if T is a buit-in type, it has to be int". + */ + + template <typename L, typename R> + struct implies_ + : public bool_<( !mlc_bool(L) || mlc_bool(R) )> + {}; + +} // end of namespace mlc + + + +#endif // ! METALIC_IMPLIES_HH Index: mlc/is_a.hh --- mlc/is_a.hh (revision 393) +++ mlc/is_a.hh (working copy) @@ -237,7 +237,7 @@ */ # define mlc_is_a(T, U) \ -mlc::wrap<typename mlc::internal::is_a<sizeof(mlc::form::of())>::ret<T,U > > +mlc::wrap_<typename mlc::internal::is_a<sizeof(mlc::form::of())>::ret<T,U > > /*! \macro mlc_is_a_(T, U) @@ -249,7 +249,7 @@ */ # define mlc_is_a_(T, U) \ -mlc::wrap<mlc::internal::is_a< sizeof(mlc::form::of())>::ret<T,U > > +mlc::wrap_<mlc::internal::is_a< sizeof(mlc::form::of())>::ret<T,U > > #endif // ! METALIC_IS_A_HH Index: mlc/comma.hh --- mlc/comma.hh (revision 0) +++ mlc/comma.hh (revision 0) @@ -0,0 +1,39 @@ +// Copyright (C) 2006 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 METALIC_COMMA_HH +# define METALIC_COMMA_HH + + +// FIXME: doc + +# define mlc_comma_1(a, b) a, b +# define mlc_comma_2(a, b, c) a, b, c +# define mlc_comma_3(a, b, c, d) a, b, c, d + + +#endif // ! METALIC_COMMA_HH Index: mlc/typedef.hh --- mlc/typedef.hh (revision 393) +++ mlc/typedef.hh (working copy) @@ -169,7 +169,7 @@ struct TypedefName \ { \ template <class T> \ - struct in_ \ + struct from_ \ { \ private: \ typedef internal::TypedefName helper_; \ @@ -184,17 +184,17 @@ }; \ \ template <class T, bool b> \ - struct in_onlyif_; \ + struct from_onlyif_; \ \ \ template <class T> \ - struct in_onlyif_ <T, true> \ + struct from_onlyif_ <T, true> \ { \ - typedef typename in_<T>::ret ret; \ + typedef typename from_<T>::ret ret; \ }; \ \ template <class T> \ - struct in_onlyif_ <T, false> \ + struct from_onlyif_ <T, false> \ { \ typedef mlc::dummy ret; \ }; \ @@ -214,13 +214,25 @@ */ #define mlc_typedef(Type, TypedefName) \ - typename typedef_::TypedefName::in_<Type>::ret + typename typedef_::TypedefName::from_<Type>::ret #define mlc_typedef_(Type, TypedefName) \ - typedef_::TypedefName::in_<Type>::ret + typedef_::TypedefName::from_<Type>::ret +/*! \macro mlc_typedef_in(Namespace, Type, TypedefName) +** +** FIXME: doc +*/ + +# define mlc_typedef_in(Namespace, Type, TypedefName) \ + typename Namespace::typedef_::TypedefName::from_<Type>::ret + +# define mlc_typedef_in_(Namespace, Type, TypedefName) \ + Namespace::typedef_::TypedefName::from_<Type>::ret + + /*! \macro mlc_typedef_onlyif(Type, TypedefName, Bexpr) ** @@ -228,11 +240,22 @@ */ #define mlc_typedef_onlyif(Type, TypedefName, Bexpr) \ - typename typedef_::TypedefName::in_onlyif_<Type, mlc_bool(Bexpr)>::ret + typename typedef_::TypedefName::from_onlyif_<Type, mlc_bool(Bexpr)>::ret #define mlc_typedef_onlyif_(Type, TypedefName, Bexpr) \ - typedef_::TypedefName::in_onlyif_<Type, mlc_bool(Bexpr)>::ret + typedef_::TypedefName::from_onlyif_<Type, mlc_bool(Bexpr)>::ret + + + +/*! \FIXME: what's the correct comment flag here? +** +** Since we often rely on having a typedef named "ret" in types, we offer +** a default equipment for this particular typedef. FIXME: doc +*/ + +mlc_decl_typedef(ret); +# define mlc_ret(Type) typename typedef_::ret::from_<Type>::ret

1 0

proto-1.0 393: Add anisotropic diffusion.
by Nicolas Widynski 09 Feb '06

09 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Add anisotropic diffusion. * oln/level/anisotropic_diffusion.hh: New. Anisotropic diffusion algorithm. * oln/makefile.src: Add anisotropic_diffusion.hh to the makefile. level/anisotropic_diffusion.hh | 175 +++++++++++++++++++++++++++++++++++++++++ makefile.src | 1 2 files changed, 176 insertions(+) Index: oln/level/anisotropic_diffusion.hh --- oln/level/anisotropic_diffusion.hh (revision 0) +++ oln/level/anisotropic_diffusion.hh (revision 0) @@ -0,0 +1,175 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 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_LEVEL_ANISOTROPIC_DIFFUSION_HH +# define OLENA_LEVEL_ANISOTROPIC_DIFFUSION_HH + +# include <oln/basics.hh> +# include <oln/utils/clone.hh> +# include <oln/morpho/gradient_morpho.hh> +# define SQR(u) u*u +# define ABS(u) u > 0 ? u : -u + +namespace oln { + + namespace level { + + namespace impl { + + template <typename I> + oln_ch_concrete_type(I, std::vector<double>) + gradient_on_each_side_(const abstract::image& input) + { + oln_ch_concrete_type(I, std::vector<double>) g(input.size(), "gradient"); + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt; + + for_all_p(p) + { + pt = p; + + // N + g.at(p).push_back((double)input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() - + input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value()); + + // S + g.at(p).push_back((double)input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - + input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value()); + + // E + g.at(p).push_back((double)input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value()); + + // W + g.at(p).push_back((double)input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() - + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value()); + } + + return g; + } + + + template <typename T> + void clean_ima(image2d<T>& ima) + { + for (int j = 0; j < ima.size().ncols(); j++) + { + ima(-1, j) = ima(0, j); + ima(ima.size().nrows(), j) = ima(ima.size().nrows() - 1, j); + } + + for (int j = 0; j < ima.size().nrows(); j++) + { + ima(j, -1) = ima(j, 0); + ima(j, ima.size().ncols()) = ima(j, ima.size().ncols() - 1); + } + } + + + template <typename I> + double compute_capa(const abstract::image& input) + { + double K = 0; + // on admet un 255 dans l'image + double seuil = 0.9 * 255; + + oln_type_of(I, concrete) grad = morpho::gradient_morpho(input); + oln_type_of(I, fwd_piter) p(input.size()); + + for_all_p(p) + { + if (grad[p] < (int)seuil) + K++; + } + return K; + } + + double diffusion_coefficient(double grad, double K) + { + std::cout << "----------------" << std::endl; + std::cout << grad << std::endl; + std::cout << K << std::endl; + return 1 / (1 + SQR(grad / K)); + } + + template <typename I> + oln_type_of(I, concrete) + anisotropic_diffusion_(const abstract::image& input) + { + oln_type_of(I, concrete) a_d(input.size(), "gradient"); + oln_ch_concrete_type(I, std::vector<double>) grad(input.size(), "gradient"); + oln_type_of(I, fwd_piter) p(input.size()); + + bool conv = false; + double K = 0; + double modify = 0; + + a_d = clone(input.exact()); + + while (conv == false) + { + clean_ima(a_d.exact()); + grad = gradient_on_each_side_(a_d); + K = compute_capa(a_d); + + for_all_p(p) + { + modify = 0; + + typename std::vector<double>::const_iterator it; + + for (it = grad[p].value().begin(); it != grad[p].value().end(); it++) + modify += *it * diffusion_coefficient(ABS((double)*it), K); + + if (a_d[p] + 0.14 * modify >= 0 and a_d[p] + 0.14 * modify <= 255) + a_d[p] = a_d[p] + 0.14 * modify; + } + + std::cout << modify << std::endl; + if (not modify) + conv = true; + }; + return a_d; + } + + + + } // end of namespace oln::level::impl + + + template <typename I> + oln_type_of(I, concrete) + anisotropic_diffusion(const abstract::image& input) + { + return impl::anisotropic_diffusion_(input.exact()); + } + + } // end of namespace oln::level + +} // end of namespace oln + +#endif // ! OLENA_LEVEL_ANISOTROPIC_DIFFUSION_HH Index: oln/makefile.src --- oln/makefile.src (revision 392) +++ oln/makefile.src (working copy) @@ -177,6 +177,7 @@ level/invert.hh \ level/level_components.hh \ level/logic.hh \ + level/anisotropic_diffusion.hh \ \ morpho/closing.hh \ morpho/dilation.hh \

1 0

Re: [Olena-patches] proto-1.0 391: Implementation of a denoising image processing algorithm : Non Local Means.
by Nicolas 09 Feb '06

09 Feb '06

This implementation is not generic but shows difficulties with the use of point and dpoint. For details, please see the topic in lrde.olena (coming soon :)) about the arguing of points and dpoints in Olena. -- Widynski Nicolas Promo 2007

1 0

proto-1.0 391: Implementation of a denoising image processing algorithm : Non Local Means.
by Nicolas Widynski 09 Feb '06

09 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Implementation of a denoising image processing algorithm : Non Local Means. * oln/appli/denoising/nl_means.hh: New. NL-means algorithm. * oln/makefile.src: Update for laplacian convolution and NL-means algorithm. appli/denoising/nl_means.hh | 141 ++++++++++++++++++++++++++++++++++++++++++++ makefile.src | 4 + 2 files changed, 145 insertions(+) Index: oln/appli/denoising/nl_means.hh --- oln/appli/denoising/nl_means.hh (revision 0) +++ oln/appli/denoising/nl_means.hh (revision 0) @@ -0,0 +1,141 @@ +// Copyright (C) 2001, 2002, 2004, 2005, 2006 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_DENOISING_NLMEANS_HH +# define OLENA_DENOISING_NLMEANS_HH + +# define SQR(u) u*u +# define PI 3.141592653589793238462643 + +# include <cmath> +# include <oln/level/fill.hh> + +namespace oln { + + namespace denoising { + + namespace impl { + + + template<typename I> + const oln_type_of(I, concrete) gaussian_mask(double variance, + int rows, + int cols) + { + oln_type_of(I, concrete) g_m(rows, cols, 0); + + int i, j; + + for (i = 0; i < rows; i++) + for (j = 0; j < cols; j++) + g_m(i,j) = (1 / 2 * PI * SQR(variance)) * exp(-(SQR(rows / 2 - i) + SQR(cols / 2 - j))); + + return g_m; + } + + + template<typename I> + oln_type_of(I, concrete) nl_means_(const oln::abstract::image& input, + int window, + double variance, + int horizon) + { + oln_type_of(I, concrete) nl(input.size(), "nl_means"); + oln_type_of(I, concrete) g_m; + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt1; + oln_type_of(I, point) pt2; + + int i, j, k, l, i2, j2, k2, l2; + double dist; + double w; + double Z; + double val; + + + level::fill(nl, 0); + + g_m = gaussian_mask(variance, window, window); + + for (i = 0; i < input.size().ncols(); i++) + { + for (j = 0; j < input.size().nrows(); j++) + { + Z = 0; + val = 0; + + for (k = i - horizon; k = 0 and k < (int)input.size().ncols() and l >= 0 and l < (int)input.size().nrows())) + continue; + + dist = 0; + w = 0; + + for (k2 = k - window / 2, i2 = i - window / 2; k2 < (k + window / 2 + window % 2); k2++, i2++) + for (l2 = l - window / 2, j2 = j - window / 2; l2 < (l + window / 2 + window % 2); l2++, j2++) + + if (i2 >= 0 and i2 < input.size().ncols() && j2 >= 0 and j2 < input.size().nrows() and + k2 >= 0 and k2 < input.size().ncols() && l2 >= 0 and l2 < input.size().nrows()) + { + dist += g_m.exact()(k2 + window / 2 - k, l2 + window / 2 - l) * + ((input.exact()(i2, j2) - input.exact()(k2, l2)) * + (input.exact()(i2, j2) - input.exact()(k2, l2))); + } + + w = exp(-dist/(SQR(variance))); + val += w * input.exact()(k, l).value(); + Z += w; + } + + nl(i,j) = val / Z; + } + + std::cout << (int)input.size().nrows() << " / " < + oln_type_of(I, concrete) nl_means(const oln::abstract::image& input, + int window, + double variance, + int horizon) + { + return impl::nl_means_(input.exact(), window, variance, horizon); + } + + + } // end of namespace oln::denoising + +} // end of namespace oln + +#endif // OLENA_DENOISING_NLMEANS_HH Index: oln/makefile.src --- oln/makefile.src (revision 390) +++ oln/makefile.src (working copy) @@ -10,6 +10,8 @@ appli/astro/tree_coherence_check.hh \ appli/astro/tree_statistics.hh \ \ + appli/denoising/nl_means.hh \ + \ basics1d.hh \ basics2d.hh \ basics3d.hh \ @@ -30,6 +32,8 @@ convert/stretch.hh \ convert/value_to_point.hh \ \ + convolution/laplacian.hh \ + \ core/1d/array1d.hh \ core/1d/bkd_piter1d.hh \ core/1d/dpoint1d.hh \

1 0

proto-1.0 390: Update laplacian convolution.
by Nicolas Widynski 09 Feb '06

09 Feb '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Update laplacian convolution. * oln/convolution/laplacian.hh: Update file. laplacian.hh | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) Index: oln/convolution/laplacian.hh --- oln/convolution/laplacian.hh (revision 389) +++ oln/convolution/laplacian.hh (working copy) @@ -45,13 +45,11 @@ namespace impl { - // FIXME : type I must be a ntg::int_s8 u8... - template <typename I> oln_type_of(I, concrete) laplacian_(const abstract::image2d& input) { - oln_type_of(I, concrete) lpl(input.size(), "laplacian second derivative"); + oln_type_of(I, concrete) lpl(input.size(), "laplacian"); oln_type_of(I, fwd_piter) p(input.size()); oln_type_of(I, point) pt; oln_type_of(I, value) v; @@ -73,7 +71,7 @@ template <typename I> oln_type_of(I, concrete) - laplacian_(const abstract::image& input) + laplacian(const abstract::image& input) { return impl::laplacian_(input.exact()); }

1 0