Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

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 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 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 580 of file attribute_closing_opening_map.hh. 

00592 {

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_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 553 of file attribute_closing_opening_map.hh. 

00565 {

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_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 716 of file attribute_closing_opening_map.hh. 

00728 {

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_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 744 of file attribute_closing_opening_map.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<> >::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 284 of file attribute_closing_opening_map.hh. 

00295 {

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. 

 #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 310 of file attribute_closing_opening_map.hh. 

00321 {

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_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 661 of file attribute_closing_opening_map.hh. 

00673 {

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_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 688 of file attribute_closing_opening_map.hh. 

00700 {

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_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 634 of file attribute_closing_opening_map.hh. 

00646 {

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_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 607 of file attribute_closing_opening_map.hh. 

00619 {

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. 

 #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 417 of file attribute_closing_opening_map.hh. 

00430 {

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. 

 #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 390 of file attribute_closing_opening_map.hh. 

00402 {

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. 

 #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 337 of file attribute_closing_opening_map.hh. 

00348 {

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. 

 #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 364 of file attribute_closing_opening_map.hh. 

00375 {

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. 

 #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 445 of file attribute_closing_opening_map.hh. 

00457 {

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. 

 #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 472 of file attribute_closing_opening_map.hh. 

00484 {

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. 

 #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 526 of file attribute_closing_opening_map.hh. 

00538 {

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. 

 #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 499 of file attribute_closing_opening_map.hh. 

00511 {

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
) 
 

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       }

Generated on Thu Apr 15 20:17:00 2004 for Olena by doxygen 1.3.6-20040222