Index: olena/ChangeLog
from Giovanni Palma <giovanni(a)lrde.epita.fr>
* oln/morpho/closing.inc: Correct comments.
* oln/morpho/extrema_killer.hh: Likewise.
* oln/morpho/attribute_closing_opening_map.hh: Likewise.
* oln/morpho/extrema.hxx: Likewise.
* oln/morpho/erosion.hh: Likewise.
* oln/morpho/extrema.hh: Likewise.
* oln/morpho/attribute_closing_opening.hh: Likewise.
* oln/morpho/attribute_union_find.hh: Likewise.
* oln/morpho/attributes.hh: Likewise.
* oln/morpho/dilation.hh: Add comments.
* oln/morpho/fast_morpho.hh: Likewise.
* oln/morpho/fast_morpho.hxx: Likewise.
* oln/morpho/geodesic_dilation.hh: Likewise.
* oln/morpho/geodesic_erosion.hh: Likewise.
* oln/morpho/gradient.inc: Likewise.
* oln/morpho/hit_or_miss.inc: Likezise.
* oln/morpho/laplacian.inc: Likewise.
* oln/morpho/minmax.hh: Likewise.
* oln/morpho/opening.inc: Likewise.
* oln/morpho/reconstruction.hh: Likewise.
* oln/morpho/splitse.hh: Likewise.
* oln/morpho/stat.hh: Likewise.
* oln/morpho/thickening.inc: Likewise.
* oln/morpho/thinning.inc: Likewise.
* oln/morpho/top_hat.inc: Likewise.
* oln/morpho/watershed.hh: Likewise.
* oln/morpho/watershed.hxx: Likewise.
Index: olena/oln/morpho/closing.inc
--- olena/oln/morpho/closing.inc Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/44_closing.in 1.15 600)
+++ olena/oln/morpho/closing.inc Wed, 10 Mar 2004 19:57:33 +0100 palma_g (oln/44_closing.in 1.15 640)
@@ -30,11 +30,11 @@
* ns: morpho, morpho::fast
* what: Morphological closing.
* arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
+ * arg: const abstract::struct_elt<E>&, se, IN, structuring element
* ret:oln_concrete_type(I)
* doc:
* Compute the morphological closing of \var{input} using \var{se}
- * as structural element.
+ * as structuring element.
* see: morpho::erosion
* see: morpho::dilation
* see: morpho::closing
@@ -47,14 +47,14 @@
/*!
** \brief Processing closing.
**
-** Compute the morphological closing of input using se as structural
+** Compute the morphological closing of input using se as structuring
** element.
**
-** \param I: exact type of the input image.
-** \param E: exact type of the structural element.
+** \param I Exact type of the input image.
+** \param E Exact type of the structuring element.
**
-** \arg input: input image to close.
-** \arg se: structural element to use.
+** \arg input Input image to close.
+** \arg se Structuring element to use.
**
** \warning This code is the same for morpho and morpho::fast
** namespaces.
Index: olena/oln/morpho/dilation.hh
--- olena/oln/morpho/dilation.hh Thu, 07 Aug 2003 02:08:21 +0200 david (oln/b/5_dilation.h 1.16 600)
+++ olena/oln/morpho/dilation.hh Wed, 10 Mar 2004 19:58:42 +0100 palma_g (oln/b/5_dilation.h 1.16 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 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
@@ -37,42 +37,56 @@
namespace morpho {
- /*=processing dilation
- * ns: morpho, morpho::fast
- * what: Morphological dilation.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the morphological dilation of \var{input} using \var{se}
- * as structural element.
- *
- * On grey-scale images, each point is replaced by the maximum value
- * of its neighbors, as indicated by \var{se}. On binary images,
- * a logical \code{or} is performed between neighbors.
- *
- * The \code{morpho::fast} version of this function use a different
- * algorithm: This algorith; is described in
- * Implementation of morphological operations from:
- * M. Van Droogenbroeck and H. Talbot.
- * "Fast computation of morphological operations with arbitrary
- * structuring elements". Pattern Recognition Letters,
- * 17(14):1451-1460, 1996.
- *
- * An
- * histogram of the value of the neighborhood indicated by
- * \var{se} is updated while iterating over all point of the
- * image. Doing so is more efficient when the
- * structural element is large.
- *
- * see: morpho::n_dilation
- * see: morpho::erosion
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * $ save(morpho::dilation(im, win_c8p()), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
- =*/
+ /*!
+ ** \brief Processing dilation.
+ **
+ ** Compute the morphological dilation of input using se
+ ** as structural element.
+ **
+ ** On grey-scale images, each point is replaced by the maximum value
+ ** of its neighbors, as indicated by se. On binary images,
+ ** a logical or is performed between neighbors.
+ **
+ ** The morpho::fast version of this function use a different
+ ** algorithm: This algorithm is described in
+ ** Implementation of morphological operations from:
+ ** M. Van Droogenbroeck and H. Talbot.
+ ** "Fast computation of morphological operations with arbitrary
+ ** structuring elements". Pattern Recognition Letters,
+ ** 17(14):1451-1460, 1996.
+ **
+ ** An histogram of the value of the neighborhood indicated by
+ ** se is updated while iterating over all point of the
+ ** image. Doing so is more efficient when the
+ ** structural element is large.
+ **
+ ** \param I Exact type of the input image.
+ ** \param E Exact type of the neighborhood.
+ **
+ ** \arg input The input image.
+ ** \arg se Structuring element to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/dilation.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::bin> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "object.pbm"));
+ ** save(oln::morpho::dilation(im1, oln::win_c8p()), IMG_OUT "oln_morpho_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html object.png
+ ** \image latex object.png
+ ** =>
+ ** \image html oln_morpho_dilation.png
+ ** \image latex oln_morpho_dilation.png
+ */
template<class I, class E>
oln_concrete_type(I)
dilation(const abstract::non_vectorial_image<I> &input,
@@ -89,18 +103,39 @@
return output;
}
- /*=processing n_dilation
- * ns: morpho
- * what: Morphological dilation itered n times.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * arg: unsigned, n, IN, number of iterations
- * ret:oln_concrete_type(I)
- * doc:
- * Apply \code{morpho::dilation} \var{n} times.
- * see: morpho::dilation
- * see: morpho::n_erosion
- =*/
+ /*!
+ ** \brief Perform morphological dilation iterated n times.
+ **
+ **
+ ** \param I Exact type of the input image.
+ ** \param E Exact type of the structuring element.
+ **
+ ** \arg input Input image.
+ ** \arg se Structuring element to use.
+ ** \arg n Number of iterations.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/dilation.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::bin> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "object.pbm"));
+ ** save(oln::morpho::n_dilation(im1, oln::win_c8p(), 5), IMG_OUT "oln_morpho_n_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html object.png
+ ** \image latex object.png
+ ** =>
+ ** \image html oln_morpho_n_dilation.png
+ ** \image latex oln_morpho_n_dilation.png
+ **
+ */
template<class I, class E>
oln_concrete_type(I)
n_dilation(const abstract::non_vectorial_image<I> & input,
Index: olena/oln/morpho/erosion.hh
--- olena/oln/morpho/erosion.hh Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/b/4_erosion.hh 1.18 600)
+++ olena/oln/morpho/erosion.hh Wed, 10 Mar 2004 20:00:55 +0100 palma_g (oln/b/4_erosion.hh 1.18 640)
@@ -40,7 +40,7 @@
** \brief Perform a morphological erosion.
**
** Compute the morphological erosion of input using se
- ** as structural element.
+ ** as structuring element.
**
** On grey-scale images, each point is replaced by the minimum
** value of its neighbors, as indicated by se. On binary
@@ -48,15 +48,15 @@
** morpho::fast version of this function use a different
** algorithm: an histogram of the value of the neighborhood
** indicated by se is updated while iterating over all point of
- ** the image. Doing so is more efficient when the structural
+ ** the image. Doing so is more efficient when the structuring
** element is large.
**
- ** \param I: exact type of the input image.
- ** \param E: exact type of the structural element.
+ ** \param I Exact type of the input image.
+ ** \param E Exact type of the structuring element.
**
**
- ** \arg input: input image.
- ** \arg se: structural element to use.
+ ** \arg input Input image.
+ ** \arg se Structuring element to use.
**
** \code
** #include <oln/basics2d.hh>
@@ -97,15 +97,15 @@
}
/*!
- ** \brief Perform morphological erosion itered n times.
+ ** \brief Perform morphological erosion iterated n times.
**
**
- ** \param I: exact type of the input image.
- ** \param E: exact type of the structural element.
+ ** \param I Exact type of the input image.
+ ** \param E Exact type of the structuring element.
**
- ** \arg input: input image.
- ** \arg se: structural element to use.
- ** \arg n: number of iterations.
+ ** \arg input Input image.
+ ** \arg se Structuring element to use.
+ ** \arg n Number of iterations.
**
** \code
** #include <oln/basics2d.hh>
@@ -151,14 +151,14 @@
** \brief Perform a morphological erosion.
**
** Compute the morphological erosion of input using se
- ** as structural element.
+ ** as structuring element.
**
- ** \param I: exact type of the input image.
- ** \param E: exact type of the structural element.
+ ** \param I Exact type of the input image.
+ ** \param E Exact type of the structuring element.
**
**
- ** \arg input: input image.
- ** \arg se: structural element to use.
+ ** \arg input Input image.
+ ** \arg se Structuring element to use.
**
** \code
** #include <oln/basics2d.hh>
Index: olena/oln/morpho/extrema.hh
--- olena/oln/morpho/extrema.hh Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/38_extrema.hh 1.12 600)
+++ olena/oln/morpho/extrema.hh Thu, 11 Mar 2004 16:22:19 +0100 palma_g (oln/38_extrema.hh 1.12 640)
@@ -38,7 +38,8 @@
/*!
** \brief oln::morpho::sure namespace.
**
- ** Here come algorithms that are sure.
+ ** Namespace where you can find reference algorithms, i.e. those
+ ** that are sure.
*/
namespace sure {
# include <oln/morpho/extrema.hxx>
@@ -47,7 +48,7 @@
/*!
** \brief oln::morpho::sequential namespace.
**
- ** Here come algorithms that are sequential.
+ ** Namespace where you can find sequential algorithms.
*/
namespace sequential {
# include <oln/morpho/extrema.hxx>
@@ -56,7 +57,7 @@
/*!
** \brief oln::morpho::hybrid namespace.
**
- ** Here come algorithms that are hybrid.
+ ** Namespace where you can find hybrid algorithms.
*/
namespace hybrid {
# include <oln/morpho/extrema.hxx>
Index: olena/oln/morpho/extrema.hxx
--- olena/oln/morpho/extrema.hxx Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/j/4_extrema.hx 1.12 600)
+++ olena/oln/morpho/extrema.hxx Wed, 10 Mar 2004 20:02:35 +0100 palma_g (oln/j/4_extrema.hx 1.12 640)
@@ -33,10 +33,10 @@
/*!
** \brief Create extremum image from another one.
**
- ** \param DestType: type of data in the wanted image.
- ** \param I: Exact type of the input image.
+ ** \param DestType Type of data in the wanted image.
+ ** \param I Exact type of the input image.
**
- ** \arg input: input image.
+ ** \arg input Input image.
*/
template <class DestType, class I>
typename mute<I, DestType>::ret
@@ -57,9 +57,9 @@
/*!
** \brief Create binary image from another one.
**
- ** \param I: exact type of the image.
+ ** \param I Exact type of the image.
**
- ** \arg input: input image.
+ ** \arg input Input image.
*/
template <class I>
typename mute<I, ntg::bin>::ret
@@ -85,13 +85,13 @@
** neighborhood. minima_map must be a bin image (true for a minimum,
** false for a non minimum). Soille p.172.
**
-** \param I: exact type of the first image.
-** \param I2: exact type of the second image.
-** \param N: exact type of the neighborhood.
-**
-** \arg input: input image.
-** \arg minima_map: minima map image.
-** \arg Ng: neighborhood to use.
+** \param I Exact type of the first image.
+** \param I2 Exact type of the second image.
+** \param N Exact type of the neighborhood.
+**
+** \arg input Input image.
+** \arg minima_map Minima map image.
+** \arg Ng Neighborhood to use.
**
** \ref foototo
** \code
@@ -146,11 +146,11 @@
/*!
** \brief Extract regional minima.
**
-** \param I: Exact type of input image.
+** \param I Exact type of input image.
** \param Exact type of neighborhood.
**
-** \arg input: input image.
-** \arg Ng: neighborhood to use.
+** \arg input Input image.
+** \arg Ng Neighborhood to use.
**
** \code
** #include <oln/basics2d.hh>
Index: olena/oln/morpho/extrema_killer.hh
--- olena/oln/morpho/extrema_killer.hh Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/e/19_extrema_ki 1.7.1.4.1.11 600)
+++ olena/oln/morpho/extrema_killer.hh Wed, 10 Mar 2004 20:06:34 +0100 palma_g (oln/e/19_extrema_ki 1.7.1.4.1.11 640)
@@ -51,12 +51,12 @@
/*!
** \brief Kill connex components smaller than a given area.
**
- ** \param I: exact type of the input image.
- ** \param N: exact type of the neighborhood.
+ ** \param I E xact type of the input image.
+ ** \param N Exact type of the neighborhood.
**
- ** \arg input: the input image.
- ** \arg area: the threshold to use.
- ** \arg Ng: the neighborhood to use.
+ ** \arg input The input image.
+ ** \arg area The threshold to use.
+ ** \arg Ng The neighborhood to use.
*/
template<class I, class N>
typename mute<I, ntg::bin>::ret
@@ -95,16 +95,16 @@
** \brief Maxima killer.
**
** It removes the small (in area) connected components of the upper
- ** level sets of input using se as structual element. The implementation
+ ** level sets of input using se as structuring element. The implementation
** uses the threshold superposition principle; so it is very slow ! it works only for
** int_u8 images.
**
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
**
- ** \arg input: the input image.
- ** \arg area: threshold to use.
- ** \arg Ng: the neighborhood to use.
+ ** \arg input The input image.
+ ** \arg area Threshold to use.
+ ** \arg Ng The neighborhood to use.
**
** \code
** #include <oln/basics2d.hh>
@@ -167,17 +167,17 @@
/*!
** \brief Minima killer.
**
- ** It removes the small (in area) connected components of the lower
- ** level sets of input using se as structual element. The implementation
- ** uses the threshold superposition principle; so it is very slow ! it works only for
- ** int_u8 images.
- **
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
- **
- ** \arg input: the input image.
- ** \arg area: threshold to use.
- ** \arg Ng: the neighborhood to use.
+ ** It removes the small (in area) connected components of the
+ ** lower level sets of input using se as structuring element. The
+ ** implementation uses the threshold superposition principle; so
+ ** it is very slow ! it works only for int_u8 images.
+ **
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
+ **
+ ** \arg input The input image.
+ ** \arg area Threshold to use.
+ ** \arg Ng The neighborhood to use.
**
** \code
** #include <oln/basics2d.hh>
@@ -245,14 +245,14 @@
/*!
** \brief Check if a point is a strict minimum.
**
- ** \param P: exact type of the point.
- ** \param I: exact type of the image.
- ** \param N: exact type of the neighborhood.
+ ** \param P Exact type of the point.
+ ** \param I Exact type of the image.
+ ** \param N Exact type of the neighborhood.
**
- ** \arg p: the point to consider.
- ** \arg input: the image where to get the value of the point to
+ ** \arg p The point to consider.
+ ** \arg input The image where to get the value of the point to
** consider.
- ** \arg Ng: type of neighborhood to use.
+ ** \arg Ng Type of neighborhood to use.
*/
template<class P, class I, class N>
// inline
@@ -280,14 +280,14 @@
/*!
** \brief Check if a point is a strict maximum.
**
- ** \param P: exact type of the point.
- ** \param I: exact type of the image.
- ** \param N: exact type of the neighborhood.
+ ** \param P Exact type of the point.
+ ** \param I Exact type of the image.
+ ** \param N Exact type of the neighborhood.
**
- ** \arg p: the point to consider.
- ** \arg input: the image where to get the value of the point to
+ ** \arg p The point to consider.
+ ** \arg input The image where to get the value of the point to
** consider.
- ** \arg Ng: type of neighborhood to use.
+ ** \arg Ng Type of neighborhood to use.
*/
template<class P, class I, class N>
// inline
@@ -321,12 +321,12 @@
** implementation is based on stak. Guichard and Morel, Image
** iterative smoothing and PDE's. Book in preparation. p 265.
**
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
**
- ** \arg input: the input image.
- ** \arg area: threshold to use.
- ** \arg Ng: the neighborhood to use.
+ ** \arg input The input image.
+ ** \arg area Threshold to use.
+ ** \arg Ng The neighborhood to use.
**
** \code
** #include <oln/basics2d.hh>
@@ -446,12 +446,12 @@
** implementation is based on stak. Guichard and Morel, Image
** iterative smoothing and PDE's. Book in preparation. p 265.
**
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
**
- ** \arg input: the input image.
- ** \arg area: threshold to use.
- ** \arg Ng: the neighborhood to use.
+ ** \arg input The input image.
+ ** \arg area Threshold to use.
+ ** \arg Ng The neighborhood to use.
**
** \code
** #include <oln/basics2d.hh>
Index: olena/oln/morpho/fast_morpho.hh
--- olena/oln/morpho/fast_morpho.hh Thu, 07 Aug 2003 02:08:21 +0200 david (oln/46_fast_morph 1.8 600)
+++ olena/oln/morpho/fast_morpho.hh Wed, 10 Mar 2004 17:10:53 +0100 palma_g (oln/46_fast_morph 1.8 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 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
@@ -33,6 +33,10 @@
namespace oln {
namespace morpho {
+ /*!
+ ** Do not exist !!!
+ ** \todo FIXME: REMOVE ME.
+ */
template<class I, class E> inline
oln_concrete_type(I)
fast_morpho(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/fast_morpho.hxx
--- olena/oln/morpho/fast_morpho.hxx Thu, 07 Aug 2003 02:08:21 +0200 david (oln/45_fast_morph 1.18 600)
+++ olena/oln/morpho/fast_morpho.hxx Wed, 10 Mar 2004 19:24:52 +0100 palma_g (oln/45_fast_morph 1.18 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -40,12 +40,21 @@
namespace oln {
namespace morpho {
+ /*!
+ ** \brief oln::morpho::internal namespace
+ ** Internal stuff.
+ */
namespace internal {
- // Find structuring elements to be added/removed from the histogram
- // when we move forward along each direction.
- // FIXME: add(dp) on w_windows associates a default weight set
- // to 1
+ /*!
+ ** \brief Find structuring elements.
+ **
+ ** Find structuring elements to be added/removed from the histogram
+ ** when we move forward along each direction.
+ **
+ ** \todo FIXME: add(dp) on w_windows associates a default weight set
+ ** to 1
+ */
template<class E1, class E2, class E3>
void
find_struct_elts(const abstract::struct_elt<E1>& se,
@@ -101,9 +110,12 @@
postcondition(se_add[n].card() == se_rem[n].card());
}
-
- // Update HIST by adding elements from _SE_ADD, and removing
- // those from _SE_REM.
+ /*!
+ ** \brief Update an histogram.
+ **
+ ** Update HIST by adding elements from _SE_ADD, and removing
+ ** those from _SE_REM.
+ */
template<class I, class E1, class E2, class H>
// inline
void
@@ -126,16 +138,20 @@
}
- // We will zigzag over the image so that only one coordinate
- // changes at each step. The path looks as follow on
- // 2D images:
- // -----------------.
- // ,----------------'
- // `----------------.
- // ,----------------'
- // `-----------------
- // (The algorithm below handles the n-dimensional case.)
-
+ /*!
+ ** We will zigzag over the image so that only one coordinate
+ ** changes at each step. The path looks as follow on
+ ** 2D images:\n
+ ** --------------\
+ ** |
+ ** /-------------/
+ ** |
+ ** \-------------\
+ ** |
+ ** -------------/
+ ** \n
+ ** (The algorithm below handles the n-dimensional case.)
+ */
template<unsigned NP1,
unsigned Dim,
typename I,
@@ -145,6 +161,10 @@
typename P,
typename O>
struct fast_morpho_inner {
+
+ /*!
+ ** Perform the action.
+ */
static void
doit(I& input, S& size, H& hist,
B* se_add, B* se_rem, B* se_add_back, B* se_rem_back,
@@ -237,23 +257,60 @@
};
} // internal
-
+ /*!
+ ** \brief functor to sort dimensions.
+ */
template<class E>
struct sort_dimensions
{
+ /*!
+ ** \brief Constructor.
+ */
sort_dimensions(abstract::struct_elt<E> se[mlc::exact<E>::ret::dim])
: se_(se) {}
+ /*!
+ ** \brief Parenthesis operator.
+ **
+ ** Call it to use the functor.
+ */
bool operator()(unsigned a, unsigned b)
{
return se_[a].card() > se_[b].card();
}
protected:
- abstract::struct_elt<E>* se_;
+ abstract::struct_elt<E>* se_; ///< Structural element.
};
-
+ /*!
+ ** \brief Fast morpho algorithm.
+ **
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/erosion.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::bin> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "object.pbm"));
+ ** //save(oln::morpho::fast_morpho<im_type, oln::win_c8p(), utils::histogram_min>
+ ** // (im1, oln::win_c8p()), IMG_OUT "oln_morpho_fast_morpho.pbm");
+ ** save(im1, IMG_OUT "oln_morpho_fast_morpho.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html object.png
+ ** \image latex object.png
+ ** =>
+ ** \image html oln_morpho_fast_morpho.png
+ ** \image latex oln_morpho_fast_morpho.png
+ ** \todo FIXME: Correct this function and make the example use it.
+ */
template<class I, class E, template<typename, typename> class H>
oln_concrete_type(I)
fast_morpho(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/geodesic_dilation.hh
--- olena/oln/morpho/geodesic_dilation.hh Wed, 08 Oct 2003 23:36:51 +0200 burrus_n (oln/37_geodesic_d 1.11.1.10 600)
+++ olena/oln/morpho/geodesic_dilation.hh Thu, 11 Mar 2004 19:56:56 +0100 palma_g (oln/37_geodesic_d 1.11.1.10 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -42,28 +42,48 @@
namespace oln {
namespace morpho {
- /*=processing geodesic_dilation
- * ns: morpho
- * what: Geodesic dilation.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the geodesic dilation of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.156.
- * Note mask must be greater or equal than marker.
- * see: morpho::simple_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::geodesic_dilation(dark, light, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
-
+ /*!
+ ** \brief Processing a geodesic dilation.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** Compute the geodesic dilation of marker with respect to the
+ ** mask image using se as structuring element. Soille
+ ** p.156.
+ ** \pre Mask must be greater or equal than marker.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/geodesic_dilation.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** save(oln::morpho::geodesic_dilation(im2, im1, oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_geodesic_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_geodesic_dilation.png
+ ** \image latex oln_morpho_geodesic_dilation.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_dilation(const abstract::non_vectorial_image<I1> & marker,
@@ -80,29 +100,51 @@
}
namespace sure {
- /*=processing simple_geodesic_dilation
- * ns: morpho
- * what: Geodesic dilation.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the geodesic dilation of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.156. Computation is
- * performed by hand (i.e without calling dilation).
- * Note mask must be greater or equal than marker.
- * see: morpho::sure_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::simple_geodesic_dilation(dark, light,
- * $ win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Processing a geodesic dilation.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** Compute the geodesic dilation of marker with respect to the
+ ** mask image using se as structuring element. Soille
+ ** p.156.
+ ** \pre Mask must be greater or equal than marker.
+ **
+ ** \warning This version shouldn't be use, since it exists only
+ ** to have a reference algorithm.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/geodesic_dilation.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** save(oln::morpho::sure::geodesic_dilation(im2, im1, oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sure_geodesic_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sure_geodesic_dilation.png
+ ** \image latex oln_morpho_sure_geodesic_dilation.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_dilation(const abstract::non_vectorial_image<I1> & marker,
Index: olena/oln/morpho/geodesic_erosion.hh
--- olena/oln/morpho/geodesic_erosion.hh Wed, 08 Oct 2003 23:36:51 +0200 burrus_n (oln/36_geodesic_e 1.17 600)
+++ olena/oln/morpho/geodesic_erosion.hh Thu, 11 Mar 2004 19:58:19 +0100 palma_g (oln/36_geodesic_e 1.17 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -39,27 +39,49 @@
namespace oln {
namespace morpho {
- /*=processing geodesic_erosion
- * ns: morpho
- * what: Geodesic erosion.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the geodesic erosion of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.158.
- * Note marker must be greater or equal than mask.
- * see: morpho::simple_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::geodesic_erosion(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Processing a geodesic erosion.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** Compute the geodesic erosion of marker with respect to the
+ ** mask mask image using se as structural element. Soille p.158.
+ **
+ ** \pre Marker must be greater or equal than mask.
+ **
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/geodesic_erosion.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** save(oln::morpho::geodesic_erosion(im1, im2, oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_geodesic_erosion.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_geodesic_erosion.png
+ ** \image latex oln_morpho_geodesic_erosion.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_erosion(const abstract::non_vectorial_image<I1> & marker,
@@ -74,28 +96,53 @@
}
namespace sure {
- /*=processing simple_geodesic_erosion
- * ns: morpho
- * what: Geodesic erosion.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the geodesic erosion of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.156. Computation is
- * performed by hand (i.e without calling dilation).
- * Note marker must be greater or equal than mask.
- * see: morpho::sure_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::geodesic_erosion(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Processing a geodesic erosion.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** Compute the geodesic erosion of marker with respect to the
+ ** mask mask image using se as structural element. Soille
+ ** p.156. Computation is performed by hand (i.e without calling
+ ** dilation).
+ **
+ ** \pre Marker must be greater or equal than mask.
+ **
+ ** \warning This version shouldn't be use, since it exists only
+ ** to have a reference algorithm.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/geodesic_erosion.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** save(oln::morpho::sure::geodesic_erosion(im1, im2, oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sure_geodesic_erosion.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sure_geodesic_erosion.png
+ ** \image latex oln_morpho_sure_geodesic_erosion.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_erosion(const abstract::non_vectorial_image<I1> & marker,
Index: olena/oln/morpho/gradient.inc
--- olena/oln/morpho/gradient.inc Thu, 07 Aug 2003 02:08:21 +0200 david (oln/43_gradient.i 1.13 600)
+++ olena/oln/morpho/gradient.inc Thu, 11 Mar 2004 16:05:01 +0100 palma_g (oln/43_gradient.i 1.13 640)
@@ -1,13 +1,13 @@
// -*- c++ -*-
-// Copyright (C) 2001 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 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
+// 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.
//
@@ -26,28 +26,16 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-
-
-/*=processing beucher_gradient
- * ns: morpho, morpho::fast
- * what: Morphological Beucher Gradient.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute the arithmetic difference between the diltation and
- * the erosion of \var{input} using \var{se} as structural element. Soille, p67.
- * see: morpho::erosion
- * see: morpho::dilation
- * see: morpho::external_gradient
- * see: morpho::internal_gradient
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::beucher_gradient(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Process a morphological beucher gradient.
+**
+** Compute the arithmetic difference between the diltation and the
+** erosion of input using se as structural element. Soille, p67.
+**
+** \arg c Conversion functor.
+** \arg input Image to process.
+** \arg se Structuring element.
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
beucher_gradient(const convert::abstract::conversion<C, B>& c,
@@ -57,14 +45,41 @@
return arith::minus(c, dilation(input, se), erosion(input, se));
}
-
-/*=processingoverload beucher_gradient
- * ns: morpho, morpho::fast
- * what: Morphological Beucher Gradient.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
-=*/
+/*!
+** \brief Process a morphological beucher gradient.
+**
+** \param I Exact type of the input image.
+** \param E Exact type of the structuring element.
+**
+** \return The beucher gradient of the input.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/gradient.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+**
+** save(oln::morpho::beucher_gradient(im1, oln::win_c8p()),
+** IMG_OUT "oln_morpho_beucher_gradient.pbm");
+** return 0;
+** }
+** \encode
+**
+** \image html lena128.png
+** \image latex lena128.png
+** =>
+** \image html oln_morpho_beucher_gradient.png
+** \image latex oln_morpho_beucher_gradient.png
+**
+*/
template<class I, class E>
oln_concrete_type(I)
beucher_gradient(const abstract::non_vectorial_image<I>& input,
@@ -74,25 +89,20 @@
}
-/*=processing internal_gradient
- * ns: morpho, morpho::fast
- * what: Morphological Internal Gradient.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute the arithmetic difference between the original image \var{input} and
- * the erosion of \var{input} using \var{se} as structural element. Soille, p67.
- * see: morpho::beucher_gradient
- * see: morpho::external_gradient
- * see: morpho::erosion
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::internal_gradient(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Process a morphological internal gradient.
+**
+** \return The internal gradient of the input.
+**
+**
+** \arg c Conversion functor.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** Compute the arithmetic difference between the original image input and
+** the erosion of input using se as structural element. Soille, p67.
+**
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
internal_gradient(const convert::abstract::conversion<C, B>& c,
@@ -102,13 +112,40 @@
return arith::minus(c, input, erosion(input, se));
}
-/*=processingoverload internal_gradient
- * ns: morpho, morpho::fast
- * what: Morphological Internal Gradient.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
-=*/
+/*!
+** \brief Process a morphological internal gradient.
+**
+** \param I Exact type of the input image.
+** \param E Exact type of the structuring element.
+**
+** \return The internal gradient of the input.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/gradient.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** save(oln::morpho::internal_gradient(im1, oln::win_c8p()),
+** IMG_OUT "oln_morpho_internal_gradient.pbm");
+** return 0;
+** }
+** \encode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_internal_gradient.png
+** \image latex oln_morpho_internal_gradient.png
+*/
template<class I, class E>
oln_concrete_type(I)
internal_gradient(const abstract::non_vectorial_image<I>& input, const
@@ -117,26 +154,17 @@
return internal_gradient(convert::force<oln_value_type(I)>(), input, se);
}
-/*=processing external_gradient
- * ns: morpho, morpho::fast
- * what: Morphological External Gradient.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute the arithmetic difference between and the dilatation of
- * \var{input} using \var{se} as structural element, and the original image
- * \var{input}. Soille, p67.
- * see: morpho::beucher_gradient
- * see: morpho::internal_gradient
- * see: morpho::dilation
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::external_gradient(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Process a morphological external gradient.
+**
+** Compute the arithmetic difference between and the dilatation of
+** input using se as structural element, and the original image
+** input. Soille, p67.
+**
+** \arg c Conversion functor.
+** \arg input Image to process.
+** \arg se Structuring element.
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
external_gradient(const convert::abstract::conversion<C, B>& c,
@@ -147,13 +175,40 @@
}
-/*=processingoverload external_gradient
- * ns: morpho, morpho::fast
- * what: Morphological External Gradient.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
-=*/
+/*!
+** \brief Process morphological external gradient.
+**
+** \param I Exact type of the input image.
+** \param E Exact type of the structuring element.
+**
+** \return The external gradient of the input.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/gradient.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** save(oln::morpho::internal_gradient(im1, oln::win_c8p()),
+** IMG_OUT "oln_morpho_external_gradient.pbm");
+** return 0;
+** }
+** \encode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_external_gradient.png
+** \image latex oln_morpho_external_gradient.png
+*/
template<class I, class E>
oln_concrete_type(I)
external_gradient(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/hit_or_miss.inc
--- olena/oln/morpho/hit_or_miss.inc Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/42_hit_or_mis 1.20 600)
+++ olena/oln/morpho/hit_or_miss.inc Thu, 11 Mar 2004 17:32:46 +0100 palma_g (oln/42_hit_or_mis 1.20 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2001, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -30,36 +30,54 @@
// note that results depend on the type of image data when it is not bin.
// you MUST be aware of it.
-/*=processing hit_or_miss
- * ns: morpho, morpho::fast
- * what: Hit_or_Miss Transform.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute the hit_or_miss transform of \var{input} by the composite structural
- * element (\var{se1}, \var{se2}). Soille p.131.
- *
- * By definition \var{se1} and \var{se2} must have the same origin, and need to
- * be disjoint. This algorithm has been extended to every data types
- * (althought it is not increasing). Beware the result depends upon the
- * image data type if it is not \code{bin}.
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * $ window2d mywin;
- * $ mywin
- * $ .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
- * $ .add(-2,-1).add(-2,0).add(-2,1)
- * $ .add(-1,0);
- * $ window2d mywin2 = - mywin;
- * $ save(morpho::fast::hit_or_miss(convert::bound<int_u8>(),
- * $ im, mywin, mywin2), "out.pgm");
- * exh: convert/bound.hh
- * exi: object.pbm
- * exo: out.pgm
-=*/
+/*!
+** \brief Preform a 'hit or miss' transform.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** Compute the hit_or_miss transform of input by the composite structuring
+** element (se1, se2). Soille p.131.\n
+**
+** By definition se1 and se2 must have the same origin, and need to
+** be disjoint. This algorithm has been extended to every data types
+** (although it is not increasing). Beware the result depends upon the
+** image data type if it is not bin.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss(oln::convert::bound<ntg::int_u8>(), im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss.png
+** \image latex oln_morpho_fast_hit_or_miss.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class C, class B, class I, class E1, class E2>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
hit_or_miss(const convert::abstract::conversion<C, B>& c,
@@ -81,13 +99,49 @@
erosion(level::invert(input), se2));
}
-/*=processingoverload hit_or_miss
- * ns: morpho, morpho::fast
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret:oln_concrete_type(I)
-=*/
+/*!
+** \brief Preform a 'hit or miss' transform.
+**
+** \param I Exact type of the input image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss(im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss_overload.png
+** \image latex oln_morpho_fast_hit_or_miss_overload.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
hit_or_miss(const abstract::non_vectorial_image<I>& input,
@@ -103,37 +157,57 @@
//
///////////////////////////////////
-/*=processing hit_or_miss_opening
- * ns: morpho, morpho::fast
- * what: Hit_or_Miss opening.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the hit_or_miss opening of \var{input} by the composite structural
- * element (\var{se1}, \var{se2}). Soille p.134.
- *
- * By definition \var{se1} and \var{se2} must have the same origin, and need to
- * be disjoint. This algorithm has been extended to every data types
- * (althought it is not increasing). Beware the result depends upon the
- * image data type if it is not \code{bin}.
- * see: morpho::hit_or_miss
- * see: morpho::hit_or_miss_closing
- * see: morpho::hit_or_miss_closing_bg
- * see: morpho::hit_or_miss_opening_bg
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * window2d mywin;
- * mywin
- * .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
- * .add(-2,-1).add(-2,0).add(-2,1)
- * .add(-1,0);
- * window2d mywin2 = - mywin;
- * $ save(morpho::hit_or_miss_opening(im, mywin, mywin2), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
-=*/
+/*!
+** \brief Perform an hit or miss opening.
+**
+** Compute the hit_or_miss opening of input by the composite structuring
+** element (se1, se2). Soille p.134.\n
+**
+** By definition se1 and se2 must have the same origin, and need to
+** be disjoint. This algorithm has been extended to every data types
+** (althought it is not increasing). Beware the result depends upon the
+** image data type if it is not bin.
+**
+** \param I Exact type of the input image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss_opening(im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss_opening.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss_opening.png
+** \image latex oln_morpho_fast_hit_or_miss_opening.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
hit_or_miss_opening(const abstract::non_vectorial_image<I>& input,
@@ -145,38 +219,57 @@
return dilation(hit_or_miss(input, se1, se2), -se1);
}
-/*=processing hit_or_miss_opening_bg
- * ns: morpho, morpho::fast
- * what: Hit_or_Miss opening of background.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the hit_or_miss opening of the background of
- * \var{input} by the composite structural
- * element (\var{se1}, \var{se2}). Soille p.135.
- *
- * By definition \var{se1} and \var{se2} must have the same origin, and need to
- * be disjoint. This algorithm has been extended to every data types
- * (althought it is not increasing). Beware the result depends upon the
- * image data type if it is not \code{bin}.
- * see: morpho::hit_or_miss
- * see: morpho::hit_or_miss_closing
- * see: morpho::hit_or_miss_closing_bg
- * see: morpho::hit_or_miss_opening
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * window2d mywin;
- * mywin
- * .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
- * .add(-2,-1).add(-2,0).add(-2,1)
- * .add(-1,0);
- * window2d mywin2 = - mywin;
- * $ save(morpho::hit_or_miss_opening_bg(im, mywin, mywin2), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
-=*/
+/*!
+** \brief Perform an hit or miss opening of background.
+**
+** Compute the hit_or_miss opening of the background of input by the
+** composite structuring element (se1, se2). Soille p.135.\n
+**
+** By definition se1 and se2 must have the same origin, and need to be
+** disjoint. This algorithm has been extended to every data types
+** (although it is not increasing). Beware the result depends upon
+** the image data type if it is not bin.
+**
+** \param I Exact type of the input image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss_opening_bg(im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss_opening_bg.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss_opening_bg.png
+** \image latex oln_morpho_fast_hit_or_miss_opening_bg.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
hit_or_miss_opening_bg(const abstract::non_vectorial_image<I>& input,
@@ -192,39 +285,59 @@
//
///////////////////////////////////
-/*=processing hit_or_miss_closing
- * ns: morpho, morpho::fast
- * what: Hit_or_Miss closing.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the hit_or_miss closing of \var{input} by the composite structural
- * element (\var{se1}, \var{se2}). This is the dual transformation of hit-or-miss opening
- * with respect to
- * set complementation. Soille p.135.
- *
- * By definition \var{se1} and \var{se2} must have the same origin, and need to
- * be disjoint. This algorithm has been extended to every data types
- * (althought it is not increasing). Beware the result depends upon the
- * image data type if it is not \code{bin}.
- * see: morpho::hit_or_miss
- * see: morpho::hit_or_miss_closing_bg
- * see: morpho::hit_or_miss_opening
- * see: morpho::hit_or_miss_opening_bg
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * window2d mywin;
- * mywin
- * .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
- * .add(-2,-1).add(-2,0).add(-2,1)
- * .add(-1,0);
- * window2d mywin2 = - mywin;
- * $ save(morpho::hit_or_miss_closing(im, mywin, mywin2), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
-=*/
+/*!
+** \brief Perform an hit or miss closing.
+**
+** Compute the hit_or_miss closing of input by the composite structuring
+** element (se1, se2). This is the dual transformation of hit-or-miss opening
+** with respect to
+** set complementation. Soille p.135.\n
+**
+** By definition se1 and se2 must have the same origin, and need to
+** be disjoint. This algorithm has been extended to every data types
+** (althought it is not increasing). Beware the result depends upon the
+** image data type if it is not bin.
+**
+** \param I Exact type of the input image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss_closing(im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss_closing.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss_closing.png
+** \image latex oln_morpho_fast_hit_or_miss_closing.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
hit_or_miss_closing(const abstract::non_vectorial_image<I>& input,
@@ -237,39 +350,59 @@
se1, se2));
}
-/*=processing hit_or_miss_closing_bg
- * ns: morpho, morpho::fast
- * what: Hit_or_Miss closing of background.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se1, IN, structural element
- * arg: const abstract::struct_elt<E>&, se2, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the hit_or_miss closing of the background of \var{input} by the composite structural
- * element (\var{se1}, \var{se2}). This is the dual transformation of hit-or-miss opening
- * with respect to
- * set complementation. Soille p.135.
- *
- * By definition \var{se1} and \var{se2} must have the same origin, and need to
- * be disjoint. This algorithm has been extended to every data types
- * (althought it is not increasing). Beware the result depends upon the
- * image data type if it is not \code{bin}.
- * see: morpho::hit_or_miss
- * see: morpho::hit_or_miss_closing
- * see: morpho::hit_or_miss_opening
- * see: morpho::hit_or_miss_opening_bg
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * window2d mywin;
- * mywin
- * .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
- * .add(-2,-1).add(-2,0).add(-2,1)
- * .add(-1,0);
- * window2d mywin2 = - mywin;
- * $ save(morpho::hit_or_miss_closing_bg(im, mywin, mywin2), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
-=*/
+/*!
+** \brief Perform an hit or miss closing of background.
+**
+** Compute the hit_or_miss closing of the background of input by the
+** composite structuring element (se1, se2). This is the dual
+** transformation of hit-or-miss opening with respect to set
+** complementation. Soille p.135.\n
+**
+** By definition se1 and se2 must have the same origin, and need to
+** be disjoint. This algorithm has been extended to every data types
+** (althought it is not increasing). Beware the result depends upon the
+** image data type if it is not bin.
+**
+** \param I Exact type of the input image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/hit_or_miss.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im1(oln::load(IMG_IN "object.pbm"));
+**
+** oln::window2d mywin;
+** mywin
+** .add(-3,-2).add(-3,-1).add(-3,0).add(-3,1).add(-3,2)
+** .add(-2,-1).add(-2,0).add(-2,1)
+** .add(-1,0);
+** oln::window2d mywin2 = - mywin;
+**
+** oln::save(oln::morpho::hit_or_miss_closing_bg(im1, mywin, mywin2),
+** IMG_OUT "oln_morpho_fast_hit_or_miss_closing_bg.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_hit_or_miss_closing_bg.png
+** \image latex oln_morpho_fast_hit_or_miss_closing_bg.png
+**
+** \todo FIXME: Histogram problems (fast version do not work).
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
hit_or_miss_closing_bg(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/laplacian.inc
--- olena/oln/morpho/laplacian.inc Thu, 07 Aug 2003 02:08:21 +0200 david (oln/41_laplacian. 1.13 600)
+++ olena/oln/morpho/laplacian.inc Fri, 12 Mar 2004 11:23:14 +0100 palma_g (oln/41_laplacian. 1.13 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2001 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 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
@@ -26,25 +26,40 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-/*=processing laplacian
- * ns: morpho, morpho::fast
- * what: Laplacian.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute the laplacian of \var{input} using \var{se}
- * as structural element.
- * see: morpho::dilation
- * see: morpho::erosion
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::laplacian(convert::bound<int_u8>(), im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
- * exh: convert/bound.hh
-=*/
+/*!
+** \brief Compute the laplacian of an image.
+**
+** Compute the laplacian of input using se as structural element.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/laplacian.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::laplacian(oln::convert::bound<ntg::int_u8>(),
+** im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_laplacian.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_laplacian.png
+** \image latex oln_morpho_fast_laplacian.png
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
laplacian(const convert::abstract::conversion<C, B>& c,
@@ -56,13 +71,39 @@
arith::minus(input, erosion(input, se)));
}
-/*=processingoverload laplacian
- * ns: morpho, morpho::fast
- * what: Laplacian.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I,oln_value_type(I)::slarger_t>::ret
-=*/
+/*!
+** \brief Compute the laplacian of an image.
+**
+** Compute the laplacian of input using se as structural element.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/laplacian.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::laplacian(oln::convert::bound<ntg::int_u8>(), im1, oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_laplacian_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_laplacian_overload.png
+** \image latex oln_morpho_fast_laplacian_overload.png
+**
+** \todo FIXME: Call the good laplacian, and correct slarger_t type.
+*/
template<class I, class E>
typename mute<I,oln_value_type(I)::slarger_t>::ret
laplacian(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/minmax.hh
--- olena/oln/morpho/minmax.hh Thu, 31 Jul 2003 18:08:39 +0200 burrus_n (oln/b/0_minmax.hh 1.5 600)
+++ olena/oln/morpho/minmax.hh Fri, 12 Mar 2004 13:19:34 +0100 palma_g (oln/b/0_minmax.hh 1.5 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -34,20 +34,20 @@
namespace oln {
namespace morpho {
- /*
- Before olena v0.6, bin type was represented by "true" and
- "false", so it did not make sense to implement a min and max for
- it. However, morphological operatators defined on binary image
- usually needs min and max operators, this is why it was previouly
- implemented here.
-
- But since v0.6 and higher, bin type is represented by '0' and
- '1', so it has min and max operators. Thus arith::min and
- arith::max should be used instead of obsolete these morpho::min
- and morpho::max.
-
- These operators are kept here for compatibility with older
- versions.
+ /*!
+ ** Before olena v0.6, bin type was represented by "true" and
+ ** "false", so it did not make sense to implement a min and max for
+ ** it. However, morphological operatators defined on binary image
+ ** usually needs min and max operators, this is why it was previouly
+ ** implemented here.\n
+ **
+ ** But since v0.6 and higher, bin type is represented by '0' and
+ ** '1', so it has min and max operators. Thus arith::min and
+ ** arith::max should be used instead of obsolete these morpho::min
+ ** and morpho::max.\n
+ **
+ ** These operators are kept here for compatibility with older
+ ** versions.
*/
using arith::min;
Index: olena/oln/morpho/opening.inc
--- olena/oln/morpho/opening.inc Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/40_opening.in 1.13 600)
+++ olena/oln/morpho/opening.inc Thu, 11 Mar 2004 19:29:17 +0100 palma_g (oln/40_opening.in 1.13 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2001, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -26,24 +26,43 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-/*=processing opening
- * ns: morpho, morpho::fast
- * what: Morphological opening.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
- * doc:
- * Compute the morphological opening of \var{input} using \var{se}
- * as structural element.
- * see: morpho::erosion
- * see: morpho::dilation
- * see: morpho::closing
- * ex:
- * $ image2d<ntg::bin> im = load("object.pbm");
- * $ save(morpho::opening(im, win_c8p()), "out.pbm");
- * exi: object.pbm
- * exo: out.pbm
-=*/
+/*!
+** \brief Perform a morphological opening.
+**
+** Compute the morphological opening of input using se as
+** structuring element.
+**
+** \param I Exact type of the input image.
+** \param E Exact type of the structuring element.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/opening.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::bin> im_type;
+**
+** im_type im(oln::load(IMG_IN "object.pbm"));
+**
+** oln::save(oln::morpho::opening(im, oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_opening.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html object.png
+** \image latex object.png
+** =>
+** \image html oln_morpho_fast_opening.png
+** \image latex oln_morpho_fast_opening.png
+**
+** \todo FIXME: Histogram problems (fast version do not compile).
+*/
template<class I, class E>
oln_concrete_type(I)
opening(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/reconstruction.hh
--- olena/oln/morpho/reconstruction.hh Wed, 08 Oct 2003 23:36:51 +0200 burrus_n (oln/35_reconstruc 1.13.1.11 600)
+++ olena/oln/morpho/reconstruction.hh Thu, 11 Mar 2004 21:01:45 +0100 palma_g (oln/35_reconstruc 1.13.1.11 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -43,27 +43,54 @@
namespace oln {
namespace morpho {
namespace sure {
- /*=processing sure_geodesic_reconstruction_dilation
- * ns: morpho
- * what: Geodesic reconstruction by dilation.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by dilation of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. This is the simplest algorithm:
- * iteration is performed until stability.
- * see: morpho::simple_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::sure_geodesic_reconstruction_dilation(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Perform a geodesic reconstruction dilation.
+ **
+ ** Compute the reconstruction by dilation of marker with respect
+ ** to the mask mask image using se as structuring
+ ** element. Soille p.160. This is the simplest algorithm:
+ ** iteration is performed until stability.
+ **
+ ** \warning This version is slow, since it is a sure one.
+ **
+ ** \pre Mask must be greater or equal than marker.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::sure::geodesic_reconstruction_dilation(im2,
+ ** im1,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sure_geodesic_reconstruction_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sure_geodesic_reconstruction_dilation.png
+ ** \image latex oln_morpho_sure_geodesic_reconstruction_dilation.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_dilation(const abstract::non_vectorial_image<I1> & marker,
@@ -88,30 +115,54 @@
namespace sequential {
- /*=processing sequential_geodesic_reconstruction_dilation
- * ns: morpho
- * what: Geodesic reconstruction by dilation.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by dilation of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. The algorithm used is the
- * one defined as sequential
- * in Vincent(1993), Morphological grayscale reconstruction in
- * image analysis: applications and efficient algorithms, itip, 2(2),
- * 176--201.
- * see: morpho::simple_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::sequential_geodesic_reconstruction_dilation(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Perform a geodesic reconstruction dilation.
+ **
+ ** Compute the reconstruction by dilation of marker with respect
+ ** to the mask image using se as structuring element. Soille
+ ** p.160. The algorithm used is the one defined as sequential in
+ ** Vincent(1993), Morphological grayscale reconstruction in
+ ** image analysis: applications and efficient algorithms, itip,
+ ** 2(2), 176--201.
+ **
+ ** \pre Mask must be greater or equal than marker.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::sequential::geodesic_reconstruction_dilation(im2,
+ ** im1,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sequential_geodesic_reconstruction_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sequential_geodesic_reconstruction_dilation.png
+ ** \image latex oln_morpho_sequential_geodesic_reconstruction_dilation.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_dilation(const abstract::non_vectorial_image<I1> & marker,
@@ -152,6 +203,14 @@
namespace internal {
+ /*!
+ ** \brief Check if it exists initialization for dilation.
+ **
+ ** \arg p Point to consider.
+ ** \arg marker Image to work on.
+ ** \arg mask Image used as mask.
+ ** \arg Ng Neighborhood to use.
+ */
template<class P, class I1, class I2, class E> inline
static bool
exist_init_dilation(const abstract::point<P>& p,
@@ -172,30 +231,54 @@
} //internal
- /*=processing hybrid_geodesic_reconstruction_dilation
- * ns: morpho
- * what: Geodesic reconstruction by dilation.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by dilation of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. The algorithm used is the
- * one defined as hybrid
- * in Vincent(1993), Morphological grayscale reconstruction in
- * image analysis: applications and efficient algorithms, itip, 2(2),
- * 176--201.
- * see: morpho::simple_geodesic_dilation
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::hybrid_geodesic_reconstruction_dilation(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+ /*!
+ ** \brief Perform a geodesic reconstruction dilation.
+ **
+ ** Compute the reconstruction by dilation of marker with
+ ** respect to the mask image using se as structuring
+ ** element. Soille p.160. The algorithm used is the one defined
+ ** as hybrid in Vincent(1993), Morphological grayscale
+ ** reconstruction in image analysis: applications and efficient
+ ** algorithms, itip, 2(2), 176--201.
+ **
+ ** \pre Mask must be greater or equal than marker.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic dilation.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::hybrid::geodesic_reconstruction_dilation(im2,
+ ** im1,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_hybrid_geodesic_reconstruction_dilation.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_hybrid_geodesic_reconstruction_dilation.png
+ ** \image latex oln_morpho_hybrid_geodesic_reconstruction_dilation.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_dilation(const abstract::non_vectorial_image<I1> & marker,
@@ -252,27 +335,55 @@
//GEODESIC RECONSTRUCTION EROSION
namespace sure {
- /*=processing sure_geodesic_reconstruction_erosion
- * ns: morpho
- * what: Geodesic reconstruction by erosion.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by erosion of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. This is the simplest algorithm :
- * iteration is performed until stability.
- * see: morpho::simple_geodesic_erosion
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::sure_geodesic_reconstruction_erosion(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+
+ /*!
+ ** \brief Perform a geodesic reconstruction erosion.
+ **
+ ** Compute the reconstruction by erosion of marker with respect
+ ** to the mask image using se as structuring element. Soille
+ ** p.160. This is the simplest algorithm: iteration is performed
+ ** until stability.
+ **
+ ** \warning This version is slow, since it is a sure one.
+ **
+ ** \pre Marker must be greater or equal than mask.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic erosion.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::sure::geodesic_reconstruction_erosion(im1,
+ ** im2,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sure_geodesic_reconstruction_erosion.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sure_geodesic_reconstruction_erosion.png
+ ** \image latex oln_morpho_sure_geodesic_reconstruction_erosion.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_erosion(const abstract::non_vectorial_image<I1> & marker,
@@ -297,30 +408,55 @@
namespace sequential {
- /*=processing sequential_geodesic_reconstruction_erosion
- * ns: morpho
- * what: Geodesic reconstruction by erosion.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by erosion of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. The algorithm used is the
- * one defined as sequential
- * in Vincent(1993), Morphological grayscale reconstruction in
- * image analysis: applications and efficient algorithms, itip, 2(2),
- * 176--201.
- * see: morpho::simple_geodesic_erosion
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::sequential_geodesic_reconstruction_erosion(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
+
+ /*!
+ ** \brief Perform a geodesic reconstruction erosion.
+ **
+ ** Compute the reconstruction by erosion of marker with respect
+ ** to the mask image using se as structuring element. Soille
+ ** p.160. The algorithm used is the one defined as sequential
+ ** in Vincent(1993), Morphological grayscale reconstruction in
+ ** image analysis: applications and efficient algorithms, itip,
+ ** 2(2), 176--201.
+ **
+ ** \pre Marker must be greater or equal than mask.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic erosion.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::sequential::geodesic_reconstruction_erosion(im1,
+ ** im2,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_sequential_geodesic_reconstruction_erosion.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_sequential_geodesic_reconstruction_erosion.png
+ ** \image latex oln_morpho_sequential_geodesic_reconstruction_erosion.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_erosion(const abstract::non_vectorial_image<I1>& marker,
@@ -358,6 +494,14 @@
namespace hybrid {
namespace internal {
+ /*!
+ ** \brief Check if it exists initialization for erosion.
+ **
+ ** \arg p Point to consider.
+ ** \arg marker Image to work on.
+ ** \arg mask Image used as mask.
+ ** \arg Ng Neighborhood to use.
+ */
template<class P, class I1, class I2, class E> inline
static bool
exist_init_erosion(const abstract::point<P>& p,
@@ -377,31 +521,54 @@
}
} // internal
- /*=processing hybrid_geodesic_reconstruction_erosion
- * ns: morpho
- * what: Geodesic reconstruction by erosion.
- * arg: const abstract::non_vectorial_image<I1>&, marker, IN, marker image
- * arg: const abstract::non_vectorial_image<I2>&, mask, IN, mask image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I1)
- * doc:
- * Compute the reconstruction by erosion of \var{marker} with respect
- * to the mask \var{mask} image using \var{se}
- * as structural element. Soille p.160. The algorithm used is the
- * one defined as hybrid
- * in Vincent(1993), Morphological grayscale reconstruction in
- * image analysis: applications and efficient algorithms, itip, 2(2),
- * 176--201.
- * see: morpho::simple_geodesic_erosion
- * ex:
- * $ image2d<int_u8> light = load("light.pgm");
- * $ image2d<int_u8> dark = load("dark.pgm");
- * $ save(morpho::sequential_geodesic_reconstruction_erosion(light, dark, win_c8p()), "out.pgm");
- * exi: light.pgm dark.pgm
- * exo: out.pgm
- * wontcompile: fixme
- =*/
-
+ /*!
+ ** \brief Perform a geodesic reconstruction erosion.
+ **
+ ** Compute the reconstruction by erosion of marker with respect
+ ** to the mask mask image using se as structuring
+ ** element. Soille p.160. The algorithm used is the one defined
+ ** as hybrid in Vincent(1993), Morphological grayscale
+ ** reconstruction in image analysis: applications and efficient
+ ** algorithms, itip, 2(2), 176--201.
+ **
+ ** \pre Marker must be greater or equal than mask.
+ **
+ ** \param I1 Exact type of image marker.
+ ** \param I2 Exact type of image mask.
+ ** \param N Exact type of neighborhood.
+ **
+ ** \arg marker Image to work on.
+ ** \arg mask Image used for geodesic erosion.
+ ** \arg Ng Neighborhood to use.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/opening.hh>
+ ** #include <oln/morpho/reconstruction.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena128.pgm"));
+ ** im_type im2(oln::morpho::opening(im1, oln::win_c4p()));
+ **
+ ** oln::save(oln::morpho::hybrid::geodesic_reconstruction_erosion(im1,
+ ** im2,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_hybrid_geodesic_reconstruction_erosion.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena128.png
+ ** \image latex lena128.png
+ ** =>
+ ** \image html oln_morpho_hybrid_geodesic_reconstruction_erosion.png
+ ** \image latex oln_morpho_hybrid_geodesic_reconstruction_erosion.png
+ **
+ */
template<class I1, class I2, class N>
oln_concrete_type(I1)
geodesic_reconstruction_erosion(const abstract::non_vectorial_image<I1> & marker,
Index: olena/oln/morpho/splitse.hh
--- olena/oln/morpho/splitse.hh Thu, 07 Aug 2003 02:08:21 +0200 david (oln/34_splitse.hh 1.7 600)
+++ olena/oln/morpho/splitse.hh Thu, 11 Mar 2004 21:38:23 +0100 palma_g (oln/34_splitse.hh 1.7 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 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
@@ -33,6 +33,18 @@
namespace oln {
namespace morpho {
+ /*!
+ ** \brief Get a sub part of a structuring element.
+ **
+ ** \param E Exact type of the structuring element.
+ **
+ ** \arg se The structuring element.
+ **
+ ** A point p take part of the new structuring element if it exists
+ ** a i that belongs to [[0..dim-1]] like p(i) < 0 and for all j
+ ** that belongs to [[0..i-1]] p(j) = 0.
+ **
+ */
template<class E>
mlc_exact_type(E)
get_plus_se_only(const abstract::struct_elt<E>& se)
@@ -54,6 +66,19 @@
return out;
}
+ /*!
+ ** \brief Get a sub part of a structuring element.
+ **
+ ** \param E Exact type of the structuring element.
+ **
+ ** \arg se The structuring element.
+ **
+ ** A point p take part of the new structuring element if it exists
+ ** a i that belongs to [[0..dim-1]] like p(i) < 0 and for all j
+ ** that belongs to [[0..i-1]] p(j) = 0 or if for all i that
+ ** belongs to [[0..dim-1]] p(i) = 0.
+ **
+ */
template<class E>
mlc_exact_type(E)
get_plus_se_p(const abstract::struct_elt<E>& se)
@@ -78,6 +103,18 @@
return out;
}
+ /*!
+ ** \brief Get a sub part of a structuring element.
+ **
+ ** \param E Exact type of the structuring element.
+ **
+ ** \arg se The structuring element.
+ **
+ ** A point p take part of the new structuring element if it exists
+ ** a i that belongs to [[0..dim-1]] like p(i) > 0 and for all j
+ ** that belongs to [[0..i-1]] p(j) = 0.
+ **
+ */
template<class E>
mlc_exact_type(E)
get_minus_se_only(const abstract::struct_elt<E>& se)
@@ -99,6 +136,19 @@
return out;
}
+ /*!
+ ** \brief Get a sub part of a structuring element.
+ **
+ ** \param E Exact type of the structuring element.
+ **
+ ** \arg se The structuring element.
+ **
+ ** A point p take part of the new structuring element if it exists
+ ** a i that belongs to [[0..dim-1]] like p(i) > 0 and for all j
+ ** that belongs to [[0..i-1]] p(j) = 0 or if for all i that
+ ** belongs to [[0..dim-1]] p(i) = 0.
+ **
+ */
template<class E>
mlc_exact_type(E)
get_minus_se_p(const abstract::struct_elt<E>& se)
Index: olena/oln/morpho/stat.hh
--- olena/oln/morpho/stat.hh Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/50_stat.hh 1.8.1.11 600)
+++ olena/oln/morpho/stat.hh Fri, 12 Mar 2004 11:04:47 +0100 palma_g (oln/50_stat.hh 1.8.1.11 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -37,12 +37,29 @@
namespace internal {
- /* We need to use this inner definition in order to specialize
- max and min on binary images. */
-
+ /*!
+ ** \brief Min and Max on a structuring element.
+ **
+ ** We need to use this inner definition in order to specialize
+ ** max and min on binary images.
+ **
+ ** \param I Image exact type.
+ ** \param E Structuring element type.
+ ** \param V Associated value type.
+ */
template <class I, class E, class V =oln_value_type(I)>
struct stat_
{
+ /*!
+ ** \brief Maximum of a structuring element.
+ **
+ ** Look for the maximum in the structuring element se disposed
+ ** on the image input, at the point p.
+ **
+ ** \arg input Input image.
+ ** \arg p Point of the image to move the structuring element on.
+ ** \arg se The structuring element to use.
+ */
static V
max(const I& input, const oln_point_type(I)& p, const E& se)
{
@@ -57,6 +74,16 @@
return val;
}
+ /*!
+ ** \brief Minimum of a structuring element.
+ **
+ ** Look for the minimum in the structuring element se disposed
+ ** on the image input, at the point p.
+ **
+ ** \arg input Input image.
+ ** \arg p Point of the image to move the structuring element on.
+ ** \arg se The structuring element to use.
+ */
static V
min(const I& input, const oln_point_type(I)& p, const E& se)
{
@@ -103,6 +130,19 @@
} // internal
+ /*!
+ ** \brief Maximum of a structuring element.
+ **
+ ** Look for the maximum in the structuring element se disposed
+ ** on the image input, at the point p.
+ **
+ ** \param I Image exact type.
+ ** \param E Structuring element type.
+ **
+ ** \arg input Input image.
+ ** \arg p Point of the image to move the structuring element on.
+ ** \arg se The structuring element to use.
+ */
template<class I, class E>
oln_value_type(I)
max(const abstract::non_vectorial_image<I>& input,
@@ -113,6 +153,18 @@
return internal::stat_<I, E>::max(input.exact(), p, se.exact());
}
+ /*! ** \brief Minimum of a structuring element.
+ **
+ ** Look for the minimum in the structuring element se disposed
+ ** on the image input, at the point p.
+ **
+ ** \param I Image exact type.
+ ** \param E Structuring element type.
+ **
+ ** \arg input Input image.
+ ** \arg p Point of the image to move the structuring element on.
+ ** \arg se The structuring element to use.
+ */
template<class I, class E>
oln_value_type(I)
min(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/thickening.inc
--- olena/oln/morpho/thickening.inc Thu, 07 Aug 2003 02:08:21 +0200 david (oln/e/28_thickening 1.10 600)
+++ olena/oln/morpho/thickening.inc Fri, 12 Mar 2004 11:12:52 +0100 palma_g (oln/e/28_thickening 1.10 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2002 EPITA Research and Development Laboratory
+// Copyright (C) 2002, 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
@@ -26,7 +26,43 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-
+/*!
+** \brief Thicken an image.
+**
+** \param I Exact type of the image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/thickening.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::thickening(im1,
+** oln::win_c8p(),
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_thickening.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_thickening.png
+** \image latex oln_morpho_fast_thickening.png
+**
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
thickening(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/thinning.inc
--- olena/oln/morpho/thinning.inc Thu, 07 Aug 2003 02:08:21 +0200 david (oln/e/26_thinning.i 1.11 600)
+++ olena/oln/morpho/thinning.inc Fri, 12 Mar 2004 11:15:59 +0100 palma_g (oln/e/26_thinning.i 1.11 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -26,7 +26,43 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-
+/*!
+** \brief Thin an image.
+**
+** \param I Exact type of the image.
+** \param E1 Exact type of the first structuring element.
+** \param E2 Exact type of the second structuring element.
+**
+** \arg input Image to process.
+** \arg se1 First structuring element.
+** \arg se2 Second structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/thinning.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::thinning(im1,
+** oln::win_c8p(),
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_thinning.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_thinning.png
+** \image latex oln_morpho_fast_thinning.png
+**
+*/
template<class I, class E1, class E2>
oln_concrete_type(I)
thinning(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/top_hat.inc
--- olena/oln/morpho/top_hat.inc Thu, 07 Aug 2003 02:08:21 +0200 david (oln/39_top_hat.in 1.13 600)
+++ olena/oln/morpho/top_hat.inc Fri, 12 Mar 2004 12:08:33 +0100 palma_g (oln/39_top_hat.in 1.13 640)
@@ -1,5 +1,5 @@
// -*- c++ -*-
-// Copyright (C) 2002 EPITA Research and Development Laboratory
+// Copyright (C) 2002, 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
@@ -27,24 +27,41 @@
// Public License.
-
-/*=processing white_top_hat
- * ns: morpho, morpho::fast
- * what: White top hat.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute white top hat of \var{input} using \var{se}
- * as structural element. Soille p.105.
- * see: morpho::opening
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::white_top_hat(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Compute the white top hat of an image.
+**
+** Compute white top hat of input using se as structuring
+** element. Soille p.105.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::white_top_hat(oln::convert::bound<ntg::int_u8>(),
+** im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_white_top_hat.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_white_top_hat.png
+** \image latex oln_morpho_fast_white_top_hat.png
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
white_top_hat(const convert::abstract::conversion<C, B>& c,
@@ -54,13 +71,39 @@
return arith::minus(c, input, opening(input, se));
}
-/*=processingoverload white_top_hat
- * ns: morpho, morpho::fast
- * what: White top hat.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret:oln_concrete_type(I)
-=*/
+/*!
+** \brief Compute the white top hat of an image.
+**
+** \param I Exact type of the image.
+** \param E Exact type of the structuring element.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::white_top_hat(im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_white_top_hat_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_white_top_hat_overload.png
+** \image latex oln_morpho_fast_white_top_hat_overload.png
+*/
template<class I, class E>
oln_concrete_type(I)
white_top_hat(const abstract::non_vectorial_image<I>& input,
@@ -72,23 +115,41 @@
// black top-hat
-/*=processing black_top_hat
- * ns: morpho, morpho::fast
- * what: Black top hat.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute black top hat of \var{input} using \var{se}
- * as structural element. Soille p.105.
- * see: morpho::closing
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::black_top_hat(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Compute the black top hat of an image.
+**
+** Compute black top hat of input using se as structuring
+** element. Soille p.105.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::black_top_hat(oln::convert::bound<ntg::int_u8>(),
+** im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_black_top_hat.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_black_top_hat.png
+** \image latex oln_morpho_fast_black_top_hat.png
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
black_top_hat(const convert::abstract::conversion<C, B>& c,
@@ -99,13 +160,39 @@
}
-/*=processingoverload balck_top_hat
- * ns: morpho, morpho::fast
- * what: Black top hat.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
-=*/
+/*!
+** \brief Compute the black top hat of an image.
+**
+** \param I Exact type of the image.
+** \param E Exact type of the structuring element.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::black_top_hat(im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_black_top_hat_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_black_top_hat_overload.png
+** \image latex oln_morpho_fast_black_top_hat_overload.png
+*/
template<class I, class E>
oln_concrete_type(I)
black_top_hat(const abstract::non_vectorial_image<I>& input,
@@ -120,25 +207,42 @@
// = (input - opening) + (closing - input)
// = closing - opening
-/*=processing self_complementary_top_hat
- * ns: morpho, morpho::fast
- * what: Self complementary top hat.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Compute self complementary top hat of \var{input} using \var{se}
- * as structural element. Soille p.106.
- * see: morpho::closing
- * see: morpho::opening
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::self_complementary_top_hat(im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
-=*/
+/*!
+** \brief Compute the self complementary top hat of an image.
+**
+** Compute self complementary top hat of input using se as structuring
+** element. Soille p.106.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::self_complementary_top_hat(oln::convert::bound<ntg::int_u8>(),
+** im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_self_complementary_top_hat.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_self_complementary_top_hat.png
+** \image latex oln_morpho_fast_self_complementary_top_hat.png
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
self_complementary_top_hat(const convert::abstract::conversion<C, B>& c,
@@ -148,13 +252,38 @@
return arith::minus(c, closing(input, se), opening(input, se));
}
-/*=processingoverload self_complementary_top_hat
- * ns: morpho, morpho::fast
- * what: Self complementary top hat.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
-=*/
+/*!
+** \brief Compute the self complementary top hat of an image.
+**
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::self_complementary_top_hat(im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_self_complementary_top_hat_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_self_complementary_top_hat_overload.png
+** \image latex oln_morpho_fast_self_complementary_top_hat_overload.png
+*/
template<class I, class E>
oln_concrete_type(I)
self_complementary_top_hat(const abstract::non_vectorial_image<I>& input,
@@ -166,28 +295,43 @@
// top-hat contrast operator
-/*=processing top_hat_contrast_op
- * ns: morpho, morpho::fast
- * what: Top hat contrastor operator.
- * arg: const convert::abstract::conversion<C, B>&, c, IN, conversion object
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
- * doc:
- * Enhance contrast \var{input} by adding the white top hat, then
- * substracting the black top hat to \var{input}. Top hats are computed using
- * \var{se} as structural element. Soille p.109.
- * see: morpho::white_top_hat
- * see: morpho::black_top_hat
- * ex:
- * $ image2d<int_u8> im = load("lena256.pgm");
- * $ save(morpho::top_hat_contrast_op(convert::bound<int_u8>(),
- * im, win_c8p()), "out.pgm");
- * exi: lena256.pgm
- * exo: out.pgm
- * exh: convert/bound.hh
-=*/
+/*!
+** \brief Top hat contrast operator.
+**
+** Enhance contrast input by adding the white top hat, then
+** subtracting the black top hat to input. Top hats are computed using
+** se as structuring element. Soille p.109.
+**
+** \arg c Conversion object.
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** oln::save(oln::morpho::fast::top_hat_contrast_op(oln::convert::bound<ntg::int_u8>(),
+** im1,
+** oln::win_c8p()),
+** IMG_OUT "oln_morpho_fast_top_hat_contrast_op.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_top_hat_contrast_op.png
+** \image latex oln_morpho_fast_top_hat_contrast_op.png
+*/
template<class C, class B, class I, class E>
typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
top_hat_contrast_op(const convert::abstract::conversion<C, B>& c,
@@ -200,13 +344,44 @@
black_top_hat(input, se)));
}
-/*=processingoverload top_hat_contrast_op
- * ns: morpho, morpho::fast
- * what: Top hat contrastor operator.
- * arg: const abstract::non_vectorial_image<I>&, input, IN, input image
- * arg: const abstract::struct_elt<E>&, se, IN, structural element
- * ret: typename mute<I, typename convoutput<C, B,oln_value_type(I)>::ret>::ret
-=*/
+
+/*!
+** \brief Top hat contrast operator.
+**
+** Enhance contrast input by adding the white top hat, then
+** subtracting the black top hat to input. Top hats are computed using
+** se as structuring element. Soille p.109.
+**
+** \arg input Image to process.
+** \arg se Structuring element.
+**
+** \code
+** #include <oln/basics2d.hh>
+** #include <oln/morpho/top_hat.hh>
+** #include <oln/level/compare.hh>
+** #include <ntg/all.hh>
+** int main()
+** {
+** typedef oln::image2d<ntg::int_u8> im_type;
+**
+** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+**
+** //oln::save(oln::morpho::fast::top_hat_contrast_op(im1,
+** // oln::win_c8p()),
+** // IMG_OUT "oln_morpho_fast_top_hat_contrast_op_overload.pbm");
+** oln::save(im1, IMG_OUT "oln_morpho_fast_top_hat_contrast_op_overload.pbm");
+** return 0;
+** }
+** \endcode
+**
+** \image html lena256.png
+** \image latex lena256.png
+** =>
+** \image html oln_morpho_fast_top_hat_contrast_op_overload.png
+** \image latex oln_morpho_fast_top_hat_contrast_op_overload.png
+**
+** \todo FIXME: Seems not to work with convert::force converter.
+*/
template<class I, class E>
oln_concrete_type(I)
top_hat_contrast_op(const abstract::non_vectorial_image<I>& input,
Index: olena/oln/morpho/watershed.hh
--- olena/oln/morpho/watershed.hh Sat, 27 Sep 2003 18:30:39 +0200 burrus_n (oln/48_watershed. 1.11 600)
+++ olena/oln/morpho/watershed.hh Fri, 12 Mar 2004 12:55:40 +0100 palma_g (oln/48_watershed. 1.11 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -34,95 +34,157 @@
namespace morpho {
- /*=processing watershed_seg
- * what: Segmented Watershed.
- * ns: morpho
- * tpl: class, DestValue, type of output labels
- * arg: const abstract::non_vectorial_image<I>&, im, IN, image of levels
- * arg: const abstract::neighborhood<N>&, ng, IN, neighborhood to consider
- * ret: typename mute<I, DestValue>::ret
- * doc:
- * Compute the segmented watershed for image \var{im} using
- * neighborhood \var{ng}.
- *
- * \code{watershed_seg} creates an ouput image whose values have
- * type \var{DestValue} (which should be discrete). In this output
- * image, \code{DestValue::max()} indicates a watershed, and all
- * basins are labeled using values from \code{DestValue::min()} to
- * \code{DestValue::max() - 4} (the remaining values are used internally
- * by the algorithm).
- *
- * When there are more basins than \code{DestValue} can hold,
- * wrapping occurs (i.e., the same label is used for several
- * basin).
- * ref:
- * This is based on the original algorithm
- * presented by Vincent and Soille. (FIXME: ref?)
- =*/
+ /*!
+ ** \brief Segmented watershed.
+ **
+ ** Compute the segmented watershed for image im using
+ ** neighborhood ng.\n
+ **
+ ** watershed_seg creates an ouput image whose values have type
+ ** DestValue (which should be discrete). In this output image,
+ ** DestValue::max() indicates a watershed, and all basins are
+ ** labeled using values from DestValue::min() to
+ ** DestValue::max() - 4 (the remaining values are used
+ ** internally by the algorithm).\n
+ **
+ ** When there are more basins than DestValue can hold, wrapping
+ ** occurs (i.e., the same label is used for several basin).
+ **
+ ** \ref This is based on the original algorithm presented by
+ ** Vincent and Soille. (FIXME: ref?)
+ **
+ ** \param DestValue Type of the data in output image.
+ ** \param I Exact type of the image.
+ ** \param N Exact type of the neighborhood.
+ **
+ ** \arg im_i Image of levels.
+ ** \arg Ng Neighborhood to consider.
+ **
+ ** \pre DestValue should be large enough.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/watershed.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+ **
+ ** oln::save(oln::morpho::watershed_seg<ntg::int_u16>(im1,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_watershed_seg.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena256.png
+ ** \image latex lena256.png
+ ** =>
+ ** \image html oln_morpho_watershed_seg.png
+ ** \image latex oln_morpho_watershed_seg.png
+ **
+ ** \todo Find a more pertinent example.
+ */
template<class DestValue, class I, class N>
typename mute<I, DestValue>::ret
watershed_seg(const abstract::non_vectorial_image<I>& im_i,
const abstract::neighborhood<N>& Ng);
- /*=processing watershed_con
- * what: Connected Watershed.
- * ns: morpho
- * tpl: class, DestValue, type of output labels
- * arg: const abstract::non_vectorial_image<I>&, im, IN, image of levels
- * arg: const abstract::neighborhood<N>&, ng, IN, neighborhood to consider
- * ret: typename mute<I, DestValue>::ret
- * doc:
- * Compute the connected watershed for image \var{im} using
- * neighborhood \var{ng}.
- *
- * \code{watershed_con} creates an ouput image whose values have
- * type \var{DestValue} (which should be discrete). In this output
- * all basins are labeled using values from \code{DestValue::min()} to
- * \code{DestValue::max() - 4} (the remaining values are used internally
- * by the algorithm).
- *
- * When there are more basins than \code{DestValue} can hold, wrapping
- * occurs (i.e., the same label is used for several basin). This is
- * potentially harmful, because if two connected basins are labeled
- * with the same value they will appear as one basin.
- * ref:
- * This is based on the original algorithm
- * presented by Vincent and Soille, but modified to not output
- * watersheds.
- =*/
+
+ /*!
+ ** \brief Connected watershed.
+ **
+ ** Compute the connected watershed for image im using
+ ** neighborhood ng.\n
+ **
+ ** watershed_con creates an ouput image whose values have
+ ** type DestValue (which should be discrete). In this output
+ ** all basins are labeled using values from DestValue::min() to
+ ** DestValue::max() - 4 (the remaining values are used internally
+ ** by the algorithm).\n
+ **
+ ** When there are more basins than DestValue can hold, wrapping
+ ** occurs (i.e., the same label is used for several basin). This is
+ ** potentially harmful, because if two connected basins are labeled
+ ** with the same value they will appear as one basin.\n
+ **
+ ** \ref This is based on the original algorithm
+ ** presented by Vincent and Soille, but modified to not output
+ ** watersheds.
+ **
+ ** \param DestValue Type of the data in output image.
+ ** \param I Exact type of the image.
+ ** \param N Exact type of the neighborhood.
+ **
+ ** \arg input Image of levels.
+ ** \arg Ng Neighborhood to consider.
+ **
+ ** \pre DestValue should be large enough.
+ **
+ ** \code
+ ** #include <oln/basics2d.hh>
+ ** #include <oln/morpho/watershed.hh>
+ ** #include <oln/level/compare.hh>
+ ** #include <ntg/all.hh>
+ ** int main()
+ ** {
+ ** typedef oln::image2d<ntg::int_u8> im_type;
+ **
+ ** im_type im1(oln::load(IMG_IN "lena256.pgm"));
+ **
+ ** oln::save(oln::morpho::watershed_con<ntg::int_u16>(im1,
+ ** oln::neighb_c4()),
+ ** IMG_OUT "oln_morpho_watershed_con.pbm");
+ ** return 0;
+ ** }
+ ** \endcode
+ **
+ ** \image html lena256.png
+ ** \image latex lena256.png
+ ** =>
+ ** \image html oln_morpho_watershed_con.png
+ ** \image latex oln_morpho_watershed_con.png
+ **
+ ** \todo Find a more pertinent example.
+ */
template<class DestValue, class I, class N>
typename mute<I, DestValue>::ret
watershed_con(const abstract::non_vectorial_image<I>& im_i, const abstract::neighborhood<N>& Ng);
- /*=processing watershed_seg_or
- * what: Segmented Watershed with user-supplied starting points.
- * ns: morpho
- * arg: const abstract::non_vectorial_image<I1>&, levels, IN, image of levels
- * arg: abstract::non_vectorial_image<I2>&, markers, INOUT, image of markers
- * arg: const abstract::neighborhood<N>&, ng, IN, neighborhood to consider
- * ret:oln_concrete_type(I2)&
- * doc:
- * Compute a segmented watershed for image \var{levels} using
- * neighborhood \var{ng}, and \var{markers} as starting point for
- * the flooding algorithm.
- *
- * \var{markers} is an image of the same size as \var{levels}
- * and containing discrete values indicating label associated to
- * each basin. On input, fill \var{markers} with
- * \code{oln_value_type(I2)::min()} (this is the \emph{unknown} label)
- * and mark the starting points or regions
- * (usually these are minima in \var{levels}) using a value
- * between \code{oln_value_type(I2)::min()+1} and \code{oln_value_type(I2)::max()-1}.
- *
- * \code{watershed_seg_or} will flood \var{levels} from these
- * non-\emph{unknown} starting points, labeling basins using
- * the value you assigned to them, and markining watershed lines
- * with \code{oln_value_type(I2)::max()}. \var{markers} should not contains
- * any \code{oln_value_type(I2)::min()} value on output.
- * ref:
- * This is based on the original algorithm
- * presented by D'Ornellas et al. (FIXME: ref?)
- =*/
+ /*!
+ ** \brief Segmented watershed with user-supplied starting points.
+ **
+ ** Compute a segmented watershed for image levels using
+ ** neighborhood ng, and markers as starting point for the flooding
+ ** algorithm.\n
+ **
+ ** markers is an image of the same size as levels and containing
+ ** discrete values indicating label associated to each basin. On
+ ** input, fill markers with oln_value_type(I2)::min() (this is the
+ ** unknown label) and mark the starting points or regions (usually
+ ** these are minima in levels) using a value between
+ ** oln_value_type(I2)::min()+1 and oln_value_type(I2)::max()-1.\n
+ **
+ ** watershed_seg_or will flood levels from these non-unknown
+ ** starting points, labeling basins using the value you assigned
+ ** to them, and markining watershed lines with
+ ** oln_value_type(I2)::max(). markers should not contains any
+ ** oln_value_type(I2)::min() value on output.
+ **
+ ** \ref This is based on the original algorithm presented by
+ ** D'Ornellas et al. (FIXME: ref?)
+ **
+ ** \param I1 Exact type of the D image.
+ ** \param I2 Exact type of the M image.
+ ** \param N Exact type of the neighborhood.
+ **
+ ** \arg D Input image.
+ ** \arg M Image of labels.
+ ** \arg Ng Neighborhood to consider.
+ */
template<class I1, class I2, class N>
oln_concrete_type(I2)&
watershed_seg_or(const abstract::non_vectorial_image<I1>& D,
Index: olena/oln/morpho/watershed.hxx
--- olena/oln/morpho/watershed.hxx Sat, 27 Sep 2003 18:30:39 +0200 burrus_n (oln/47_watershed. 1.9.1.5.1.5 600)
+++ olena/oln/morpho/watershed.hxx Fri, 12 Mar 2004 12:58:17 +0100 palma_g (oln/47_watershed. 1.9.1.5.1.5 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -141,6 +141,10 @@
}
};
+ /*!
+ ** \brief Check if the second element of p1 is lower than the
+ ** second one of p2.
+ */
template<class Point, class T> inline
bool
watershed_seg_sort_(const std::pair<Point, T>& p1,
@@ -149,7 +153,9 @@
return p1.second < p2.second;
}
- // Algorithm by Vincent and Soille
+ /*!
+ ** \brief Algorithm by Vincent and Soille.
+ */
template<class PointHandler, class DestValue, class I, class N>
typename mute<I, DestValue>::ret
soille_watershed_(const abstract::non_vectorial_image<I>& im_i,
@@ -284,10 +290,12 @@
}
- // cmp_queue_elt is a comparison function for the elements from
- // the priority queue used in watershed_seg_or. Note that we
- // return true when l is greater than r, because we when the queue
- // sorted in increasing order.
+ /*!
+ ** cmp_queue_elt is a comparison function for the elements from
+ ** the priority queue used in watershed_seg_or. Note that we
+ ** return true when l is greater than r, because we when the queue
+ ** sorted in increasing order.
+ */
template <class T>
struct cmp_queue_elt
{
Index: olena/oln/morpho/attribute_closing_opening.hh
--- olena/oln/morpho/attribute_closing_opening.hh Thu, 11 Mar 2004 15:41:55 +0100 van-vl_n (oln/q/49_attribute_ 1.18 600)
+++ olena/oln/morpho/attribute_closing_opening.hh Thu, 11 Mar 2004 15:44:41 +0100 palma_g (oln/q/49_attribute_ 1.18 640)
@@ -58,14 +58,14 @@
/*!
** \brief Perform an attribute closing.
**
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
- ** \param A: Attribute exact type.
- **
- ** \arg input: input image.
- ** \arg Ng: neighborhood to use.
- ** \arg lambda: threshold to use.
- ** \arg env: environment.
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
+ ** \param A Attribute exact type.
+ **
+ ** \arg input Input image.
+ ** \arg Ng Neighborhood to use.
+ ** \arg lambda Threshold to use.
+ ** \arg env Environment.
*/
template<class I, class N, class A>
oln_concrete_type(I)
@@ -82,14 +82,14 @@
/*!
** \brief Perform an attribute opening.
**
- ** \param I: image exact type.
- ** \param N: neighborhood exact type.
- ** \param A: Attribute exact type.
- **
- ** \arg input: input image.
- ** \arg Ng: neighborhood to use.
- ** \arg lambda: threshold to use.
- ** \arg env: environment.
+ ** \param I Image exact type.
+ ** \param N Neighborhood exact type.
+ ** \param A Attribute exact type.
+ **
+ ** \arg input Input image.
+ ** \arg Ng Neighborhood to use.
+ ** \arg lambda Threshold to use.
+ ** \arg env Environment.
*/
template<class I, class N, class A>
oln_concrete_type(I)
Index: olena/oln/morpho/attribute_union_find.hh
--- olena/oln/morpho/attribute_union_find.hh Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/q/50_attribute_ 1.14 600)
+++ olena/oln/morpho/attribute_union_find.hh Wed, 10 Mar 2004 19:56:59 +0100 palma_g (oln/q/50_attribute_ 1.14 640)
@@ -43,11 +43,11 @@
/*!
** \brief Struct that contains everything to compute an
- ** attribute opening or closing
+ ** attribute opening or closing.
**
- ** \param T: exact type of images to process.
- ** \param ATTRIBUTE: exact type of attribute to use.
- ** \param Env: type of environment to use.
+ ** \param T Exact type of images to process.
+ ** \param ATTRIBUTE Exact type of attribute to use.
+ ** \param Env Type of environment to use.
*/
template<class T, class ATTRIBUTE, class Env = attr_env_type(ATTRIBUTE)>
struct tarjan_set
@@ -60,8 +60,8 @@
/*!
** \brief tarjan_set constructor.
- ** \param ima: image to open/close.
- ** \param env: environment to use to compute attributes.
+ ** \param ima Image to open/close.
+ ** \param env Environment to use to compute attributes.
*/
tarjan_set(const image_type& ima, const env_type &env) : input_(ima),
parent_(ima.size()),
@@ -73,11 +73,11 @@
/*!
** \brief Main method to perform an attribute opening/closing.
- ** \param closing: true -> a closing is performed, an opening otherwise.
+ ** \param closing True -> a closing is performed, an opening otherwise.
**
- ** \param lambda: threshold to use for attribute growing.
- ** \param Ng: neighborhood to use in the algorithm.
- ** \return the resulting image.
+ ** \param lambda Threshold to use for attribute growing.
+ ** \param Ng Neighborhood to use in the algorithm.
+ ** \return The resulting image.
*/
template<bool closing, class N>
image_type
@@ -162,7 +162,7 @@
/*!
** \brief Make a new component from a point.
- ** \arg x: root of the component.
+ ** \arg x Root of the component.
*/
void
make_set(const point_type& x)
@@ -174,7 +174,7 @@
/*!
** \brief find the root of a component.
- ** \arg x: a point of the component.
+ ** \arg x A point of the component.
*/
point_type
find_root(const point_type& x)
@@ -190,8 +190,8 @@
/*!
** \brief Check if two components should be merged.
- ** \arg x: a point of the first component.
- ** \arg y: a point of the second component.
+ ** \arg x A point of the first component.
+ ** \arg y A point of the second component.
*/
bool
criterion(const point_type& x, const point_type& y)
@@ -203,8 +203,8 @@
/*!
** \brief Do union of two components.
- ** \arg n: a point of the first component.
- ** \arg p: a point of the second component.
+ ** \arg n A point of the first component.
+ ** \arg p A point of the second component.
*/
void
uni(const point_type& n, const point_type& p)
Index: olena/oln/morpho/attributes.hh
--- olena/oln/morpho/attributes.hh Wed, 10 Mar 2004 16:20:23 +0100 palma_g (oln/j/45_attributes 1.6 600)
+++ olena/oln/morpho/attributes.hh Wed, 10 Mar 2004 19:50:24 +0100 palma_g (oln/j/45_attributes 1.6 644)
@@ -128,7 +128,7 @@
// the traits fwd declaration
/*!
** Traits for attributes information.
- ** \param T: exact type of the attribute.
+ ** \param T Exact type of the attribute.
*/
template <class T>
struct attr_traits;
@@ -728,8 +728,8 @@
*-----------*/
/*!
** \brief Max value attribute.
- ** \param T: data type.
- ** \param Exact: the exact type.
+ ** \param T Data type.
+ ** \param Exact The exact type.
*/
template <class T = unsigned, class Exact = mlc::final>
class maxvalue_type:
@@ -752,7 +752,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
maxvalue_type(const lambda_type &lambda): value_(lambda)
{
@@ -761,10 +761,10 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \param I: image exact type.
+ ** \param I Image exact type.
**
- ** \arg input: input image.
- ** \arg p: point to consider in the image.
+ ** \arg input Input image.
+ ** \arg p Point to consider in the image.
*/
template <class I>
maxvalue_type(const abstract::image<I> &input,
@@ -844,8 +844,8 @@
*-----------*/
/*!
** \brief Min value attribute.
- ** \param T: data type.
- ** \param Exact: the exact type.
+ ** \param T Data type.
+ ** \param Exact The exact type.
*/
template <class T = unsigned, class Exact = mlc::final>
class minvalue_type:
@@ -868,7 +868,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
minvalue_type(const lambda_type &lambda): value_(lambda)
{
@@ -877,10 +877,10 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \param I: image exact type.
+ ** \param I Image exact type.
**
- ** \arg input: input image.
- ** \arg p: point to consider in the image.
+ ** \arg input Input image.
+ ** \arg p Point to consider in the image.
*/
template <class I>
minvalue_type(const abstract::image<I> &input,
@@ -960,8 +960,8 @@
*-----------*/
/*!
** \brief Ball attribute.
- ** \param I: exact type of images to process.
- ** \param Exact: the exact type.
+ ** \param I Exact type of images to process.
+ ** \param Exact The exact type.
*/
template <class I, class Exact = mlc::final>
class ball_type:
@@ -989,7 +989,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
ball_type(const lambda_type &lambda): value_(lambda), pts_()
{
@@ -999,7 +999,7 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \arg p: point to consider in the image.
+ ** \arg p Point to consider in the image.
*/
ball_type(const im_type&, const point_type &p, const env_type &) :
value_(ntg_zero_val(value_type)), pts_()
@@ -1123,8 +1123,8 @@
*-----------*/
/*!
** \brief Dist attribute.
- ** \param I: exact type of images to process.
- ** \param Exact: the exact type.
+ ** \param I Exact type of images to process.
+ ** \param Exact The exact type.
*/
template <class I, class Exact = mlc::final>
class dist_type:
@@ -1150,7 +1150,7 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \arg p: point to consider in the image.
+ ** \arg p Point to consider in the image.
*/
dist_type(const im_type&,
const point_type &p,
@@ -1174,7 +1174,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
dist_type(const lambda_type lambda): value_(lambda)
{
@@ -1275,8 +1275,8 @@
*-----------*/
/*!
** \brief Cube attribute.
- ** \param I: exact type of images to process.
- ** \param Exact: the exact type.
+ ** \param I Exact type of images to process.
+ ** \param Exact The exact type.
*/
template <class I, class Exact = mlc::final>
class cube_type:
@@ -1304,7 +1304,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
cube_type(const lambda_type &lambda):
mins_(dim),
@@ -1321,7 +1321,7 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \arg p: point to consider in the image.
+ ** \arg p Point to consider in the image.
*/
cube_type(const im_type&,
const point_type &p,
@@ -1336,7 +1336,7 @@
** \brief Accessor to minimums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th minimum.
** \see getMin_impl()
*/
@@ -1349,7 +1349,7 @@
** \brief Accessor to maximums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th maximum.
** \see getMax_impl()
*/
@@ -1444,8 +1444,8 @@
*-----*/
/*!
** \brief Box attribute.
- ** \param I: exact type of images to process.
- ** \param Exact: the exact type.
+ ** \param I Exact type of images to process.
+ ** \param Exact The exact type.
*/
template <class I, class Exact = mlc::final>
class box_type:
@@ -1462,7 +1462,7 @@
/*!
** \brief Ctor from a lambda_type value.
**
- ** \arg lambda: value of the attribute.
+ ** \arg lambda Value of the attribute.
*/
box_type(const lambda_type &lambda): maxs_(dim), mins_(dim)
{
@@ -1486,7 +1486,7 @@
/*!
** \brief Ctor from a point and an image.
**
- ** \arg p: point to consider in the image.
+ ** \arg p Point to consider in the image.
*/
box_type(const im_type&, const point_type &p, const env_type &): maxs_(dim), mins_(dim)
{
@@ -1498,7 +1498,7 @@
** \brief Accessor to minimums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th minimum.
** \see getMin_impl()
*/
@@ -1512,7 +1512,7 @@
** \brief Accessor to maximums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th maximum.
** \see getMax_impl()
*/
@@ -1526,7 +1526,7 @@
** \brief Accessor to minimums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th minimum.
** \see getMin_impl()
*/
@@ -1540,7 +1540,7 @@
** \brief Accessor to maximums.
**
** Virtual method.
- ** \arg i: index of the minimum wanted.
+ ** \arg i Index of the minimum wanted.
** \return the i th maximum.
** \see getMax_impl()
*/
Index: olena/oln/morpho/attribute_closing_opening_map.hh
--- olena/oln/morpho/attribute_closing_opening_map.hh Thu, 11 Mar 2004 15:41:55 +0100 van-vl_n (oln/j/49_attribute_ 1.5 600)
+++ olena/oln/morpho/attribute_closing_opening_map.hh Thu, 11 Mar 2004 15:43:32 +0100 palma_g (oln/j/49_attribute_ 1.5 600)
@@ -60,9 +60,9 @@
** See "Fast morphological attribute operations using Tarjan's union-find
** algorithm" by Michael H. F. Wilkinson and Jos B. T. M. Roerdink
**
- ** \param I: image exact type.
- ** \param D: attribute exact type.
- ** \param Env: type of environment.
+ ** \param I Image exact type.
+ ** \param D Attribute exact type.
+ ** \param Env Type of environment.
*/
template <class I, class D, class Env = morpho::NullEnv>
struct f_tarjan_map
@@ -90,13 +90,13 @@
/*!
** \brief Perform an attribute opening/closing.
**
- ** \param N: exact type of neighborhood
+ ** \param N Exact type of neighborhood
**
- ** \arg is_closing: choose between closing and opening.
- ** \arg input: input image.
- ** \arg ng: neighborhood to use.
- ** \arg lambda: threshold.
- ** \arg env: environment.
+ ** \arg is_closing Choose between closing and opening.
+ ** \arg input Input image.
+ ** \arg ng Neighborhood to use.
+ ** \arg lambda Threshold.
+ ** \arg env Environment.
*/
template <class N>
f_tarjan_map(bool is_closing,
@@ -105,7 +105,7 @@
const lambda_type& lambda,
const Env & env = Env());
/*!
- ** \brief return the result of the opening/closing.
+ ** \brief Return the result of the opening/closing.
*/
oln_concrete_type(I)
res()
@@ -128,22 +128,22 @@
/*!
** \brief Make a new component from a point.
- ** \arg x: root of the component.
+ ** \arg x Root of the component.
*/
void
make_set(const point_type& x);
/*!
** \brief link two components
- ** \arg x: a point of the first component.
- ** \arg y: a point of the second component.
+ ** \arg x A point of the first component.
+ ** \arg y A point of the second component.
*/
void
link(const point_type& x, const point_type& y);
/*!
** \brief find the root of a component.
- ** \arg x: a point of the component.
+ ** \arg x A point of the component.
*/
point_type
find_root(const point_type& x);
@@ -157,8 +157,8 @@
/*!
** \brief link two components if they have to be linked
- ** \arg n: a point of the first component.
- ** \arg p: a point of the second component.
+ ** \arg n A point of the first component.
+ ** \arg p A point of the second component.
*/
void
do_union(const point_type& n, const point_type& p);
--
Giovanni Palma
EPITA - promo 2005 - membre d'EpX - LRDE
Mob. : +33 (0)6 60 97 31 74
Index: olena/ChangeLog
from Niels Van Vliet <niels(a)lrde.epita.fr>
* olena/oln/snakes/snakes_base.hh: Add comments
* olena/oln/snakes/energies.hh: Add comments
* olena/oln/snakes/greedy.hh: Add comments
* olena/oln/snakes/node.hh: Add comments
* olena/oln/snakes/segment.hh: Add comments
* olena/oln/snakes/snakes_base.hh: Add comments
* olena/oln/morpho/attribute_closing_opening.hh: Fix bug in doc
* olena/oln/morpho/attribute_closing_opening_map.hh: Fix bug in doc
Index: olena/oln/morpho/attribute_closing_opening.hh
--- olena/oln/morpho/attribute_closing_opening.hh Wed, 10 Mar 2004
16:20:23 +0100 palma_g (oln/q/49_attribute_ 1.17 640)
+++ olena/oln/morpho/attribute_closing_opening.hh Thu, 11 Mar 2004
15:14:01 +0100 van-vl_n (oln/q/49_attribute_ 1.17 640)
@@ -327,7 +327,7 @@
**
** im_type im1(oln::load(IMG_IN "lena128.pgm"));
** im1 = oln::morpho::fast::maxvalue_closing(im1,
oln::neighb_c4(), 5);
- ** oln::save(im1, IMG_OUT
"oln_morpho_fast_maxvalue_closing.png.ppm");
+ ** oln::save(im1, IMG_OUT "oln_morpho_fast_maxvalue_closing.ppm");
** return 0;
** }
** \endcode
Index: olena/oln/snakes/snakes_base.hh
--- olena/oln/snakes/snakes_base.hh Wed, 21 Jan 2004 05:11:16 +0100
astrid (oln/f/50_snakes_bas 1.1 644)
+++ olena/oln/snakes/snakes_base.hh Wed, 10 Mar 2004 18:51:37 +0100
van-vl_n (oln/f/50_snakes_bas 1.1 644)
@@ -32,8 +32,15 @@
namespace oln {
+ /*! \namespace oln::snakes
+ ** Namespace snakes.
+ */
namespace snakes {
-
+ /*! Snake algorithm.
+ **
+ ** \attention FIXME: Do not work due to the function node::energy.
+ ** \todo FIXME: Add doc & test.
+ */
template <class algorithm>
class snake
{
@@ -57,6 +64,7 @@
ntg::float_s
energy(void) const;
///< Return the snake energy. This is not algorithm-dependant.
+ ///< \attention FIXME: Do not work due to the function node::energy
public:
int
Index: olena/oln/snakes/energies.hh
--- olena/oln/snakes/energies.hh Wed, 21 Jan 2004 05:11:16 +0100 astrid
(oln/j/22_energies.h 1.1 644)
+++ olena/oln/snakes/energies.hh Wed, 10 Mar 2004 18:51:37 +0100
van-vl_n (oln/j/22_energies.h 1.1 644)
@@ -32,6 +32,8 @@
namespace snakes {
+ /*! Base class for energy.
+ */
template <class I>
class energy
{
@@ -40,6 +42,11 @@
energy(void *) {}
public:
+ /*! Return the energy.
+ **
+ ** The first arg is the gradient of the image;
+ ** the 3 nodes are the previous, the current and the next node.
+ */
ntg::float_s
compute(const I&, const node<I>&, const node<I>&, const node<I>&)
{
@@ -52,6 +59,7 @@
}
public:
+ //! FIXME: What is that?
static void* cookie() { return 0; };
private:
@@ -59,6 +67,14 @@
};
+ /*! Energy of continuity.
+ **
+ ** The goal of this energy is to avoid pack of nodes an lack
+ ** of nodes in some part of the snake. The average distance
+ ** between two consecutive points is \a average_dist. The
+ ** more the distance between \a prev and \a current is
+ ** far from \a average_dist, the higher the energy is.
+ */
template <class I>
class continuity_energy : public energy<I>
{
@@ -82,6 +98,13 @@
};
+ /*! Energy of curvature.
+ **
+ ** The snake is supposed to be applied on object that
+ ** have smooth edge (example: an egg). The more the
+ ** \a prev \a current \a next nodes are aligned, the
+ ** less the energy is.
+ */
template <class I>
class curvature_energy : public energy<I>
{
@@ -101,6 +124,11 @@
};
+ /*! Energy of the gradient.
+ **
+ ** The snake should follow the edge of the object.
+ ** The higher the gradient is, the less the energy is.
+ */
template <class I>
class image_energy : public energy<I>
{
@@ -120,7 +148,10 @@
};
- // This macro allows the user to define his own external energy.
+ /*! This macro allows the user to define his own external energy.
+ **
+ ** \see dummy_energy
+ */
#define oln_snakes_define_external_energy(Energy, Gradient, PrevNode,
CurrentNode, NextNode) \
\
template<class I> \
@@ -148,7 +179,7 @@
const ::oln::snakes::node<I>& NextNode)
- // Default external energy.
+ //! Default external energy.
oln_snakes_define_external_energy(dummy_energy,,,,)
{
return 0;
Index: olena/oln/snakes/greedy.hh
--- olena/oln/snakes/greedy.hh Wed, 21 Jan 2004 05:11:16 +0100 astrid
(oln/j/25_greedy.hh 1.1 644)
+++ olena/oln/snakes/greedy.hh Wed, 10 Mar 2004 18:51:37 +0100 van-vl_n
(oln/j/25_greedy.hh 1.1 644)
@@ -36,7 +36,13 @@
namespace snakes {
- /// N is the size of the neighborhood.
+ /*! This class can be use as the algorithm of snake.
+ **
+ ** \param N is the size of the neighborhood.
+ ** \pre N must be odd.
+ ** \see snake
+ */
+
template <int N, class I, template<typename> class external_energy
= dummy_energy>
class greedy
{
Index: olena/oln/snakes/node.hh
--- olena/oln/snakes/node.hh Wed, 21 Jan 2004 05:11:16 +0100 astrid
(oln/j/32_node.hh 1.1 644)
+++ olena/oln/snakes/node.hh Wed, 10 Mar 2004 18:51:37 +0100 van-vl_n
(oln/j/32_node.hh 1.1 644)
@@ -34,6 +34,10 @@
namespace snakes {
+ /*! A node is a point used in ring.
+ **
+ ** \attention FIXME: Do not work due to the function energy.
+ */
template<class I>
class node : public I::point_type
{
@@ -48,6 +52,10 @@
}
public:
+ /*! Return the energy
+ **
+ ** FIXME: not implemented, do not work
+ */
inline
ntg::float_s
energy(const I& gradient, point_type prev, point_type next) const;
@@ -61,7 +69,7 @@
} // end oln
-
+//! Print the position of a node \a n
template <class I>
std::ostream& operator<<(std::ostream& os, const oln::snakes::node<I>& n)
{
Index: olena/oln/snakes/segment.hh
--- olena/oln/snakes/segment.hh Wed, 21 Jan 2004 05:11:16 +0100 astrid
(oln/j/34_segment.hh 1.1 644)
+++ olena/oln/snakes/segment.hh Wed, 10 Mar 2004 18:51:37 +0100 van-vl_n
(oln/j/34_segment.hh 1.1 644)
@@ -37,6 +37,10 @@
namespace snakes {
+ /*! A segment is a list of node.
+ **
+ ** \attention FIXME: Do not work due to the function node::energy.
+ */
template <class I>
class segment
{
@@ -53,6 +57,9 @@
ntg::float_s
energy(const I& gradient) const;
///< Just iterate through the vector and sums up point energies.
+ ///<
+ ///< \attention FIXME: Do not work due to the function node::energy.
+
public:
std::list<point_type>
Index: olena/oln/morpho/attribute_closing_opening_map.hh
--- olena/oln/morpho/attribute_closing_opening_map.hh Wed, 10 Mar 2004
16:20:23 +0100 palma_g (oln/j/49_attribute_ 1.4 600)
+++ olena/oln/morpho/attribute_closing_opening_map.hh Thu, 11 Mar 2004
15:13:57 +0100 van-vl_n (oln/j/49_attribute_ 1.4 600)
@@ -423,7 +423,7 @@
**
** im_type im1(oln::load(IMG_IN "lena128.pgm"));
** im1 = oln::morpho::slow::maxvalue_closing(im1,
oln::neighb_c4(), 5);
- ** oln::save(im1, IMG_OUT
"oln_morpho_fast_maxvalue_closing.png.ppm");
+ ** oln::save(im1, IMG_OUT "oln_morpho_fast_maxvalue_closing.ppm");
** return 0;
** }
** \endcode
Index: olena/ChangeLog
from Niels Van Vliet <niels(a)lrde.epita.fr>
* oln/morpho/attribute_closing_opening_map.hh: Add file.
Attribute closing and opening using std::map.
* oln/morpho/attribute_closing_opening_map.hxx: Add file.
* oln/utils/special_points.hh: Add file. Point used as a state.
* tests/morpho/attributes: Add file. Add tests on attribute
closing and opening.
Index: olena/oln/morpho/attribute_closing_opening_map.hxx
--- olena/oln/morpho/attribute_closing_opening_map.hxx Tue, 10 Feb 2004
19:47:05 +0100 van-vl_n ()
+++ olena/oln/morpho/attribute_closing_opening_map.hxx Tue, 10 Feb 2004
19:18:13 +0100 van-vl_n (oln/j/48_attribute_ 644)
@@ -0,0 +1,194 @@
+// 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.
+
+
+namespace oln
+{
+ namespace morpho
+ {
+ template <class I, class D, class Env>
+ template <class N>
+ f_tarjan_map<I, D, Env>::f_tarjan_map(bool is_closing,
+ const typename f_tarjan_map<I, D, Env>::input_type& input,
+ const abstract::neighborhood<N>& ng,
+ const typename f_tarjan_map<I, D, Env>::lambda_type& lambda,
+ const Env & env) :
+ is_closing(is_closing),
+ input(input),
+ lambda(lambda),
+ parent(input.size()),
+ is_proc(input.size()),
+ output(input.size()),
+ env(env)
+ {
+ // init S and parent
+ typedef typename std::vector<point_type> vector_type;
+ vector_type S(input.npoints());
+ if (is_closing)
+ utils::distrib_sort(input, S);
+ else
+ utils::distrib_sort_inv(input, S);
+
+ level::fill(parent, inactive());
+ level::fill(is_proc, false);
+
+ // array S contains sorted pixel list
+ make_set(S[0]);
+ is_proc[S[0]] = true;
+
+ for (int ip = 1; ip < int(S.size()); ++ip)
+ {
+ point_type p = S[ip];
+
+ // p_ is the pixel just processed before p
+ point_type p_ = S[ip - 1];
+ if (input[p] != input[p_])
+ {
+ // for all the previous layer
+ for (int iq = ip - 1; iq >= 0; --iq)
+ {
+ point_type q = S[iq];
+ if (input[q] != input[p_])
+ break;
+ // if the attribute is 'reached', we do not need
+ // it anymore
+ if (parent[q] == active() && !(auxdata[q] < lambda))
+ {
+ parent[q] = inactive();
+ auxdata.erase(q);
+ }
+ }
+ }
+ make_set(p);
+
+ oln_neighb_type(N) n(ng, p);
+ for_all(n)
+ if (input.hold(n) && is_proc[n])
+ do_union(n, p);
+
+ is_proc[p] = true;
+ }
+
+ // resolving phase in reverse sort order
+
+ for (int ip = int(S.size()) - 1; ip >= 0; --ip)
+ {
+ point_type p = S[ip];
+ if (parent[p] == active() || parent[p] == inactive())
+ output[p] = input[p];
+ else
+ output[p] = output[parent[p]];
+ }
+ }
+
+ template <class I, class D, class Env>
+ const typename f_tarjan_map<I, D, Env>::point_type
+ f_tarjan_map<I, D, Env>::inactive()
+ {
+ static const point_type it =
utils::internal::mk_point_looking_like<point_type>(-2);
+ return it;
+ }
+
+ template <class I, class D, class Env>
+ const typename f_tarjan_map<I, D, Env>::point_type
+ f_tarjan_map<I, D, Env>::active()
+ {
+ static const point_type it =
utils::internal::mk_point_looking_like<point_type>(-1);
+ return it;
+ }
+
+ template <class I, class D, class Env>
+ void
+ f_tarjan_map<I, D, Env>::make_set(const typename f_tarjan_map<I, D,
Env>::point_type& x)
+ {
+ precondition(parent[x] == inactive());
+ parent[x] = active();
+ auxdata[x] = D(input, x, env);
+ }
+
+ template <class I, class D, class Env>
+ void
+ f_tarjan_map<I, D, Env>::link(const typename f_tarjan_map<I, D,
Env>::point_type& x,
+ const typename f_tarjan_map<I, D, Env>::point_type& y)
+ {
+ if (parent[x] == active() && parent[y] == active())
+ {
+ auxdata[y] += auxdata[x];
+ auxdata.erase(x);
+ }
+ else
+ if (parent[x] == active())
+ auxdata.erase(x);
+ else
+ {
+ parent[y] = inactive();
+ auxdata.erase(y);
+ }
+ parent[x] = y;
+ }
+
+ template <class I, class D, class Env>
+ typename f_tarjan_map<I, D, Env>::point_type
+ f_tarjan_map<I, D, Env>::find_root(const typename f_tarjan_map<I,
D, Env>::point_type& x)
+ {
+ if (parent[x] != active() && parent[x] != inactive())
+ {
+ parent[x] = find_root(parent[x]);
+ return parent[x];
+ }
+ return x;
+ }
+
+ template <class I, class D, class Env>
+ bool
+ f_tarjan_map<I, D, Env>::equiv(const typename f_tarjan_map<I, D,
Env>::point_type& x,
+ const typename f_tarjan_map<I, D, Env>::point_type& y) const
+ {
+ return input[x] == input[y] || parent[x] == active();
+ }
+
+ template <class I, class D, class Env>
+ void
+ f_tarjan_map<I, D, Env>::do_union(const typename f_tarjan_map<I, D,
Env>::point_type& n,
+ const typename f_tarjan_map<I, D, Env>::point_type& p)
+ {
+ point_type r = find_root(n);
+ if (r != p)
+ {
+ if (equiv(r, p))
+ link(r, p);
+ else
+ if (parent[p] == active())
+ {
+ parent[p] = inactive();
+ auxdata.erase(p);
+ }
+ }
+ }
+ } // end of namespace morpho
+} // end of namespace oln
+
Index: olena/oln/morpho/attribute_closing_opening_map.hh
--- olena/oln/morpho/attribute_closing_opening_map.hh Tue, 10 Feb 2004
19:47:05 +0100 van-vl_n ()
+++ olena/oln/morpho/attribute_closing_opening_map.hh Tue, 10 Feb 2004
19:18:13 +0100 van-vl_n (oln/j/49_attribute_ 644)
@@ -0,0 +1,151 @@
+// 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 OLENA_MORPHO_ATTRIBUTE_CLOSING_OPENING_MAP
+# define OLENA_MORPHO_ATTRIBUTE_CLOSING_OPENING_MAP
+# include <oln/morpho/attributes.hh>
+# include <oln/level/fill.hh>
+# include <oln/basics2d.hh>
+# include <ntg/int.hh>
+# include <oln/utils/histogram.hh>
+# include <oln/utils/special_points.hh>
+
+# include <iterator>
+# include <vector>
+# include <map>
+# include <algorithm>
+# include <utility>
+
+
+namespace oln
+{
+ namespace morpho
+ {
+
+ /*! Attribute closing using map. Smaller memory usage, but
+ * slower computation than the attribute_closing_opening
+ *
+ * See "Fast morphological attribute operations using Tarjan's
union-find
+ * algorithm" by Michael H. F. Wilkinson and Jos B. T. M. Roerdink
+ */
+ template <class I, class D, class Env = morpho::tarjan::NullEnv>
+ struct f_tarjan_map
+ {
+ public:
+ typedef abstract::image<I> input_type;
+ typedef oln_concrete_type(I) img_type;
+
+ typedef oln_point_type(input_type) point_type;
+ typedef oln_value_type(input_type) value_type;
+ typedef typename mute<input_type, point_type>::ret parent_type;
+ typedef typename mute<input_type, bool>::ret is_proc_type;
+ typedef typename D::lambda_type lambda_type;
+
+ // e.g.,
+ // when I is image2d<int_u8> and D is area_type, we've got:
+ // +--------------+------------------+
+ // | input_type | image2d<int_u8> |
+ // | point_type | point2d |
+ // | parent_type | image2d<point2d> |
+ // | is_proc_type | image2d<bool> |
+ // | lambda_type | int |
+ // +--------------+------------------+
+
+ template <class N>
+ f_tarjan_map(bool is_closing,
+ const input_type& input,
+ const abstract::neighborhood<N>& ng,
+ const lambda_type& lambda,
+ const Env & env = Env());
+
+ template<typename DestValue>
+ typename mute<I, DestValue>::ret
+ res()
+ {
+ return output;
+ }
+ protected:
+
+ static const point_type
+ inactive();
+
+ static const point_type
+ active();
+
+ void
+ make_set(const point_type& x);
+
+ void
+ link(const point_type& x, const point_type& y);
+
+ point_type
+ find_root(const point_type& x);
+
+ bool
+ equiv(const point_type& x, const point_type& y) const;
+
+ void
+ do_union(const point_type& n, const point_type& p);
+
+ const bool is_closing;
+ const input_type& input;
+ lambda_type lambda;
+ parent_type parent;
+ is_proc_type is_proc;
+ img_type output;
+ std::map<point_type, D, oln::internal::default_less<point_type> >
auxdata;
+ Env env;
+ };
+
+
+ /*! Attribute closing using map. Smaller memory usage, but
+ * slower computation than the attribute_closing_opening
+ *
+ * See "Fast morphological attribute operations using Tarjan's
union-find
+ * algorithm" by Michael H. F. Wilkinson and Jos B. T. M. Roerdink
+ */
+ template <typename DestValue, class I, class D, class Env, class N>
+ typename mute<I, DestValue>::ret
+ tarjan_map(bool is_closing,
+ const abstract::image<I>& input,
+ const abstract::neighborhood<N>& ng,
+ const typename D::lambda_type& lambda,
+ const Env & env = Env())
+ {
+ oln::morpho::f_tarjan_map<I, D, Env > t(is_closing,
+ input,
+ ng,
+ lambda,
+ env);
+ return t. template res<DestValue>();
+ }
+ } // end of namespace morpho
+} // end of namespace oln
+
+#include "attribute_closing_opening_map.hxx"
+
+#endif
Index: olena/oln/utils/special_points.hh
--- olena/oln/utils/special_points.hh Tue, 10 Feb 2004 19:47:05 +0100
van-vl_n ()
+++ olena/oln/utils/special_points.hh Tue, 10 Feb 2004 19:18:14 +0100
van-vl_n (oln/j/50_special_po 644)
@@ -0,0 +1,58 @@
+// 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 OLENA_UTILS_SPECIAL_POINTS_HH
+# define OLENA_UTILS_SPECIAL_POINTS_HH
+
+# include <oln/core/abstract/point.hh>
+
+namespace oln {
+
+ namespace utils {
+
+ namespace internal {
+ /*! Creates a point that is used as a state.
+ *
+ * This function should be called with a value unreachable
+ * for example a negative one.
+ */
+ template <class P>
+ P
+ mk_point_looking_like(coord value)
+ {
+ P p;
+ p.nth(0) = value;
+ return p;
+ }
+
+ } // end of namespace internal
+
+ } // end of namespace utils
+
+} // end of namespace oln
+
+#endif // ! OLENA_UTILS_SPECIAL_POINTS_HH
Index: olena/tests/morpho/tests/attribute
--- olena/tests/morpho/tests/attribute Tue, 10 Feb 2004 19:47:05 +0100
van-vl_n ()
+++ olena/tests/morpho/tests/attribute Tue, 10 Feb 2004 19:18:00 +0100
van-vl_n (oln/j/51_attribute 644)
@@ -0,0 +1,109 @@
+// -*- c++ -*-
+
+#include <oln/basics2d.hh>
+#include <oln/morpho/attribute_closing_opening.hh>
+#include <oln/morpho/attribute_closing_opening_map.hh>
+#include <oln/level/compare.hh>
+#include <ntg/all.hh>
+#include <oln/morpho/extrema_killer.hh>
+
+#include "check.hh"
+#include "data.hh"
+
+using namespace oln;
+using namespace ntg;
+
+#define OK_OR_FAIL \
+ std::cout << "OK" << std::endl; \
+ else \
+ { \
+ std::cout << "FAIL" << std::endl; \
+ fail = true; \
+ }
+
+//FIXME some algo are already checked.
+bool
+check_algo()
+{
+ bool fail(false);
+
+ typedef image2d<int_u8> img_type;
+ typedef oln::morpho::tarjan::area_type<unsigned> area_type;
+ const area_type::lambda_type area = 100;
+ const neighborhood2d nb = neighb_c8();
+ const oln::morpho::tarjan::NullEnv env;
+
+ img_type lena = load(rdata("lena.pgm"));
+ img_type lena_sure_closing = oln::morpho::sure_minima_killer(lena,
area, nb);
+ img_type lena_sure_opening = oln::morpho::sure_maxima_killer(lena,
area, nb);
+
+ img_type lena_tst_opening;
+ img_type lena_tst_closing;
+
+ std::cerr << "testing tarjan_map..." << std::endl;
+ lena_tst_closing =
morpho::tarjan_map<ntg::int_u8,img_type,area_type>(true, lena, nb,
area, env);
+ lena_tst_opening=
morpho::tarjan_map<ntg::int_u8,img_type,area_type>(false, lena, nb,
area, env);
+
+
+ fail = fail ||
+ !level::is_equal(lena_sure_closing, lena_tst_closing)||
+ !level::is_equal(lena_sure_opening, lena_tst_opening);
+
+ std::cerr << "fail:" << fail << std::endl;
+
+ std::cerr << "testing fast_minima_killer..." << std::endl;
+ lena_tst_closing = oln::morpho::fast_minima_killer(lena, area, nb);
+
+ fail = fail ||
+ !level::is_equal(lena_sure_closing, lena_tst_closing);
+ std::cerr << "fail:" << fail << std::endl;
+
+ std::cerr << "testing area_closin and area_opeing..." << std::endl;
+ lena_tst_closing = morpho::tarjan::area_closing(lena, nb, area);
+ lena_tst_opening = morpho::tarjan::area_opening(lena, nb, area);
+ fail = fail ||
+ !level::is_equal(lena_sure_closing, lena_tst_closing)||
+ !level::is_equal(lena_sure_opening, lena_tst_opening);
+ std::cerr << "fail:" << fail << std::endl;
+ //FIXME at least 1 other algo should be checked
+
+ return fail;
+}
+
+
+bool
+check_attribute()
+{
+ //FIXME attributes should be checked
+ return false;
+}
+
+
+bool
+check_env()
+{
+ //FIXME env should be checked
+ return false;
+}
+bool
+check()
+{
+ bool fail = false;
+
+ std::cerr << "FIXME: check_attribute and check_env are empty."
+ << std::endl;
+
+ std::cout << "check algo... " << std::flush;
+ if (check_algo() == false)
+ OK_OR_FAIL;
+
+ std::cout << "check attribute... " << std::flush;
+ if (check_attribute() == false)
+ OK_OR_FAIL;
+
+ std::cout << "check env... " << std::flush;
+ if (check_env() == false)
+ OK_OR_FAIL;
+
+ return fail;
+}
Index: olena/ChangeLog
from Niels Van Vliet <niels(a)lrde.epita.fr>
* oln/core/abstract/image.hh: Remove macro oln_neighb_type.
* oln/core/abstract/neighborhood.hh: Add macro oln_neighb_type.
* oln/core/utils/histogram.hh: Add a FIXME.
+2004-02-10 Niels Van Vliet <niels(a)lrde.epita.fr>
+
* oln/morpho/attribute_closing_opening_map.hh: Add file.
Attribute closing and opening using std::map.
* oln/morpho/attribute_closing_opening_map.hxx: Add file.
Index: olena/oln/core/abstract/neighborhood.hh
--- olena/oln/core/abstract/neighborhood.hh Thu, 07 Aug 2003 02:08:21
+0200 david (oln/c/38_neighborho 1.18 640)
+++ olena/oln/core/abstract/neighborhood.hh Wed, 11 Feb 2004 09:11:56
+0100 van-vl_n (oln/c/38_neighborho 1.18 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2002, 2003 EPITA Research and Development
Laboratory
+// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development
Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -175,6 +175,9 @@
return win;
}
+# define oln_neighb_type(Neighbable) \
+typename Neighbable::neighb_type
+
} // end of oln
Index: olena/oln/utils/histogram.hh
--- olena/oln/utils/histogram.hh Tue, 10 Feb 2004 17:32:17 +0100 palma_g
(oln/10_histogram. 1.6.1.14.1.5 640)
+++ olena/oln/utils/histogram.hh Wed, 11 Feb 2004 09:15:27 +0100
van-vl_n (oln/10_histogram. 1.6.1.14.1.5 640)
@@ -84,6 +84,9 @@
namespace abstract
{
+ // FIXME: An image is inside the histogram. This is incorrect
+ // because it is not exactly an image (we do not need any
+ // border).
template<class T,
typename CPT,
class Exact = mlc::final>
Index: olena/oln/core/abstract/image.hh
--- olena/oln/core/abstract/image.hh Mon, 01 Sep 2003 20:12:38 +0200
burrus_n (oln/t/25_image.hh 1.19 640)
+++ olena/oln/core/abstract/image.hh Wed, 11 Feb 2004 09:11:57 +0100
van-vl_n (oln/t/25_image.hh 1.19 640)
@@ -1,4 +1,4 @@
-// Copyright (C) 2001, 2003 EPITA Research and Development Laboratory
+// Copyright (C) 2001, 2003, 2004 EPITA Research and Development
Laboratory
//
// This file is part of the Olena Library. This library is free
// software; you can redistribute it and/or modify it under the terms
@@ -209,9 +209,6 @@
# define oln_dpoint_type(DPointable) \
mlc_exact_type(DPointable)::dpoint_type
-# define oln_neighb_type(Neighbable) \
-typename Neighbable::neighb_type
-
} // end of namespace oln
#endif // ! OLENA_CORE_ABSTRACT_IMAGE_HH
