oln::morpho::slow Namespace Reference

Algorithm that are slow (but need less memory), or that are slow if it is used with a large structuring element. More...


Classes

struct  f_tarjan_map

Functions

template<class D, class I, class N>
oln::mute< I >::ret tarjan_map (bool is_closing, const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &ng, const typename oln::morpho::attr::attr_traits< D >::lambda_type &lambda, const typename oln::morpho::attr::attr_traits< D >::env_type &env)
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<> >::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<> >::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<> >::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<> >::lambda_type &lambda)
 Perform an integral opening.
template<class I, class N>
oln::mute< I >::ret volume_closing (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &ng, const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::lambda_type &lambda, const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::env_type &env)
 Perform an integral closing.
template<class I, class N>
oln::mute< I >::ret volume_opening (const abstract::non_vectorial_image< I > &input, const abstract::neighborhood< N > &ng, const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::lambda_type &lambda, const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::env_type &env)
 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<> >::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<> >::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<> >::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<> >::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<> >::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<> >::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.


Detailed Description

Algorithm that are slow (but need less memory), or that are slow if it is used with a large structuring element.

Function Documentation

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::ball_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_ball_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_ball_closing.png

Definition at line 661 of file attribute_closing_opening_map.hh.

00673 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::ball_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_ball_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_ball_opening.png

Definition at line 634 of file attribute_closing_opening_map.hh.

00646 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::box_closing(im1, oln::neighb_c4(), lambda);
   oln::save(im1, IMG_OUT "oln_morpho_slow_box_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_box_closing.png

Definition at line 797 of file attribute_closing_opening_map.hh.

00809 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::box_opening(im1, oln::neighb_c4(), lambda);
   oln::save(im1, IMG_OUT "oln_morpho_slow_box_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_box_opening.png

Definition at line 825 of file attribute_closing_opening_map.hh.

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

Perform a cardinal closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::card_closing(im1, oln::neighb_c4(), 200);
   oln::save(im1, IMG_OUT "oln_morpho_slow_card_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_card_closing.png

Definition at line 309 of file attribute_closing_opening_map.hh.

00320 {

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

Perform a cardinal opening.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::card_opening(im1, oln::neighb_c4(), 200);
   oln::save(im1, IMG_OUT "oln_morpho_slow_card_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_card_opening.png

Definition at line 335 of file attribute_closing_opening_map.hh.

00346 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::cube_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_cube_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_cube_closing.png

Definition at line 742 of file attribute_closing_opening_map.hh.

00754 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::cube_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_cube_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_cube_opening.png

Definition at line 769 of file attribute_closing_opening_map.hh.

00781 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::dist_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_dist_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_dist_closing.png

Definition at line 715 of file attribute_closing_opening_map.hh.

00727 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::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_map.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::slow::dist_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_dist_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_dist_opening.png

Definition at line 688 of file attribute_closing_opening_map.hh.

00700 {

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

Perform a height closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::height_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_height_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_height_closing.png

Definition at line 498 of file attribute_closing_opening_map.hh.

00511 {

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

Perform a height closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::height_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_height_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_height_opening.png

Definition at line 471 of file attribute_closing_opening_map.hh.

00483 {

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

Perform an integral closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::integral_closing(im1, oln::neighb_c4(),
                                             200);
   oln::save(im1, IMG_OUT "oln_morpho_slow_integral_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_integral_closing.png

Definition at line 362 of file attribute_closing_opening_map.hh.

00373 {

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

Perform an integral opening.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::integral_opening(im1, oln::neighb_c4(),
                                             200);
   oln::save(im1, IMG_OUT "oln_morpho_slow_integral_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_integral_opening.png

Definition at line 389 of file attribute_closing_opening_map.hh.

00400 {

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

Perform a maxvalue closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::maxvalue_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_maxvalue_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_maxvalue_closing.png

Definition at line 526 of file attribute_closing_opening_map.hh.

00538 {

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

Perform a maxvalue opening.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::maxvalue_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_maxvalue_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_maxvalue_opening.png

Definition at line 553 of file attribute_closing_opening_map.hh.

00565 {

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

Perform a minvalue closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::minvalue_closing(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_minvalue_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_minvalue_closing.png

Definition at line 607 of file attribute_closing_opening_map.hh.

00619 {

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

Perform a minvalue opening.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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::slow::minvalue_opening(im1, oln::neighb_c4(), 5);
   oln::save(im1, IMG_OUT "oln_morpho_slow_minvalue_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_minvalue_opening.png

Definition at line 580 of file attribute_closing_opening_map.hh.

00592 {

template<class D, class I, class N>
oln::mute< I >::ret oln::morpho::slow::tarjan_map ( bool  is_closing,
const abstract::non_vectorial_image< I > &  input,
const abstract::neighborhood< N > &  ng,
const typename oln::morpho::attr::attr_traits< D >::lambda_type &  lambda,
const typename oln::morpho::attr::attr_traits< D >::env_type &  env 
)

Attribute closing using map. Smaller memory usage, but slower computation than the attribute_closing_opening

See "Fast morphological attribute operations using Tarjan's union-find algorithm" by Michael H. F. Wilkinson and Jos B. T. M. Roerdink

Definition at line 195 of file attribute_closing_opening_map.hh.

References oln::morpho::slow::f_tarjan_map< I, D, Env >::res().

00200       {
00201         oln::morpho::slow::f_tarjan_map<I, D, attr_env_type(D) > t(is_closing,
00202                                                                    input,
00203                                                                    ng,
00204                                                                    lambda,
00205                                                                    env);
00206         return t.res();
00207       }

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::volume_closing ( const abstract::non_vectorial_image< I > &  input,
const abstract::neighborhood< N > &  ng,
const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::lambda_type &  lambda,
const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::env_type &  env 
)

Perform an integral closing.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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"));
   oln::morpho::env::OtherImageEnv<im_type>     env(im1);
   im1 = oln::morpho::slow::volume_closing(im1, oln::neighb_c4(),
                                           200, env);
   oln::save(im1, IMG_OUT "oln_morpho_slow_integral_closing.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_integral_closing.png

Definition at line 417 of file attribute_closing_opening_map.hh.

00428 {

template<class I, class N>
oln::mute< I >::ret oln::morpho::slow::volume_opening ( const abstract::non_vectorial_image< I > &  input,
const abstract::neighborhood< N > &  ng,
const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::lambda_type &  lambda,
const typename oln::morpho::attr::attr_traits< attr::volume_type< I > >::env_type &  env 
)

Perform an integral opening.

 #include <oln/basics2d.hh>
 #include <oln/morpho/attribute_closing_opening_map.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"));
   oln::morpho::env::OtherImageEnv<im_type>     env(im1);
   im1 = oln::morpho::slow::volume_opening(im1, oln::neighb_c4(),
                                           200, env);
   oln::save(im1, IMG_OUT "oln_morpho_slow_integral_opening.ppm");
 }
lena128_pgm.png
=>
oln_morpho_slow_integral_opening.png

Definition at line 445 of file attribute_closing_opening_map.hh.

00456 {


Generated on Tue Feb 20 20:29:18 2007 for Olena by  doxygen 1.5.1