[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2. Processings

2.1 Morphological processings  
2.2 Level processings  


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.1 Morphological processings

Soille refers to P. Soille, morphological Image Analysis -- Principals and Applications. Springer 1998.

morpho::beucher_gradient  Morphological Beucher Gradient.
morpho::black_top_hat  Black top hat.
morpho::closing  Morphological closing.
morpho::dilation  Morphological dilation.
morpho::erosion  Morphological erosion.
morpho::external_gradient  Morphological External Gradient.
morpho::geodesic_dilation  Geodesic dilation.
morpho::geodesic_erosion  Geodesic erosion.
morpho::hit_or_miss  Hit_or_Miss Transform.
morpho::hit_or_miss_closing  Hit_or_Miss closing.
morpho::hit_or_miss_closing_bg  Hit_or_Miss closing of background.
morpho::hit_or_miss_opening  Hit_or_Miss opening.
morpho::hit_or_miss_opening_bg  Hit_or_Miss opening of background.
morpho::hybrid_geodesic_reconstruction_dilation  Geodesic reconstruction by dilation.
morpho::hybrid_geodesic_reconstruction_erosion  Geodesic reconstruction by erosion.
morpho::hybrid_minima_imposition  Minima Imposition.
morpho::hybrid_regional_minima  Regional minima.
morpho::internal_gradient  Morphological Internal Gradient.
morpho::laplacian  Laplacian.
morpho::n_dilation  Morphological dilation itered n times.
morpho::n_erosion  Morphological erosion itered n times.
morpho::opening  Morphological opening.
morpho::self_complementary_top_hat  Self complementary top hat.
morpho::sequential_geodesic_reconstruction_dilation  Geodesic reconstruction by dilation.
morpho::sequential_geodesic_reconstruction_erosion  Geodesic reconstruction by erosion.
morpho::sequential_minima_imposition  Minima Imposition.
morpho::sequential_regional_minima  Regional minima.
morpho::simple_geodesic_dilation  Geodesic dilation.
morpho::simple_geodesic_erosion  Geodesic erosion.
morpho::sure_geodesic_reconstruction_dilation  Geodesic reconstruction by dilation.
morpho::sure_geodesic_reconstruction_erosion  Geodesic reconstruction by erosion.
morpho::sure_minima_imposition  Minima Imposition.
morpho::sure_regional_minima  Regional minima.
morpho::top_hat_contrast_op  Top hat contrastor operator.
morpho::watershed_con  Connected Watershed.
morpho::watershed_seg  Segmented Watershed.
morpho::watershed_seg_or  Segmented Watershed with user-supplied starting points.
morpho::white_top_hat  White top hat.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::beucher_gradient

PURPOSE
Morphological Beucher Gradient.
PROTOTYPE

#include "morpho/gradient.hh"

mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::beucher_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::beucher_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::beucher_gradient (const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::fast::beucher_gradient (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute the arithmetic difference between the diltation and the erosion of input using se as structural element. Soille, p67.

SEE ALSO
morpho::erosion,
morpho::dilation,
morpho::external_gradient,
morpho::internal_gradient.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::beucher_gradient(im, win_c8p()), "out.pgm");

{
lena256.pgm
38eb20951c1836d7516bca69b8083b1b-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::black_top_hat

PURPOSE
Black top hat.
PROTOTYPE

#include "morpho/top_hat.hh"

typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::black_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::black_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute black top hat of input using se as structural element. Soille p.105.

SEE ALSO
morpho::closing.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::black_top_hat(im, win_c8p()), "out.pgm");

{
lena256.pgm
c105a9785b9f50ad7110027ad32a0870-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::closing

PURPOSE
Morphological closing.
PROTOTYPE

#include "morpho/closing.hh"

Concrete(I) morpho::closing (const image<I>& input, const struct_elt<E>& se);
Concrete(I) morpho::fast::closing (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Compute the morphological closing of input using se as structural element.

SEE ALSO
morpho::erosion,
morpho::dilation,
morpho::closing.

EXAMPLE
 
 image2d<bin> im = load("object.pbm");
 save(morpho::closing(im, win_c8p()), "out.pbm");

{
object.pbm
d29036f63407c8744376e25651f8eabe-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::dilation

PURPOSE
Morphological dilation.
PROTOTYPE

#include "morpho/dilation.hh"

Concrete(I) morpho::dilation (const image<I>& input, const struct_elt<E>& se);
Concrete(I) morpho::fast::dilation (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
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

SEE ALSO
morpho::n_dilation,
morpho::erosion.

EXAMPLE
 
 image2d<bin> im = load("object.pbm");
 save(morpho::dilation(im, win_c8p()), "out.pbm");

{
object.pbm
f1706d290e99025f279daa3c56b61d75-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::erosion

PURPOSE
Morphological erosion.
PROTOTYPE

#include "morpho/erosion.hh"

Concrete(I) morpho::erosion (const image<I>& input, const struct_elt<E>& se);
Concrete(I) morpho::fast::erosion (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Compute the morphological erosion of input using se as structural element.

On grey-scale images, each point is replaced by the minimum value of its neighbors, as indicated by se. On binary images, a logical and is performed between neighbors. The morpho::fast version of this function use a different

SEE ALSO
morpho::n_erosion,
morpho::dilation.

EXAMPLE
 
 image2d<bin> im = load("object.pbm");
 save(morpho::erosion(im, win_c8p()), "out.pbm");

{
object.pbm
13f70485fa1c9a58d832c856439292a8-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::external_gradient

PURPOSE
Morphological External Gradient.
PROTOTYPE

#include "morpho/gradient.hh"

mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::external_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::external_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::external_gradient (const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::fast::external_gradient (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute the arithmetic difference between and the dilatation of input using se as structural element, and the original image input. Soille, p67.

SEE ALSO
morpho::beucher_gradient,
morpho::internal_gradient,
morpho::dilation.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::external_gradient(im, win_c8p()), "out.pgm");

{
lena256.pgm
ef1128522df9164025e6315c461598ca-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::geodesic_dilation

PURPOSE
Geodesic dilation.
PROTOTYPE

#include "morpho/geodesic_dilation.hh"

Concrete(I1) morpho::geodesic_dilation (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the geodesic dilation of marker with respect to the mask mask image using se as structural element. Soille p.156. Note mask must be greater or equal than marker.

SEE ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<int_u8> dark = load("dark.pgm");
 save(morpho::geodesic_dilation(dark, light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::geodesic_erosion

PURPOSE
Geodesic erosion.
PROTOTYPE

#include "morpho/geodesic_erosion.hh"

Concrete(I1) morpho::geodesic_erosion (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the geodesic erosion of marker with respect to the mask mask image using se as structural element. Soille p.158. Note marker must be greater or equal than mask.

SEE ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<int_u8> dark = load("dark.pgm");
 save(morpho::geodesic_erosion(light, dark, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hit_or_miss

PURPOSE
Hit_or_Miss Transform.
PROTOTYPE

#include "morpho/hit_or_miss.hh"

typename mute<_I, typename convoutput<C, Value(_I)>::ret>::ret
morpho::hit_or_miss (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2); typename mute<_I, typename convoutput<C, Value(_I)>::ret>::ret
morpho::fast::hit_or_miss (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2); Concrete(I) morpho::hit_or_miss (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2); Concrete(I) morpho::fast::hit_or_miss (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);

PARAMETERS
c IN conversion object
input IN input image
se1 IN structural element
se2 IN structural element

DESCRIPTION
Compute the hit_or_miss transform of input by the composite structural element (se1, se2). Soille p.131.

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.

EXAMPLE
 
 image2d<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");

{
object.pbm
ff97734993ff4b71387a4a41eb3b8dbc-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hit_or_miss_closing

PURPOSE
Hit_or_Miss closing.
PROTOTYPE

#include "morpho/hit_or_miss.hh"

Concrete(I) morpho::hit_or_miss_closing (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);
Concrete(I) morpho::fast::hit_or_miss_closing (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);

PARAMETERS
input IN input image
se1 IN structural element
se2 IN structural element

DESCRIPTION
Compute the hit_or_miss closing of input by the composite structural element (se1, se2). This is the dual transformation of hit-or-miss opening with respect to set complementation. Soille p.135.

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.

SEE ALSO
morpho::hit_or_miss,
morpho::hit_or_miss_closing_bg,
morpho::hit_or_miss_opening,
morpho::hit_or_miss_opening_bg.

EXAMPLE
 
 image2d<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");

{
object.pbm
38b1ff1541813b3579fe700bd2be49a8-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hit_or_miss_closing_bg

PURPOSE
Hit_or_Miss closing of background.
PROTOTYPE

#include "morpho/hit_or_miss.hh"

Concrete(I) morpho::hit_or_miss_closing_bg (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);
Concrete(I) morpho::fast::hit_or_miss_closing_bg (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);

PARAMETERS
input IN input image
se1 IN structural element
se2 IN structural element

DESCRIPTION
Compute the hit_or_miss closing of the background of input by the composite structural element (se1, se2). This is the dual transformation of hit-or-miss opening with respect to set complementation. Soille p.135.

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.

SEE ALSO
morpho::hit_or_miss,
morpho::hit_or_miss_closing,
morpho::hit_or_miss_opening,
morpho::hit_or_miss_opening_bg.

EXAMPLE
 
 image2d<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");

{
object.pbm
b5e879af2d26751655668b09e5e4658b-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hit_or_miss_opening

PURPOSE
Hit_or_Miss opening.
PROTOTYPE

#include "morpho/hit_or_miss.hh"

Concrete(I) morpho::hit_or_miss_opening (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);
Concrete(I) morpho::fast::hit_or_miss_opening (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);

PARAMETERS
input IN input image
se1 IN structural element
se2 IN structural element

DESCRIPTION
Compute the hit_or_miss opening of input by the composite structural element (se1, se2). Soille p.134.

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.

SEE ALSO
morpho::hit_or_miss,
morpho::hit_or_miss_closing,
morpho::hit_or_miss_closing_bg,
morpho::hit_or_miss_opening_bg.

EXAMPLE
 
 image2d<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");

{
object.pbm
674bbf23a0ae62fb1727c6c1959802bf-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hit_or_miss_opening_bg

PURPOSE
Hit_or_Miss opening of background.
PROTOTYPE

#include "morpho/hit_or_miss.hh"

Concrete(I) morpho::hit_or_miss_opening_bg (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);
Concrete(I) morpho::fast::hit_or_miss_opening_bg (const image<I>& input, const struct_elt<E>& se1, const struct_elt<E>& se2);

PARAMETERS
input IN input image
se1 IN structural element
se2 IN structural element

DESCRIPTION
Compute the hit_or_miss opening of the background of input by the composite structural element (se1, se2). Soille p.135.

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.

SEE ALSO
morpho::hit_or_miss,
morpho::hit_or_miss_closing,
morpho::hit_or_miss_closing_bg,
morpho::hit_or_miss_opening.

EXAMPLE
 
 image2d<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");

{
object.pbm
77e10533b1537dd9e3090cbe89187a23-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hybrid_geodesic_reconstruction_dilation

PURPOSE
Geodesic reconstruction by dilation.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::hybrid_geodesic_reconstruction_dilation (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by dilation of marker with respect to the mask mask image using 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 ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hybrid_geodesic_reconstruction_erosion

PURPOSE
Geodesic reconstruction by erosion.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::hybrid_geodesic_reconstruction_erosion (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by erosion of marker with respect to the mask mask image using 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 ALSO
morpho::simple_geodesic_erosion.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hybrid_minima_imposition

PURPOSE
Minima Imposition.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::hybrid_minima_imposition (const image<I1>& input, const image<I2>& minima_map, const struct_elt<E>& se);

PARAMETERS
input IN input image
minima_map IN bin image
se IN structural element

DESCRIPTION
Impose minima defined by minima_map on input using se as structural element. Soille p.172. minima_map must be a bin image (true for a minimum, false for a non minimum). The algorithm uses hybrid_geodesic_reconstruction_erosion.

SEE ALSO
morpho::hybrid_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<bin> minima = load("minima.pbm");
 save(morpho::hybrid_minima_imposition(light, minima, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::hybrid_regional_minima

PURPOSE
Regional minima.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::hybrid_regional_minima (const image<I1>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Extract regional minima of input using se as structural element. Soille p.169. The algorithm uses hybrid_geodesic_reconstruction_erosion.

SEE ALSO
morpho::hybrid_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(morpho::hybrid_minima_imposition(light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::internal_gradient

PURPOSE
Morphological Internal Gradient.
PROTOTYPE

#include "morpho/gradient.hh"

mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::internal_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::internal_gradient (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::internal_gradient (const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::fast::internal_gradient (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute the arithmetic difference between the original image input and the erosion of input using se as structural element. Soille, p67.

SEE ALSO
morpho::beucher_gradient,
morpho::external_gradient,
morpho::erosion.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::internal_gradient(im, win_c8p()), "out.pgm");

{
lena256.pgm
23d043a9f9ad07232988f5746628a8cb-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::laplacian

PURPOSE
Laplacian.
PROTOTYPE

#include "morpho/laplacian.hh"

typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::laplacian (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::laplacian (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, Value(I)::slarger_t>::ret
morpho::laplacian (const image<I>& input, const struct_elt<E>& se); typename mute<I, Value(I)::slarger_t>::ret
morpho::fast::laplacian (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute the laplacian of input using se as structural element.

SEE ALSO
morpho::dilation,
morpho::erosion.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::laplacian(convert::bound<int_u8>(), im, win_c8p()), "out.pgm");

{
lena256.pgm
4da0cbf9abc246077548e7f09c6c7bd5-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::n_dilation

PURPOSE
Morphological dilation itered n times.
PROTOTYPE

#include "morpho/dilation.hh"

Concrete(I) morpho::n_dilation (const image<I>& input, const struct_elt<E>& se, unsigned n);

PARAMETERS
input IN input image
se IN structural element
n IN number of iterations

DESCRIPTION
Apply morpho::dilation n times.

SEE ALSO
morpho::dilation,
morpho::n_erosion.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::n_erosion

PURPOSE
Morphological erosion itered n times.
PROTOTYPE

#include "morpho/erosion.hh"

Concrete(I) morpho::n_erosion (const image<I>& input, const struct_elt<E>& se, unsigned n);

PARAMETERS
input IN input image
se IN structural element
n IN number of iterations

DESCRIPTION
Apply morpho::erosion n times.

SEE ALSO
morpho::erosion,
morpho::n_dilation.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::opening

PURPOSE
Morphological opening.
PROTOTYPE

#include "morpho/opening.hh"

Concrete(I) morpho::opening (const image<I>& input, const struct_elt<E>& se);
Concrete(I) morpho::fast::opening (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Compute the morphological opening of input using se as structural element.

SEE ALSO
morpho::erosion,
morpho::dilation,
morpho::closing.

EXAMPLE
 
 image2d<bin> im = load("object.pbm");
 save(morpho::opening(im, win_c8p()), "out.pbm");

{
object.pbm
28b70740642fc644d12469c6ab52876f-out.pbm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::self_complementary_top_hat

PURPOSE
Self complementary top hat.
PROTOTYPE

#include "morpho/top_hat.hh"

typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::self_complementary_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::self_complementary_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::self_complementary_top_hat (const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::self_complementary_top_hat (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute self complementary top hat of input using se as structural element. Soille p.106.

SEE ALSO
morpho::closing,
morpho::opening.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::self_complementary_top_hat(im, win_c8p()), "out.pgm");

{
lena256.pgm
f1653d170815764fa1f225379ceec968-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sequential_geodesic_reconstruction_dilation

PURPOSE
Geodesic reconstruction by dilation.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::sequential_geodesic_reconstruction_dilation (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by dilation of marker with respect to the mask mask image using 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 ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sequential_geodesic_reconstruction_erosion

PURPOSE
Geodesic reconstruction by erosion.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::sequential_geodesic_reconstruction_erosion (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by erosion of marker with respect to the mask mask image using 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 ALSO
morpho::simple_geodesic_erosion.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sequential_minima_imposition

PURPOSE
Minima Imposition.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::sequential_minima_imposition (const image<I1>& input, const image<I2>& minima_map, const struct_elt<E>& se);

PARAMETERS
input IN input image
minima_map IN bin image
se IN structural element

DESCRIPTION
Impose minima defined by minima_map on input using se as structural element. Soille p.172. The algorithm uses sequential_geodesic_reconstruction_erosion. minima_map must be a bin image (true for a minimum, false for a non minimum).

SEE ALSO
morpho::sequential_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<bin> minima = load("minima.pbm");
 save(morpho::sequential_minima_imposition(light, minima, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sequential_regional_minima

PURPOSE
Regional minima.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::sequential_regional_minima (const image<I1>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Extract regional minima of input using se as structural element. Soille p.169. The algorithm uses sequential_geodesic_reconstruction_erosion.

SEE ALSO
morpho::sequential_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(morpho::sequential_minima_imposition(light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::simple_geodesic_dilation

PURPOSE
Geodesic dilation.
PROTOTYPE

#include "morpho/geodesic_dilation.hh"

Concrete(I1) morpho::simple_geodesic_dilation (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the geodesic dilation 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). Note mask must be greater or equal than marker.

SEE ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::simple_geodesic_erosion

PURPOSE
Geodesic erosion.
PROTOTYPE

#include "morpho/geodesic_erosion.hh"

Concrete(I1) morpho::simple_geodesic_erosion (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
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). Note marker must be greater or equal than mask.

SEE ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<int_u8> dark = load("dark.pgm");
 save(morpho::geodesic_erosion(light, dark, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sure_geodesic_reconstruction_dilation

PURPOSE
Geodesic reconstruction by dilation.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::sure_geodesic_reconstruction_dilation (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by dilation of marker with respect to the mask mask image using se as structural element. Soille p.160. This is the simplest algorithm: iteration is performed until stability.

SEE ALSO
morpho::simple_geodesic_dilation.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sure_geodesic_reconstruction_erosion

PURPOSE
Geodesic reconstruction by erosion.
PROTOTYPE

#include "morpho/reconstruction.hh"

Concrete(I1) morpho::sure_geodesic_reconstruction_erosion (const image<I1>& marker, const image<I2>& mask, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
mask IN mask image
se IN structural element

DESCRIPTION
Compute the reconstruction by erosion of marker with respect to the mask mask image using se as structural element. Soille p.160. This is the simplest algorithm : iteration is performed until stability.

SEE ALSO
morpho::simple_geodesic_erosion.

EXAMPLE
 
 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");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sure_minima_imposition

PURPOSE
Minima Imposition.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::sure_minima_imposition (const image<I1>& input, const image<I2>& minima_map, const struct_elt<E>& se);

PARAMETERS
input IN input image
minima_map IN bin image
se IN structural element

DESCRIPTION
Impose minima defined by minima_map on input using se as structural element. Soille p.172. minima_map must be a bin image (true for a minimum, false for a non minimum). The algorithm uses sure_geodesic_reconstruction_erosion.

SEE ALSO
morpho::sure_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 image2d<bin> minima = load("minima.pbm");
 save(morpho::sure_minima_imposition(light, minima, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::sure_regional_minima

PURPOSE
Regional minima.
PROTOTYPE

#include "morpho/extrema.hh"

Concrete(_I) morpho::sure_regional_minima (const image<I1>& input, const struct_elt<E>& se);

PARAMETERS
input IN input image
se IN structural element

DESCRIPTION
Extract regional minima of input using se as structural element. Soille p.169. The algorithm uses sure_geodesic_reconstruction_erosion.

SEE ALSO
morpho::sure_geodesic_reconstruction_erosion.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(morpho::sure_minima_imposition(light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::top_hat_contrast_op

PURPOSE
Top hat contrastor operator.
PROTOTYPE

#include "morpho/top_hat.hh"

typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::top_hat_contrast_op (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::top_hat_contrast_op (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::top_hat_contrast_op (const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::top_hat_contrast_op (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Enhance contrast input by adding the white top hat, then substracting the black top hat to input. Top hats are computed using se as structural element. Soille p.109.

SEE ALSO
morpho::white_top_hat,
morpho::black_top_hat.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::top_hat_contrast_op(convert::bound<int_u8>(),
im, win_c8p()), "out.pgm");

{
lena256.pgm
ee6175e5826b4cdde225a26e9f630c1f-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::watershed_con

PURPOSE
Connected Watershed.
PROTOTYPE

#include "morpho/watershed.hh"

typename mute<I, DestValue>::ret
morpho::watershed_con<class DestValue> (const image<I>& im, const neighborhood<N>& ng);

PARAMETERS
DestValue type of output labels
im IN image of levels
ng IN neighborhood to consider

DESCRIPTION
Compute the connected watershed for image im using neighborhood ng.

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).

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.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::watershed_seg

PURPOSE
Segmented Watershed.
PROTOTYPE

#include "morpho/watershed.hh"

typename mute<I, DestValue>::ret
morpho::watershed_seg<class DestValue> (const image<I>& im, const neighborhood<N>& ng);

PARAMETERS
DestValue type of output labels
im IN image of levels
ng IN neighborhood to consider

DESCRIPTION
Compute the segmented watershed for image im using neighborhood ng.

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).

When there are more basins than DestValue can hold, wrapping occurs (i.e., the same label is used for several basin).


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::watershed_seg_or

PURPOSE
Segmented Watershed with user-supplied starting points.
PROTOTYPE

#include "morpho/watershed.hh"

Concrete(I2)& morpho::watershed_seg_or (const image<I1>& levels, image<I2>& markers, const neighborhood<N>& ng);

PARAMETERS
levels IN image of levels
markers IN OUT image of markers
ng IN neighborhood to consider

DESCRIPTION
Compute a segmented watershed for image levels using neighborhood ng, and markers as starting point for the flooding algorithm.

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 Value(I2)::min() (this is the unknown label) and mark the starting points or regions (usually these are minima in levels) using a value between Value(I2)::min()+1 and Value(I2)::max()-1.

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 Value(I2)::max(). markers should not contains any Value(I2)::min() value on output.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

morpho::white_top_hat

PURPOSE
White top hat.
PROTOTYPE

#include "morpho/top_hat.hh"

typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::white_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); typename mute<I, typename convoutput<C, Value(I)>::ret>::ret
morpho::fast::white_top_hat (const conversion<C>& c, const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::white_top_hat (const image<I>& input, const struct_elt<E>& se); Concrete(I) morpho::fast::white_top_hat (const image<I>& input, const struct_elt<E>& se);

PARAMETERS
c IN conversion object
input IN input image
se IN structural element

DESCRIPTION
Compute white top hat of input using se as structural element. Soille p.105.

SEE ALSO
morpho::opening.

EXAMPLE
 
 image2d<int_u8> im = load("lena256.pgm");
 save(morpho::white_top_hat(im, win_c8p()), "out.pgm");

{
lena256.pgm
8b3fd738e549881dd83b6ea5954c2a69-out.pgm
}


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

2.2 Level processings

level::connected_component  Connected Component.
level::fast_maxima_killer  Maxima killer.
level::fast_minima_killer  Minima killer.
level::frontp_connected_component  Connected Component.
level::sure_maxima_killer  Maxima killer.
level::sure_minima_killer  Minima killer.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::connected_component

PURPOSE
Connected Component.
PROTOTYPE

#include "level/connected.hh"

typename mute<_I, DestType>::ret
level::connected_component (const image<I1>& marker, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
se IN structural element

DESCRIPTION
It removes the small (in area) connected components of the upper level sets of input using se as structural element. The implementation comes from Cocquerez et Philipp, Analyse d'images, filtrages et segmentations p.62.

SEE ALSO
level::frontp_connected_component.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::connected_component<int_u8>(light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::fast_maxima_killer

PURPOSE
Maxima killer.
PROTOTYPE

#include "level/extrema_killer.hh"

Concrete(_I1) level::fast_maxima_killer (const image<I1>& marker, const unsigned int area area, const neighborhood<_N>& Ng);

PARAMETERS
marker IN marker image
area IN area
Ng IN neighboorhood

DESCRIPTION
It removes the small (in area) connected components of the upper level sets of input using Ng as neighboorhood. The implementation is based on stak. Guichard and Morel, Image iterative smoothing and PDE's. Book in preparation. p 265.

SEE ALSO
level::sure_maxima_killer.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::fast_maxima_killer(light, 20, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::fast_minima_killer

PURPOSE
Minima killer.
PROTOTYPE

#include "level/extrema_killer.hh"

Concrete(_I1) level::fast_minima_killer (const image<I1>& marker, const unsigned int area area, const neighborhood<_N>& Ng);

PARAMETERS
marker IN marker image
area IN area
Ng IN neighboorhood

DESCRIPTION
It removes the small (in area) connected components of the lower level sets of input using Ng as neighboorhood. The implementation is based on stak. Guichard and Morel, Image iterative smoothing and PDE's. Book in preparation. p 265.

SEE ALSO
level::sure_minima_killer.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::fast_minima_killer(light, 20, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::frontp_connected_component

PURPOSE
Connected Component.
PROTOTYPE

#include "level/cc.hh"

typename mute<I, DestType>::ret
level::frontp_connected_component (const image<I1>& marker, const neighborhood<E>& se);

PARAMETERS
marker IN marker image
se IN neighbourhood

DESCRIPTION
It removes the small (in area) connected components of the upper level sets of input using se as structural element. The implementation uses front propagation.

SEE ALSO
level::connected_component.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::frontp_connected_component<int_u16>(light, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::sure_maxima_killer

PURPOSE
Maxima killer.
PROTOTYPE

#include "level/extrema_killer.hh"

Concrete(I1) level::sure_maxima_killer (const image<I1>& marker, const unsigned int area area, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
area IN area
se IN structural element

DESCRIPTION
It removes the small (in area) connected components of the upper 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.

SEE ALSO
level::fast_maxima_killer.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::sure_maxima_killer(light, 20, win_c8p()), "out.pgm");


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

level::sure_minima_killer

PURPOSE
Minima killer.
PROTOTYPE

#include "level/extrema_killer.hh"

Concrete(I1) level::sure_minima_killer (const image<I1>& marker, const unsigned int area area, const struct_elt<E>& se);

PARAMETERS
marker IN marker image
area IN area
se IN structural element

DESCRIPTION
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.

SEE ALSO
level::fast_maxima_killer.

EXAMPLE
 
 image2d<int_u8> light = load("light.pgm");
 save(level::sure_minima_killer(light, 20, win_c8p()), "out.pgm");


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Alexandre Duret-Lutz on January, 14 2002 using texi2html