oln::morpho::fast Namespace Reference

Algorithm enhanced for large structuring elements. More...

Functions
template<class I, class N> oln::mute< I >::ret	card_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::card_type< unsigned > >::lambda_type &lambda)
	Perform a cardinal closing.
template<class I, class N> oln::mute< I >::ret	card_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::card_type< unsigned > >::lambda_type &lambda)
	Perform a cardinal opening.
template<class I, class N> oln::mute< I >::ret	integral_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::integral_type< unsigned > >::lambda_type &lambda)
	Perform an integral closing.
template<class I, class N> oln::mute< I >::ret	integral_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::integral_type< unsigned > >::lambda_type &lambda)
	Perform an integral opening.
template<class I, class N> oln::mute< I >::ret	height_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::height_type< unsigned > >::lambda_type &lambda)
	Perform a height closing.
template<class I, class N> oln::mute< I >::ret	height_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::height_type< unsigned > >::lambda_type &lambda)
	Perform a height closing.
template<class I, class N> oln::mute< I >::ret	maxvalue_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::maxvalue_type< unsigned > >::lambda_type &lambda)
	Perform a maxvalue closing.
template<class I, class N> oln::mute< I >::ret	maxvalue_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::maxvalue_type< unsigned > >::lambda_type &lambda)
	Perform a maxvalue opening.
template<class I, class N> oln::mute< I >::ret	minvalue_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::minvalue_type< unsigned > >::lambda_type &lambda)
	Perform a minvalue opening.
template<class I, class N> oln::mute< I >::ret	minvalue_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::minvalue_type< unsigned > >::lambda_type &lambda)
	Perform a minvalue closing.
template<class I, class N> oln::mute< I >::ret	ball_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::ball_type< I > >::lambda_type &lambda)
	Perform a ball opening.
template<class I, class N> oln::mute< I >::ret	ball_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::ball_type< I > >::lambda_type &lambda)
	Perform a ball closing.
template<class I, class N> oln::mute< I >::ret	dist_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::dist_type< I > >::lambda_type &lambda)
	Perform a dist opening.
template<class I, class N> oln::mute< I >::ret	dist_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::dist_type< I > >::lambda_type &lambda)
	Perform a dist closing.
template<class I, class N> oln::mute< I >::ret	cube_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::cube_type< I > >::lambda_type &lambda)
	Perform a cube closing.
template<class I, class N> oln::mute< I >::ret	cube_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::cube_type< I > >::lambda_type &lambda)
	Perform a cube opening.
template<class I, class N> oln::mute< I >::ret	box_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::box_type< I > >::lambda_type &lambda)
	Perform a box closing.
template<class I, class N> oln::mute< I >::ret	box_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &Ng, const typename oln::morpho::attr::attr_traits< attr::box_type< I > >::lambda_type &lambda)
	Perform a box opening.
template<class I, class E> oln::mute< I >::ret	closing (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Processing closing.
template<class I, class E> oln::mute< I >::ret	dilation (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
template<class I, class E> oln::mute< I >::ret	erosion (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Perform a morphological erosion.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	beucher_gradient (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Process a morphological beucher gradient.
template<class I, class E> oln::mute< I >::ret	external_gradient (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Process a morphological beucher gradient.
template<class C, class B, class I, class E1, class E2> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	hit_or_miss (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Preform a 'hit or miss' transform.
template<class I, class E1, class E2> oln::mute< I >::ret	hit_or_miss (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Preform a 'hit or miss' transform.
template<class I, class E1, class E2> oln::mute< I >::ret	hit_or_miss_opening (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Perform an hit or miss opening.
template<class I, class E1, class E2> oln::mute< I >::ret	hit_or_miss_opening_bg (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Perform an hit or miss opening of background.
template<class I, class E1, class E2> oln::mute< I >::ret	hit_or_miss_closing (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Perform an hit or miss closing.
template<class I, class E1, class E2> oln::mute< I >::ret	hit_or_miss_closing_bg (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Perform an hit or miss closing of background.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	laplacian (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the laplacian of an image.
template<class DestValue, class I, class E> mute< I, DestValue >::ret	laplacian (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the laplacian of an image.
template<class I, class E> oln::mute< I >::ret	opening (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Perform a morphological opening.
template<class I, class E1, class E2> oln::mute< I >::ret	thickening (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Thicken an image.
template<class I, class E1, class E2> oln::mute< I >::ret	thinning (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E1 > &se1, const abstract::struct_elt< E2 > &se2)
	Thin an image.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	white_top_hat (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the white top hat of an image.
template<class I, class E> oln::mute< I >::ret	white_top_hat (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the white top hat of an image.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	black_top_hat (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the black top hat of an image.
template<class I, class E> oln::mute< I >::ret	black_top_hat (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the black top hat of an image.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	self_complementary_top_hat (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the self complementary top hat of an image.
template<class I, class E> oln::mute< I >::ret	self_complementary_top_hat (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Compute the self complementary top hat of an image.
template<class C, class B, class I, class E> mute< I, typename convoutput< C, B, typename mlc::exact< I >::ret::value_type >::ret >::ret	top_hat_contrast_op (const convert::abstract::conversion< C, B > &c, const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Top hat contrast operator.
template<class I, class E> oln::mute< I >::ret	top_hat_contrast_op (const abstract::non_vectorial_image< I > &input, const abstract::struct_elt< E > &se)
	Top hat contrast operator.

---

Detailed Description

Algorithm enhanced for large structuring elements.

---

Function Documentation

template<class I, class N> oln::mute< I >::ret ball_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::ball_type< I > >::lambda_type &  lambda )

Perform a ball closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::ball_closing(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_ball_closing.ppm"); return 0; } => Definition at line 471 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret ball_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::ball_type< I > >::lambda_type &  lambda )

Perform a ball opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::ball_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_ball_opening.ppm"); return 0; } => Definition at line 443 of file attribute_closing_opening.hh. {

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret beucher_gradient (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Process a morphological beucher gradient. Compute the arithmetic difference between the diltation and the erosion of input using se as structural element. Soille, p67. c Conversion functor. input Image to process. se Structuring element. Definition at line 298 of file gradient.hh.

template<class I, class E> oln::mute< I >::ret black_top_hat (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the black top hat of an image. Parameters: I  Exact type of the image. E  Exact type of the structuring element. input Image to process. se Structuring element. #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"); } => Definition at line 619 of file top_hat.hh.

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret black_top_hat (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the black top hat of an image. Compute black top hat of input using se as structuring element. Soille p.105. c Conversion object. input Image to process. se Structuring element. #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"); } => Definition at line 577 of file top_hat.hh.

template<class I, class N> oln::mute< I >::ret box_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::box_type< I > >::lambda_type &  lambda )

Perform a box closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; ntg::vec<2, unsigned, mlc::final> lambda; lambda[0] = lambda[1] = 50; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::box_closing(im1, oln::neighb_c4(), lambda); oln::save(im1, IMG_OUT "oln_morpho_fast_box_closing.ppm"); return 0; } => Definition at line 612 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret box_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::box_type< I > >::lambda_type &  lambda )

Perform a box opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; ntg::vec<2, unsigned, mlc::final> lambda; lambda[0] = lambda[1] = 50; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::box_opening(im1, oln::neighb_c4(), lambda); oln::save(im1, IMG_OUT "oln_morpho_fast_box_opening.ppm"); return 0; } => Definition at line 641 of file attribute_closing_opening.hh.

template<class I, class N> oln::mute< I >::ret card_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::card_type< unsigned > >::lambda_type &  lambda )

Perform a cardinal closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.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")); im1 = oln::morpho::fast::card_closing(im1, oln::neighb_c4(), 200); oln::save(im1, IMG_OUT "oln_morpho_fast_card_closing.ppm"); return 0; } => Definition at line 166 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret card_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::card_type< unsigned > >::lambda_type &  lambda )

Perform a cardinal opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.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")); im1 = oln::morpho::fast::card_opening(im1, oln::neighb_c4(), 200); oln::save(im1, IMG_OUT "oln_morpho_fast_card_opening.ppm"); return 0; } => Definition at line 193 of file attribute_closing_opening.hh. {

template<class I, class E> oln::mute< I >::ret closing (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Processing closing. Compute the morphological closing of input using se as structuring element. Parameters: I  Exact type of the input image. E  Exact type of the structuring element. input Input image to close. se Structuring element to use. #include <oln/basics2d.hh> #include <oln/morpho/closing.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::closing(im1, oln::win_c8p()), IMG_OUT "oln_morpho_closing.pbm"); return 0; } => Definition at line 205 of file closing.hh.

template<class I, class N> oln::mute< I >::ret cube_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::cube_type< I > >::lambda_type &  lambda )

Perform a cube closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::cube_closing(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_cube_closing.ppm"); return 0; } => Definition at line 555 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret cube_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::cube_type< I > >::lambda_type &  lambda )

Perform a cube opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::cube_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_cube_opening.ppm"); return 0; } => Definition at line 583 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret dist_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::dist_type< I > >::lambda_type &  lambda )

Perform a dist closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::dist_closing(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_dist_closing.ppm"); return 0; } => Definition at line 527 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret dist_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::dist_type< I > >::lambda_type &  lambda )

Perform a dist opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::dist_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_dist_opening.ppm"); return 0; } => Definition at line 499 of file attribute_closing_opening.hh. {

template<class I, class E> oln::mute< I >::ret erosion (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Perform a morphological erosion. Compute the morphological erosion of input using se as structuring element. Parameters: I  Exact type of the input image. E  Exact type of the structuring element. input Input image. se Structuring element to use. #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::erosion(im1, oln::win_c8p()), IMG_OUT "oln_morpho_fast_erosion.pbm"); } => Definition at line 186 of file erosion.hh. { return fast_morpho<I, E, utils::histogram_min<oln_value_type(I)> > (input, se); }

template<class I, class E> oln::mute< I >::ret external_gradient (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Process a morphological beucher gradient. Parameters: I  Exact type of the input image. E  Exact type of the structuring element. Returns: The beucher gradient of the input. input Image to process. se Structuring element. #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_pgm.png \image latex lena128_pgm.png => \image html oln_morpho_beucher_gradient.png \image latex oln_morpho_beucher_gradient.png */ template<class I, class E> typename oln::mute< I >::ret beucher_gradient(const abstract::non_vectorial_image<I>& input, const abstract::struct_elt<E>& se) { return beucher_gradient(convert::force<typename mlc::exact< I >::ret::value_type>(), input, se); } template<class C, class B, class I, class E> typename mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret internal_gradient(const convert::abstract::conversion<C, B>& c, const abstract::non_vectorial_image<I>& input, const abstract::struct_elt<E>& se) { return arith::minus(c, input, erosion(input, se)); } template<class I, class E> typename oln::mute< I >::ret internal_gradient(const abstract::non_vectorial_image<I>& input, const abstract::struct_elt<E>& se) { return internal_gradient(convert::force<typename mlc::exact< I >::ret::value_type>(), input, se); } template<class C, class B, class I, class E> typename mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret external_gradient(const convert::abstract::conversion<C, B>& c, const abstract::non_vectorial_image<I>& input, const abstract::struct_elt<E>& se) { return arith::minus(c, dilation(input, se), input); } => Definition at line 471 of file gradient.hh.

template<class I, class N> oln::mute< I >::ret height_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::height_type< unsigned > >::lambda_type &  lambda )

Perform a height closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::height_closing(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_height_closing.ppm"); return 0; } => Definition at line 302 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret height_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::height_type< unsigned > >::lambda_type &  lambda )

Perform a height closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.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")); im1 = oln::morpho::fast::height_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_height_opening.ppm"); return 0; } => Definition at line 274 of file attribute_closing_opening.hh. {

template<class I, class E1, class E2> oln::mute< I >::ret hit_or_miss (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

Preform a 'hit or miss' transform. Parameters: I  Exact type of the input image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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::fast::hit_or_miss(im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss_overload.pbm"); } => Definition at line 587 of file hit_or_miss.hh.

template<class C, class B, class I, class E1, class E2> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret hit_or_miss (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

Preform a 'hit or miss' transform. c Conversion object. input Image to process. se1 First structuring element. se2 Second structuring element. Compute the hit_or_miss transform of input by the composite structuring 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 (although it is not increasing). Beware the result depends upon the image data type if it is not bin. #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::fast::hit_or_miss (oln::convert::bound<ntg::int_u8>(), im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss.pbm"); } => Definition at line 525 of file hit_or_miss.hh.

template<class I, class E1, class E2> oln::mute< I >::ret hit_or_miss_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

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. 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. Parameters: I  Exact type of the input image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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::fast::hit_or_miss_closing(im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss_closing.pbm"); } => Definition at line 777 of file hit_or_miss.hh.

template<class I, class E1, class E2> oln::mute< I >::ret hit_or_miss_closing_bg (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

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. 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. Parameters: I  Exact type of the input image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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::fast::hit_or_miss_closing_bg(im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss_closing_bg.pbm"); } => Definition at line 840 of file hit_or_miss.hh.

template<class I, class E1, class E2> oln::mute< I >::ret hit_or_miss_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

Perform an hit or miss opening. Compute the hit_or_miss opening of input by the composite structuring 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. Parameters: I  Exact type of the input image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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::fast::hit_or_miss_opening(im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss_opening.pbm"); } => Definition at line 651 of file hit_or_miss.hh.

template<class I, class E1, class E2> oln::mute< I >::ret hit_or_miss_opening_bg (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

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. 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. Parameters: I  Exact type of the input image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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::fast::hit_or_miss_opening_bg(im1, mywin, mywin2), IMG_OUT "oln_morpho_fast_hit_or_miss_opening_bg.pbm"); } => Definition at line 711 of file hit_or_miss.hh.

template<class I, class N> oln::mute< I >::ret integral_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::integral_type< unsigned > >::lambda_type &  lambda )

Perform an integral closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.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")); im1 = oln::morpho::fast::integral_closing(im1, oln::neighb_c4(), 200); oln::save(im1, IMG_OUT "oln_morpho_fast_integral_closing.ppm"); return 0; } => Definition at line 220 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret integral_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::integral_type< unsigned > >::lambda_type &  lambda )

Perform an integral opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.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")); im1 = oln::morpho::fast::integral_opening(im1, oln::neighb_c4(), 200); oln::save(im1, IMG_OUT "oln_morpho_fast_integral_opening.ppm"); return 0; } => Definition at line 247 of file attribute_closing_opening.hh. {

template<class DestValue, class I, class E> mute<I, DestValue>::ret laplacian (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the laplacian of an image. Compute the laplacian of input using se as structural element. input Image to process. se Structuring element. #include <oln/basics2d.hh> #include <oln/morpho/laplacian.hh> #include <oln/convert/stretch.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::image2d<ntg::int_s<10> > i10 = oln::morpho::fast::laplacian(oln::convert::bound<ntg::int_s<10> >(), im1, oln::win_c8p()); oln::image2d<ntg::int_s<10> > f10 = oln::morpho::fast::laplacian<ntg::int_s<10> >(im1, oln::win_c8p()); oln::save(apply(oln::convert::stretch<ntg::int_u8>(),(f10)), IMG_OUT "oln_morpho_fast_laplacian_overload.pgm"); } => Todo: FIXME: Not instantiated in swilena (see tools/swilena/generate_morpho_instantiations.py) Definition at line 285 of file laplacian.hh.

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret laplacian (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the laplacian of an image. Compute the laplacian of input using se as structural element. c Conversion object. input Image to process. se Structuring element. #include <oln/basics2d.hh> #include <oln/morpho/laplacian.hh> #include <oln/convert/stretch.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::image2d<ntg::int_s<10> > i10 = oln::morpho::fast::laplacian(oln::convert::bound<ntg::int_s<10> >(), im1, oln::win_c8p()); oln::save(apply(oln::convert::stretch<ntg::int_u8>(), i10), IMG_OUT "oln_morpho_fast_laplacian.pgm"); } => Definition at line 232 of file laplacian.hh.

template<class I, class N> oln::mute< I >::ret maxvalue_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::maxvalue_type< unsigned > >::lambda_type &  lambda )

Perform a maxvalue closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; 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.ppm"); return 0; } => Definition at line 331 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret maxvalue_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::maxvalue_type< unsigned > >::lambda_type &  lambda )

Perform a maxvalue opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::maxvalue_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_maxvalue_opening.ppm"); return 0; } => Definition at line 359 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret minvalue_closing (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::minvalue_type< unsigned > >::lambda_type &  lambda )

Perform a minvalue closing. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::minvalue_closing(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_minvalue_closing.ppm"); return 0; } => Definition at line 415 of file attribute_closing_opening.hh. {

template<class I, class N> oln::mute< I >::ret minvalue_opening (  const abstract::non_vectorial_image< I > &  input, const abstract::neighborhood< N > &  Ng, const typename oln::morpho::attr::attr_traits< attr::minvalue_type< unsigned > >::lambda_type &  lambda )

Perform a minvalue opening. #include <oln/basics2d.hh> #include <oln/morpho/attribute_closing_opening.hh> #include <oln/level/compare.hh> #include <ntg/all.hh> #include <iostream> int main() { typedef oln::image2d<ntg::int_u8> im_type; im_type im1(oln::load(IMG_IN "lena128.pgm")); im1 = oln::morpho::fast::minvalue_opening(im1, oln::neighb_c4(), 5); oln::save(im1, IMG_OUT "oln_morpho_fast_minvalue_opening.ppm"); return 0; } => Definition at line 387 of file attribute_closing_opening.hh. {

template<class I, class E> oln::mute< I >::ret opening (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Perform a morphological opening. Compute the morphological opening of input using se as structuring element. Parameters: I  Exact type of the input image. E  Exact type of the structuring element. input Image to process. se Structuring element. #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::fast::opening(im, oln::win_c8p()), IMG_OUT "oln_morpho_fast_opening.pbm"); } => Definition at line 174 of file opening.hh.

template<class I, class E> oln::mute< I >::ret self_complementary_top_hat (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the self complementary top hat of an image. c Conversion object. input Image to process. se Structuring element. #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"); } => Definition at line 709 of file top_hat.hh.

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret self_complementary_top_hat (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the self complementary top hat of an image. Compute self complementary top hat of input using se as structuring element. Soille p.106. c Conversion object. input Image to process. se Structuring element. #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"); } => Definition at line 669 of file top_hat.hh.

template<class I, class E1, class E2> oln::mute< I >::ret thickening (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

Thicken an image. Parameters: I  Exact type of the image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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; } => Definition at line 194 of file thickening.hh.

template<class I, class E1, class E2> oln::mute< I >::ret thinning (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E1 > &  se1, const abstract::struct_elt< E2 > &  se2 )

Thin an image. Parameters: I  Exact type of the image. E1  Exact type of the first structuring element. E2  Exact type of the second structuring element. input Image to process. se1 First structuring element. se2 Second structuring element. #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; } => Definition at line 194 of file thinning.hh.

template<class I, class E> oln::mute< I >::ret top_hat_contrast_op (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

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. input Image to process. se Structuring element. #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"); } => Definition at line 804 of file top_hat.hh.

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret top_hat_contrast_op (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

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. c Conversion object. input Image to process. se Structuring element. #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"); } => Definition at line 757 of file top_hat.hh.

template<class I, class E> oln::mute< I >::ret white_top_hat (  const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the white top hat of an image. Parameters: I  Exact type of the image. E  Exact type of the structuring element. input Image to process. se Structuring element. #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"); } => Definition at line 531 of file top_hat.hh.

template<class C, class B, class I, class E> mute<I, typename convoutput<C, B,typename mlc::exact< I >::ret::value_type>::ret>::ret white_top_hat (  const convert::abstract::conversion< C, B > &  c, const abstract::non_vectorial_image< I > &  input, const abstract::struct_elt< E > &  se )

Compute the white top hat of an image. Compute white top hat of input using se as structuring element. Soille p.105. c Conversion object. input Image to process. se Structuring element. #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"); } => Definition at line 490 of file top_hat.hh.

---