Namespaces | Functions | Variables

mln::make Namespace Reference

Namespace of routines that help to make Milena's objects. More...

Namespaces

namespace  impl
namespace  internal

Functions

template<unsigned D, typename G , typename V >
p_set< complex_psite< D, G > > attachment (const complex_psite< D, G > &f, const complex_image< D, G, V > &ima)
 Compute the attachment of the cell corresponding to the facet f to the image ima.
mln::box1d box1d (def::coord min_ind, def::coord max_ind)
 Create an mln::box1d.
mln::box1d box1d (unsigned ninds)
 Create an mln::box1d.
mln::box2d box2d (unsigned nrows, unsigned ncols)
 Create an mln::box2d.
mln::box2d box2d (def::coord min_row, def::coord min_col, def::coord max_row, def::coord max_col)
 Create an mln::box2d.
mln::box2d_h box2d_h (def::coord min_row, def::coord min_col, def::coord max_row, def::coord max_col)
 Create an mln::box2d_h.
mln::box2d_h box2d_h (unsigned nrows, unsigned ncols)
 Create an mln::box2d_h.
mln::box3d box3d (unsigned nslis, unsigned nrows, unsigned ncols)
 Create an mln::box3d.
mln::box3d box3d (def::coord min_sli, def::coord min_row, def::coord min_col, def::coord max_sli, def::coord max_row, def::coord max_col)
 Create an mln::box3d.
template<unsigned D, typename G >
p_set< complex_psite< D, G > > cell (const complex_psite< D, G > &f)
 Compute the set of faces of the cell corresponding to the facet f.
template<typename T , typename U >
util::couple< T, U > couple (const T &val1, const T &val2)
 Construct an mln::util::couple on-the-fly.
template<typename T , typename U >
util::couple< T, U > couple (const T &val1, const U &val2)
template<unsigned D, typename G , typename V >
p_set< complex_psite< D, G > > detachment (const complex_psite< D, G > &f, const complex_image< D, G, V > &ima)
 Compute the detachment of the cell corresponding to the facet f to the image ima.
template<typename F , unsigned St, unsigned Sf>
neighb< win::multiple
< window2d, F > > 		double_neighb2d (const F &test, bool const (&when_true)[St], bool const (&when_false)[Sf])
mln::dpoint2d_h dpoint2d_h (def::coord row, def::coord col)
 Create an mln::dpoint2d_h.
template<typename I , typename N >
neighb< win::multiple_size
< 2, mln_window(N), pw::value_
< I > > > 		dual_neighb (const Image< I > &ima, const Neighborhood< N > &nbh_true, const Neighborhood< N > &nbh_false)
template<typename G , typename P >
p_edges< G, pw::cst_< P > > dummy_p_edges (const Graph< G > &g_, const P &dummy_site)
 Create a p_edges which associate a graph element to a constant site.
template<typename G >
p_edges< G > dummy_p_edges (const Graph< G > &g)
 Create a p_edges which associate a graph element to a constant site.
template<typename G , typename P >
p_vertices< G, pw::cst_< P > > dummy_p_vertices (const Graph< G > &g_, const P &dummy_site)
 Create a p_vertices which associate a graph element to a constant site.
template<typename G >
p_vertices< G > dummy_p_vertices (const Graph< G > &g)
 Create a p_vertices which associate a graph element to a constant site.
template<typename V , typename G >
mln::edge_image< void, V, G > edge_image (const Graph< G > &g, const fun::i2v::array< V > &fv)
 Construct an edge image.
template<typename FP , typename FV , typename G >
mln::edge_image< typename
FP::result, typename
FV::result, G > 		edge_image (const Graph< G > &g_, const Function_v2v< FP > &fp, const Function_v2v< FV > &fv)
 Construct an edge image.
template<typename P , typename V , typename G , typename FP , typename FV >
mln::edge_image< typename
FP::result, typename
FV::result, G > 		edge_image (const mln::vertex_image< P, V, G > &v_ima_, const p_edges< G, FP > pe, const Function_vv2v< FV > &fv_)
 Construct an edge image.
template<typename P , typename V , typename G , typename FV >
mln::edge_image< void,
typename FV::result, G > 		edge_image (const mln::vertex_image< P, V, G > &v_ima_, const Function_vv2v< FV > &fv_)
 Construct an edge image.
template<typename T , unsigned N>
algebra::h_mat< mlc_sqrt_int(N),
T > 		h_mat (const T(&tab)[N])
 Create an mln::algebra::mat<n,n,T>.
template<typename V , unsigned L>
mln::image1d< V > image (V(&values)[L])
 Create an image1d from an 1D array of values.
template<typename V , unsigned R, unsigned C>
mln::image2d< V > image (V(&values)[R][C])
 Create an image2d from an 2D array of values.
template<typename V , unsigned S, unsigned R, unsigned C>
mln::image3d< V > image (V(&values)[S][R][C])
 Create an image3d from an 3D array of values.
template<typename V , unsigned S>
mln::image2d< V > image2d (V(&values)[S])
 Create an image2d from an 2D array of values.
template<typename I >
mln::image3d< typename I::value > image3d (const util::array< I > &ima)
 Create an image3d from an array of 2D images.
template<typename I >
mln::image3d< typename I::value > image3d (const Image< I > &ima)
 Create an image3d from a 2D image.
template<typename I , typename N >
util::graph influence_zone_adjacency_graph (const Image< I > &iz_, const Neighborhood< N > &nbh, const typename I::value &nlabels)
 Create a graph from an influence zone image.
template<typename I >
mln::labeled_image< I > labeled_image (const Image< I > &ima, const typename I::value &nlabels)
template<unsigned n, unsigned m, typename T >
algebra::mat< n, m, T > mat (const T(&tab)[n *m])
 Create an mln::algebra::mat<n,m,T>.
mln::w_window2d_float mk_chamfer_3x3_float (float d10, float d11)
template<int d10, int d11>
mln::w_window2d_int mk_chamfer_3x3_int ()
mln::w_window2d_float mk_chamfer_5x5_float (float d10, float d11, float d21)
template<int d10, int d11, int d21>
mln::w_window2d_int mk_chamfer_5x5_int ()
mln::w_window2d_float mk_chamfer_exact ()
template<unsigned S>
mln::neighb2d neighb2d (bool const (&vals)[S])
template<typename T >
util::ord_pair< T > ord_pair (const T &val1, const T &val2)
 Construct an mln::util::ord_pair on-the-fly.
template<typename W , typename G >
p_edges< G, fun::i2v::array
< util::site_pair< typename
W::site > > > 		p_edges_with_mass_centers (const Image< W > &wst_, const Graph< G > &g_)
 Construct a p_edges from a watershed image and a region adjacency graph (RAG).
template<typename W , typename G >
p_vertices< G, fun::i2v::array
< typename W::site > > 		p_vertices_with_mass_centers (const Image< W > &wst_, const Graph< G > &g_)
 Construct a p_vertices from a watershed image and a region adjacency graph (RAG).
template<typename I >
mln::util::pix< I > pix (const Image< I > &ima, const typename I::psite &p)
 Create an mln::util::pix from an image ima and a psite p.
template<typename I >
mln::pixel< const I > pixel (const Image< I > &ima, const typename I::psite &p)
 Create a mln::pixel from a constant image ima and a point p.
template<typename I >
mln::pixel< I > pixel (Image< I > &ima, const typename I::psite &p)
 Create a mln::pixel from a mutable image ima and a point p.
mln::point2d_h point2d_h (def::coord row, def::coord col)
 Create an mln::point2d_h.
template<typename I , typename N >
util::couple< util::graph,
typename mln::trait::concrete
< I >::ret > 		rag_and_labeled_wsl (const Image< I > &wshd_, const Neighborhood< N > &nbh_, const typename I::value &nbasins)
 Create a region adjacency graph and a label image of the watershed line from a watershed image.
template<typename I , typename N >
util::graph region_adjacency_graph (const Image< I > &wshd_, const Neighborhood< N > &nbh, const typename I::value &nbasins)
 Create a region adjacency graph from a watershed image.
template<typename V , typename F >
fun::i2v::array< V > relabelfun (const Function_v2b< F > &fv2b, const V &nlabels, V &new_nlabels)
 Create a i2v function from a v2b function.
template<typename V , typename F >
fun::i2v::array< V > relabelfun (const Function_v2v< F > &fv2v, const V &nlabels, V &new_nlabels)
 Create a i2v function from a v2v function.
template<typename T >
algebra::vec< 4, T > vec (const T &v_0, const T &v_1, const T &v_2, const T &v_3)
 Create an mln::algebra::vec<4,T>.
template<typename T >
algebra::vec< 1, T > vec (const T &v_0)
 Create an mln::algebra::vec<n,T>.
template<typename T >
algebra::vec< 3, T > vec (const T &v_0, const T &v_1, const T &v_2)
 Create an mln::algebra::vec<3,T>.
template<typename T >
algebra::vec< 2, T > vec (const T &v_0, const T &v_1)
 Create an mln::algebra::vec<2,T>.
template<typename FP , typename FV , typename G >
mln::vertex_image< typename
FP::result, typename
FV::result, G > 		vertex_image (const Graph< G > &g_, const Function_v2v< FP > &fp, const Function_v2v< FV > &fv)
 Construct a vertex image.
template<typename G , typename FV >
mln::vertex_image< void,
typename FV::result, G > 		vertex_image (const Graph< G > &g, const Function_v2v< FV > &fv)
 Construct a vertex image.
template<typename I , typename N >
p_vertices< util::graph,
fun::i2v::array< typename
I::site > > 		voronoi (Image< I > &ima_, Image< I > &orig_, const Neighborhood< N > &nbh)
 Apply the Voronoi algorithm on ima_ with the original image orig_ for node computing with neighborhood nbh.
template<typename W , typename F >
mln::w_window< typename
W::dpsite, typename F::result > 		w_window (const Window< W > &win, const Function_v2v< F > &wei)
 Create a mln::w_window from a window and a weight function.
template<typename W , unsigned M>
mln::w_window< mln::dpoint1d, W > w_window1d (W(&weights)[M])
 Create a 1D mln::w_window from an array of weights.
template<unsigned M>
mln::w_window1d_int w_window1d_int (int(&weights)[M])
 Create a mln::w_window1d_int.
template<typename W , unsigned S>
mln::w_window< mln::dpoint2d, W > w_window2d (W(&weights)[S])
 Create a 2D mln::w_window from an array of weights.
template<unsigned M>
mln::w_window2d_int w_window2d_int (int(&weights)[M])
 Create a mln::w_window2d_int.
template<typename W , unsigned M>
mln::w_window< mln::dpoint3d, W > w_window3d (W(&weights)[M])
 Create a 3D mln::w_window from an array of weights.
template<unsigned M>
mln::w_window3d_int w_window3d_int (int(&weights)[M])
 Create a mln::w_window3d_int.
template<typename D , typename W , unsigned L>
mln::w_window< D, W > w_window_directional (const Gdpoint< D > &dp, W(&weights)[L])
 Create a directional centered weighted window.

Variables

neighb< win::multiple
< window2d, bool(*)(A)> > 		double_neighb2d (bool(*test)(A), bool const (&when_true)[St], bool const (&when_false)[Sf])

Detailed Description

Namespace of routines that help to make Milena's objects.

Function Documentation

template<unsigned D, typename G , typename V >
p_set< complex_psite< D, G > > mln::make::attachment ( const complex_psite< D, G > &  f,
const complex_image< D, G, V > &  ima 
) [inline]

Compute the attachment of the cell corresponding to the facet f to the image ima.

Precondition:
f is a facet (it does not belong to any face of higher dimension).
ima is an image of Boolean values.
Returns:
a set of faces containing the attachment.

We do not use the fomal definition of the attachment here (see couprie.08.pami). We use the following (equivalent) definition: an N-face F in CELL is in the attachment of CELL to IMA if it is adjacent to at least an (N-1)-face or an (N+1)-face that does not belong to CELL.

References cell(), mln::internal::image_base< V, p_complex< D, G >, complex_image< D, G, V > >::has(), and mln::topo::is_facet().

Referenced by mln::topo::is_simple_cell< I >::operator()().

mln::box1d mln::make::box1d ( def::coord  min_ind,
def::coord  max_ind 
) [inline]

Create an mln::box1d.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
[in] min_ind Minimum index.
[in] max_ind Maximum index.
Precondition:
max_ind >= min_ind.
Returns:
A 1D box.

References box1d().

mln::box1d mln::make::box1d ( unsigned  ninds  )  [inline]

Create an mln::box1d.

Parameters:
[in] ninds Number of indices.
Precondition:
ninds != 0 and ncols != 0.
Returns:
A 1D box.

Referenced by box1d(), mln::convert::over_load::from_to_(), and mln::image1d< T >::image1d().

mln::box2d mln::make::box2d ( unsigned  nrows,
unsigned  ncols 
) [inline]

Create an mln::box2d.

Parameters:
[in] nrows Number of rows.
[in] ncols Number of columns.
Precondition:
nrows != 0 and ncols != 0.
Returns:
A 2D box.

Referenced by mln::world::inter_pixel::display_edge(), mln::world::binary_2d::impl::enlargex2(), mln::image2d< T >::image2d(), mln::io::pnm::load(), and mln::test_image().

mln::box2d mln::make::box2d ( def::coord  min_row,
def::coord  min_col,
def::coord  max_row,
def::coord  max_col 
) [inline]

Create an mln::box2d.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
[in] min_row Index of the top most row.
[in] min_col Index of the left most column.
[in] max_row Index of the botton most row.
[in] max_col Index of the right most column.
Precondition:
max_row >= min_row and max_col >= min_col.
Returns:
A 2D box.
mln::box2d_h mln::make::box2d_h ( def::coord  min_row,
def::coord  min_col,
def::coord  max_row,
def::coord  max_col 
) [inline]

Create an mln::box2d_h.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
[in] min_row Index of the top most row.
[in] min_col Index of the left most column.
[in] max_row Index of the botton most row.
[in] max_col Index of the right most column.
Precondition:
max_row >= min_row and max_col >= min_col.
Returns:
A 2D_H box.

References point2d_h().

mln::box2d_h mln::make::box2d_h ( unsigned  nrows,
unsigned  ncols 
) [inline]

Create an mln::box2d_h.

Parameters:
[in] nrows Number of rows.
[in] ncols Number of columns.
Precondition:
nrows != 0 and ncols != 0.
Returns:
A 2D_H box.

References point2d_h().

mln::box3d mln::make::box3d ( unsigned  nslis,
unsigned  nrows,
unsigned  ncols 
) [inline]

Create an mln::box3d.

Parameters:
[in] nslis Number of slices.
[in] nrows Number of rows.
[in] ncols Number of columns.
Precondition:
ninds != 0 and ncols != 0 and nslis != 0.
Returns:
A 3D box.

Referenced by image3d(), and mln::image3d< T >::image3d().

mln::box3d mln::make::box3d ( def::coord  min_sli,
def::coord  min_row,
def::coord  min_col,
def::coord  max_sli,
def::coord  max_row,
def::coord  max_col 
) [inline]

Create an mln::box3d.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
[in] min_sli Index of the lowest slice.
[in] min_row Index of the top most row.
[in] min_col Index of the left most column.
[in] max_sli Index of the highest slice.
[in] max_row Index of the botton most row.
[in] max_col Index of the right most column.
Precondition:
max_sli >= min_sli.
max_row >= min_row.
max_col >= min_col.
Returns:
A 3D box.
template<unsigned D, typename G >
p_set< complex_psite< D, G > > mln::make::cell ( const complex_psite< D, G > &  f  )  [inline]

Compute the set of faces of the cell corresponding to the facet f.

Precondition:
f is a facet (it does not belong to any face of higher dimension).
Returns:
An mln::p_set of sites (faces) containing the attachment.

References mln::topo::is_facet(), and mln::complex_psite< D, G >::n().

Referenced by attachment(), and detachment().

template<typename T , typename U >
util::couple<T,U> mln::make::couple ( const T &  val1,
const T &  val2 
)

Construct an mln::util::couple on-the-fly.

Referenced by mln::transform::distance_and_closest_point_geodesic(), mln::transform::distance_and_influence_zone_geodesic(), and mln::make::impl::generic::rag_and_labeled_wsl().

template<typename T , typename U >
util::couple<T,U> mln::make::couple ( const T &  val1,
const U &  val2 
) [inline]
template<unsigned D, typename G , typename V >
p_set< complex_psite< D, G > > mln::make::detachment ( const complex_psite< D, G > &  f,
const complex_image< D, G, V > &  ima 
) [inline]

Compute the detachment of the cell corresponding to the facet f to the image ima.

Precondition:
f is a facet (it does not belong to any face of higher dimension).
ima is an image of Boolean values.
Returns:
a set of faces containing the detachment.

We do not use the fomal definition of the detachment here (see couprie.08.pami). We use the following (equivalent) definition: an N-face F in CELL is not in the detachment of CELL from IMA if it is adjacent to at least an (N-1)-face or an (N+1)-face that does not belong to CELL.

References cell(), mln::internal::image_base< V, p_complex< D, G >, complex_image< D, G, V > >::has(), and mln::topo::is_facet().

Referenced by mln::topo::detach().

template<typename F , unsigned St, unsigned Sf>
neighb< win::multiple<window2d, F> > mln::make::double_neighb2d ( const F &  test,
bool const (&)  when_true[St],
bool const (&)  when_false[Sf] 
)
mln::dpoint2d_h mln::make::dpoint2d_h ( def::coord  row,
def::coord  col 
) [inline]

Create an mln::dpoint2d_h.

Parameters:
[in] row Row coordinate.
[in] col Column coordinate.
Returns:
A 2D dpoint.
template<typename I , typename N >
neighb< win::multiple_size< 2, mln_window(N), pw::value_< I > > > mln::make::dual_neighb ( const Image< I > &  ima,
const Neighborhood< N > &  nbh_true,
const Neighborhood< N > &  nbh_false 
) [inline]

References mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::pw::value().

template<typename G , typename P >
p_edges< G, pw::cst_< P > > mln::make::dummy_p_edges ( const Graph< G > &  g_,
const P &  dummy_site 
)

Create a p_edges which associate a graph element to a constant site.

Parameters:
[in] g_ A graph.
[in] dummy_site The dummy site mapped to graph edges.
Returns:
A p_edges.

References mln::pw::cst(), mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename G >
p_edges< G > mln::make::dummy_p_edges ( const Graph< G > &  g  ) 

Create a p_edges which associate a graph element to a constant site.

0 (int) is used as dummy site.

Parameters:
[in] g A graph.
Returns:
A p_edges.
template<typename G , typename P >
p_vertices< G, pw::cst_< P > > mln::make::dummy_p_vertices ( const Graph< G > &  g_,
const P &  dummy_site 
)

Create a p_vertices which associate a graph element to a constant site.

Parameters:
[in] g_ A graph.
[in] dummy_site The dummy site mapped to graph vertices.
Returns:
A p_vertices.

References mln::pw::cst(), mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename G >
p_vertices< G > mln::make::dummy_p_vertices ( const Graph< G > &  g  ) 

Create a p_vertices which associate a graph element to a constant site.

0 (int) is used as dummy site.

Parameters:
[in] g A graph.
Returns:
A p_vertices.
template<typename V , typename G >
mln::edge_image< void, V, G > mln::make::edge_image ( const Graph< G > &  g,
const fun::i2v::array< V > &  fv 
)

Construct an edge image.

Parameters:
[in] g A graph
[in] fv A function mapping edge ids to values.
Returns:
an edge image.

References mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename FP , typename FV , typename G >
mln::edge_image< typename FP::result, typename FV::result, G > mln::make::edge_image ( const Graph< G > &  g_,
const Function_v2v< FP > &  fp,
const Function_v2v< FV > &  fv 
)

Construct an edge image.

Parameters:
[in] g_ A graph
[in] fp A function mapping edge ids to sites.
[in] fv A function mapping edge ids to values.
Returns:
an edge image.

References mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename P , typename V , typename G , typename FP , typename FV >
mln::edge_image< typename FP::result, typename FV::result, G > mln::make::edge_image ( const mln::vertex_image< P, V, G > &  v_ima_,
const p_edges< G, FP >  pe,
const Function_vv2v< FV > &  fv_ 
)

Construct an edge image.

Parameters:
[in] v_ima_ A vertex image.
[in] pe A p_edges mapping graph element to sites .
[in] fv_ A function mapping two vertex ids to a value. The result is associated to the corresponding edge.
Returns:
an edge image.

References mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::internal::image_base< fun::i2v::array< V >::result, p_vertices< G, internal::vfsite_selector< P, G >::site_function_t >, vertex_image< P, V, G > >::is_valid().

template<typename P , typename V , typename G , typename FV >
mln::edge_image< void, typename FV::result, G > mln::make::edge_image ( const mln::vertex_image< P, V, G > &  v_ima_,
const Function_vv2v< FV > &  fv_ 
)

Construct an edge image.

Parameters:
[in] v_ima_ A vertex image.
[in] fv_ A function mapping two vertex ids to a value. The result is associated to the corresponding edge.
Returns:
an edge image without localization information mapped to graph elements.

References mln::pw::internal::image_base< fun::i2v::array< V >, p_vertices< G, internal::vfsite_selector< P, G >::site_function_t >, vertex_image< P, V, G > >::domain(), mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::internal::image_base< fun::i2v::array< V >::result, p_vertices< G, internal::vfsite_selector< P, G >::site_function_t >, vertex_image< P, V, G > >::is_valid().

template<typename T , unsigned N>
algebra::h_mat< mlc_sqrt_int(N), T > mln::make::h_mat ( const T(&)  tab[N]  )  [inline]

Create an mln::algebra::mat<n,n,T>.

Referenced by mln::fun::x2x::rotation< n, C >::rotation().

template<typename V , unsigned L>
mln::image1d< V > mln::make::image ( V(&)  values[L]  ) 

Create an image1d from an 1D array of values.

Parameters:
[in] values 1D array.
Returns:
A 1D image.
template<typename V , unsigned R, unsigned C>
mln::image2d< V > mln::make::image ( V(&)  values[R][C]  ) 

Create an image2d from an 2D array of values.

Parameters:
[in] values 2D array.
Returns:
A 2D image.

References mln::opt::at().

template<typename V , unsigned S, unsigned R, unsigned C>
mln::image3d< V > mln::make::image ( V(&)  values[S][R][C]  ) 

Create an image3d from an 3D array of values.

Parameters:
[in] values 3D array.
Returns:
A 3D image.

References mln::opt::at().

template<typename V , unsigned S>
mln::image2d< V > mln::make::image2d ( V(&)  values[S]  ) 

Create an image2d from an 2D array of values.

Parameters:
[in] values 2D array.
Returns:
A 2D image.

References mln::convert::from_to().

template<typename I >
mln::image3d< typename I::value > mln::make::image3d ( const util::array< I > &  ima  )  [inline]

Create an image3d from an array of 2D images.

References box3d(), mln::util::array< T >::is_empty(), mln::util::array< T >::nelements(), mln::data::paste(), mln::box< P >::pmax(), mln::box< P >::pmin(), and mln::slice().

Referenced by mln::io::pnms::load().

template<typename I >
mln::image3d< typename I::value > mln::make::image3d ( const Image< I > &  ima  )  [inline]

Create an image3d from a 2D image.

References box3d(), mln::exact(), mln::data::paste(), and mln::slice().

template<typename I , typename N >
util::graph mln::make::influence_zone_adjacency_graph ( const Image< I > &  iz_,
const Neighborhood< N > &  nbh,
const typename I::value &  nlabels 
) [inline]

Create a graph from an influence zone image.

Parameters:
[in] iz influence zone image.
[in] nbh A neighborhood.
[in] nlabels number of influence zone in iz.
Returns:
util::graph Graph based on the adjacency of the influence zones.

References mln::trace::entering(), mln::trace::exiting(), mln::make::internal::influence_zone_adjacency_graph_dispatch(), and mln::make::internal::influence_zone_adjacency_graph_tests().

Referenced by mln::make::internal::influence_zone_adjacency_graph_dispatch().

template<typename I >
mln::labeled_image< I > mln::make::labeled_image ( const Image< I > &  ima,
const typename I::value &  nlabels 
)

References mln::exact().

template<unsigned n, unsigned m, typename T >
algebra::mat< n, m, T > mln::make::mat ( const T(&)  tab[n *m]  )  [inline]

Create an mln::algebra::mat<n,m,T>.

Parameters:
[in] tab Array of values.
Precondition:
The array dimension has to be n * m.
mln::w_window2d_float mln::make::mk_chamfer_3x3_float ( float  d10,
float  d11 
) [inline]

References w_window2d().

template<int d10, int d11>
mln::w_window2d_int mln::make::mk_chamfer_3x3_int (  )  [inline]

References w_window2d().

mln::w_window2d_float mln::make::mk_chamfer_5x5_float ( float  d10,
float  d11,
float  d21 
) [inline]

References w_window2d().

template<int d10, int d11, int d21>
mln::w_window2d_int mln::make::mk_chamfer_5x5_int (  )  [inline]

References w_window2d().

mln::w_window2d_float mln::make::mk_chamfer_exact (  )  [inline]

References w_window2d().

template<unsigned S>
mln::neighb2d mln::make::neighb2d ( bool const (&)  vals[S]  )  [inline]

References mln::convert::from_to().

template<typename T >
util::ord_pair< T > mln::make::ord_pair ( const T &  val1,
const T &  val2 
) [inline]

Construct an mln::util::ord_pair on-the-fly.

Referenced by mln::util::internal::adjacency_matrix_impl_selector< V, metal::bool_< false > >::add(), mln::util::internal::adjacency_matrix_impl_selector< V, metal::bool_< false > >::are_adjacent(), and mln::util::internal::adjacency_matrix_impl_selector< V, metal::bool_< false > >::remove().

template<typename W , typename G >
p_edges< G, fun::i2v::array< util::site_pair< typename W::site > > > mln::make::p_edges_with_mass_centers ( const Image< W > &  wst_,
const Graph< G > &  g_ 
) [inline]

Construct a p_edges from a watershed image and a region adjacency graph (RAG).

Map each graph edge to a pair of mass centers of two adjacent regions.

Parameters:
wst_ A watershed image.
g_ A region adjacency graph.
Returns:
A p_edges.
See also:
edge_image, p_edges, make::region_adjacency_graph

References mln::labeling::compute(), mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename W , typename G >
p_vertices< G, fun::i2v::array< typename W::site > > mln::make::p_vertices_with_mass_centers ( const Image< W > &  wst_,
const Graph< G > &  g_ 
) [inline]

Construct a p_vertices from a watershed image and a region adjacency graph (RAG).

Map each graph vertex to the mass center of its corresponding region.

Parameters:
wst_ A watershed image.
g_ A region adjacency graph.
Returns:
A p_vertices.
See also:
edge_image, vertex_image, p_vertices, p_edges, make::region_adjacency_graph

References mln::labeling::compute(), mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::convert::from_to().

template<typename I >
mln::util::pix< I > mln::make::pix ( const Image< I > &  ima,
const typename I::psite &  p 
) [inline]

Create an mln::util::pix from an image ima and a psite p.

Parameters:
[in] ima The input image.
[in] p The point site.
Returns:
An mln::util::pix.

Referenced by mln::accu::impl::generic::compute(), mln::accu::impl::take(), mln::morpho::tree::internal::take_as_init(), and mln::canvas::morpho::impl::take_as_init().

template<typename I >
mln::pixel< const I > mln::make::pixel ( const Image< I > &  ima,
const typename I::psite &  p 
) [inline]

Create a mln::pixel from a constant image ima and a point p.

References mln::exact().

template<typename I >
mln::pixel< I > mln::make::pixel ( Image< I > &  ima,
const typename I::psite &  p 
) [inline]

Create a mln::pixel from a mutable image ima and a point p.

References mln::exact().

mln::point2d_h mln::make::point2d_h ( def::coord  row,
def::coord  col 
) [inline]

Create an mln::point2d_h.

Parameters:
[in] row Row coordinate.
[in] col Column coordinate.
Returns:
A 2D point.

Referenced by box2d_h().

template<typename I , typename N >
util::couple< util::graph, typename mln::trait::concrete< I >::ret > mln::make::rag_and_labeled_wsl ( const Image< I > &  wshd_,
const Neighborhood< N > &  nbh_,
const typename I::value &  nbasins 
) [inline]

Create a region adjacency graph and a label image of the watershed line from a watershed image.

Parameters:
[in] wshd_ Watershed image.
[in] nbh_ Neighborhood
[in] nbasins Number of influence zone in wshd.
Returns:
A couple. First element is the graph, second element is an image with a labeled watershed line.

	      |-----------------|		      |-----------------|
	      | 1 1 1 0 2 2 0 3 |                     | . . . 1 . . 2 . |
	      | 1 1 0 2 2 2 0 3 |                     | . . 1 . . . 2 . |
	      | 1 0 4 0 2 0 3 3 |           ---->     | . 1 . 3 . 4 . . |
	      | 0 4 4 4 0 5 0 3 |                     | 1 . . . 5 . 6 . |
	      |-----------------|                     |-----------------|

		Watershed image			      Labeled watershed line
	 (watershed line labeled with 0)


			|
			|
			|
			v

		  1 -- 2 - 3
		   \  /   /
		    4 -- 5

	    Region Adjacency graph (RAG)

References mln::trace::entering(), mln::trace::exiting(), mln::make::internal::rag_and_labeled_wsl_dispatch(), and mln::make::internal::rag_and_labeled_wsl_tests().

Referenced by mln::make::internal::rag_and_labeled_wsl_dispatch().

template<typename I , typename N >
util::graph mln::make::region_adjacency_graph ( const Image< I > &  wshd_,
const Neighborhood< N > &  nbh,
const typename I::value &  nbasins 
) [inline]

Create a region adjacency graph from a watershed image.

Parameters:
[in] wshd_ watershed image.
[in] nbh A neighborhood.
[in] nbasins number of influence zone in wshd.
Returns:
util::graph Graph based on the adjacency of the influence zones.

References mln::trace::entering(), mln::trace::exiting(), mln::make::internal::region_adjacency_graph_dispatch(), and mln::make::internal::region_adjacency_graph_tests().

Referenced by mln::make::internal::region_adjacency_graph_dispatch().

template<typename V , typename F >
fun::i2v::array< V > mln::make::relabelfun ( const Function_v2b< F > &  fv2b,
const V &  nlabels,
V &  new_nlabels 
) [inline]

Create a i2v function from a v2b function.

This function can be used to relabel a labeled image.

Parameters:
[in] fv2b A v2b function.
[in] nlabels The number of labels.
[in] new_nlabels The number of labels after relabeling.
Returns:
a i2v function.
See also:
mln::labeling::relabel

References mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::literal::zero.

Referenced by mln::labeling::pack(), mln::labeling::pack_inplace(), mln::labeling::relabel(), and mln::labeling::relabel_inplace().

template<typename V , typename F >
fun::i2v::array< V > mln::make::relabelfun ( const Function_v2v< F > &  fv2v,
const V &  nlabels,
V &  new_nlabels 
) [inline]

Create a i2v function from a v2v function.

This function can be used to relabel a labeled image.

Parameters:
[in] fv2v A v2v function. This function maps an id to an already existing one.
[in] nlabels The number of labels.
[in] new_nlabels The number of labels after relabeling.
Returns:
a i2v function.
See also:
mln::labeling::relabel

References mln::trace::entering(), mln::exact(), mln::trace::exiting(), and mln::literal::zero.

template<typename T >
algebra::vec< 4, T > mln::make::vec ( const T &  v_0,
const T &  v_1,
const T &  v_2,
const T &  v_3 
) [inline]

Create an mln::algebra::vec<4,T>.

Parameters:
[in] v_0 First coordinate.
[in] v_1 Second coordinate.
[in] v_2 Third coordinate.
[in] v_3 Fourth coordinate.
Returns:
A 4D vector.
template<typename T >
algebra::vec< 1, T > mln::make::vec ( const T &  v_0  )  [inline]

Create an mln::algebra::vec<n,T>.

Parameters:
[in] v_0 First coordinate.
Returns:
A 1D vector.

Referenced by mln::fun::x2x::rotation< n, C >::check_rotation().

template<typename T >
algebra::vec< 3, T > mln::make::vec ( const T &  v_0,
const T &  v_1,
const T &  v_2 
) [inline]

Create an mln::algebra::vec<3,T>.

Parameters:
[in] v_0 First coordinate.
[in] v_1 Second coordinate.
[in] v_2 Third coordinate.
Returns:
A 3D vector.
template<typename T >
algebra::vec< 2, T > mln::make::vec ( const T &  v_0,
const T &  v_1 
) [inline]

Create an mln::algebra::vec<2,T>.

Parameters:
[in] v_0 First coordinate.
[in] v_1 Second coordinate.
Returns:
A 2D vector.
template<typename FP , typename FV , typename G >
mln::vertex_image< typename FP::result, typename FV::result, G > mln::make::vertex_image ( const Graph< G > &  g_,
const Function_v2v< FP > &  fp,
const Function_v2v< FV > &  fv 
)

Construct a vertex image.

Parameters:
[in] g_ A graph.
[in] fp A function mapping vertex ids to sites.
[in] fv A function mapping vertex ids to values.
Returns:
A vertex image.

References mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename G , typename FV >
mln::vertex_image< void, typename FV::result, G > mln::make::vertex_image ( const Graph< G > &  g,
const Function_v2v< FV > &  fv 
)

Construct a vertex image.

Parameters:
[in] g A graph.
[in] fv A function mapping vertex ids to values.
Returns:
A vertex image.

References mln::trace::entering(), mln::exact(), and mln::trace::exiting().

template<typename I , typename N >
p_vertices< util::graph, fun::i2v::array< typename I::site > > mln::make::voronoi ( Image< I > &  ima_,
Image< I > &  orig_,
const Neighborhood< N > &  nbh 
) [inline]

Apply the Voronoi algorithm on ima_ with the original image orig_ for node computing with neighborhood nbh.

Parameters:
[in] ima_ The labeling image.
[in] orig_ The original image.
[in] nbh The neighborhood for computing algorithm.
Returns:
The computed graph.

Take original point.

Compute links between link.

Compute the center of label.

FIXME

Take original point.

Compute links between link.

Compute the center of label.

FIXME

References mln::util::graph::add_edge(), mln::util::graph::add_vertex(), mln::exact(), and mln::estim::min_max().

template<typename W , typename F >
mln::w_window< typename W::dpsite, typename F::result > mln::make::w_window ( const Window< W > &  win,
const Function_v2v< F > &  wei 
) [inline]

Create a mln::w_window from a window and a weight function.

Parameters:
[in] win A simple window.
[in] wei A weight function.
Returns:
A weighted window.

References mln::trace::entering(), mln::exact(), mln::trace::exiting(), mln::w_window< D, W >::insert(), and mln::literal::origin.

template<typename W , unsigned M>
mln::w_window< mln::dpoint1d, W > mln::make::w_window1d ( W(&)  weights[M]  )  [inline]

Create a 1D mln::w_window from an array of weights.

Parameters:
[in] weights Array.
Precondition:
The array size, M, has to be a square of an odd integer.
Returns:
A 1D weighted window.

References mln::w_window< D, W >::insert().

Referenced by w_window1d_int().

template<unsigned M>
mln::w_window1d_int mln::make::w_window1d_int ( int(&)  weights[M]  )  [inline]

Create a mln::w_window1d_int.

Parameters:
[in] weights Array of integers.
Precondition:
The array size, M, has to be a square of an odd integer.
Returns:
A 1D int-weighted window.

References w_window1d().

template<typename W , unsigned S>
mln::w_window< mln::dpoint2d, W > mln::make::w_window2d ( W(&)  weights[S]  )  [inline]

Create a 2D mln::w_window from an array of weights.

Parameters:
[in] weights Array.
Precondition:
The array size, S, has to be a square of an odd integer.
Returns:
A 2D weighted window.

References mln::convert::from_to().

Referenced by mk_chamfer_3x3_float(), mk_chamfer_3x3_int(), mk_chamfer_5x5_float(), mk_chamfer_5x5_int(), mk_chamfer_exact(), and w_window2d_int().

template<unsigned M>
mln::w_window2d_int mln::make::w_window2d_int ( int(&)  weights[M]  )  [inline]

Create a mln::w_window2d_int.

Parameters:
[in] weights Array of integers.
Precondition:
The array size, M, has to be a square of an odd integer.
Returns:
A 2D int-weighted window.

References w_window2d().

Referenced by mln::morpho::approx::impl::dilation_by_distance_thresholding_2d(), and mln::morpho::approx::impl::erosion_by_distance_thresholding_2d().

template<typename W , unsigned M>
mln::w_window< mln::dpoint3d, W > mln::make::w_window3d ( W(&)  weights[M]  )  [inline]

Create a 3D mln::w_window from an array of weights.

Parameters:
[in] weights Array.
Precondition:
The array size, M, has to be a cube of an odd integer.
Returns:
A 3D weighted window.

References mln::w_window< D, W >::insert().

Referenced by w_window3d_int().

template<unsigned M>
mln::w_window3d_int mln::make::w_window3d_int ( int(&)  weights[M]  )  [inline]

Create a mln::w_window3d_int.

Parameters:
[in] weights Array of integers.
Precondition:
The array size, M, has to be a cube of an odd integer.
Returns:
A 3D int-weighted window.

References w_window3d().

Referenced by mln::morpho::approx::impl::dilation_by_distance_thresholding_3d(), and mln::morpho::approx::impl::erosion_by_distance_thresholding_3d().

template<typename D , typename W , unsigned L>
mln::w_window< D, W > mln::make::w_window_directional ( const Gdpoint< D > &  dp,
W(&)  weights[L] 
) [inline]

Create a directional centered weighted window.

Parameters:
[in] dp A delta-point to set the orientation.
[in] weights An array of weights.
Returns:
A weighted window.

The window length L has to be odd.

References mln::exact(), mln::w_window< D, W >::insert(), and mln::literal::zero.

Variable Documentation

neighb< win::multiple< window2d, F > > mln::make::double_neighb2d [inline]

Referenced by mln::c6_2d(), mln::world::inter_pixel::e2c(), and mln::world::inter_pixel::e2e().

Generated on Thu Sep 8 2011 18:35:58 for Milena (Olena) by  doxygen 1.7.1