mln::make Namespace Reference

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

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 (def::coord min_row, def::coord min_col, def::coord max_row, def::coord max_col)
	Create an mln::box2d.
mln::box2d	box2d (unsigned nrows, unsigned ncols)
	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 (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.
mln::box3d	box3d (unsigned nslis, unsigned nrows, unsigned ncols)
	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<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 from the image ima.
mln::dpoint2d_h	dpoint2d_h (def::coord row, def::coord col)
	Create an mln::dpoint2d_h.
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_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_vertices< G >	dummy_p_vertices (const Graph< G > &g)
	Create a p_vertices 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 P, typename V, typename G, typename F>
mln::edge_image< void, bool, G >	edge_image (const mln::vertex_image< P, V, G > &v_ima_, const Function_v2b< F > &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 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 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 FV, typename G>
mln::edge_image< void, typename FV::result, G >	edge_image (const Graph< G > &g, const Function_v2v< FV > &fv)
	Construct an edge image.
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 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 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 R, unsigned C>
mln::image2d< V >	image (V(&values)[R][C])
	Create an image2d from an 2D array of values.
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 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 Image< I > &ima)
	Create an image3d from a 2D image.
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, 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<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>.
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< I >	pixel (Image< I > &ima, const typename I::psite &p)
	Create a mln::pixel from a mutable image ima and a point 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.
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_v2v< F > &fv2v, const V &nlabels, V &new_nlabels)
	Create a i2v function from a v2v function.
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 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< 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 T>
algebra::vec< 1, T >	vec (const T &v_0)
	Create an mln::algebra::vec<n,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.

---

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

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 mln::image1d< T >::image1d().

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 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::image2d< T >::image2d(), and mln::io::pnm::load().

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

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

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
	)			[inline]

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

Referenced by mln::labeling::blobs_and_compute(), mln::transform::distance_and_closest_point_geodesic(), and mln::transform::distance_and_influence_zone_geodesic().

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

Moreover, the term detachment does not correspond to the complex resulting from the collapsing of CELL onto IMA, but the part that is removed, i.e., the detached part CELL - ATTACHMENT. It would be wise to rename this routine to something else.

References cell(), and mln::topo::is_facet().

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

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 G>

p_edges< G > mln::make::dummy_p_edges

(

const Graph< G > &

g

)

[inline]

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_edges< G, pw::cst_< P > > mln::make::dummy_p_edges	(	const Graph< G > &	g_,
		const P &	dummy_site
	)			[inline]

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.

template<typename G>

p_vertices< G > mln::make::dummy_p_vertices

(

const Graph< G > &

g

)

[inline]

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 G, typename P>

p_vertices< G, pw::cst_< P > > mln::make::dummy_p_vertices	(	const Graph< G > &	g_,
		const P &	dummy_site
	)			[inline]

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.

template<typename P, typename V, typename G, typename F>

mln::edge_image< void, bool, G > mln::make::edge_image	(	const mln::vertex_image< P, V, G > &	v_ima_,
		const Function_v2b< F > &	fv_
	)			[inline]

Construct an edge image.

Parameters:

[in]	v_ima_	A vertex image.
[in]	fv_	A predicate on a vertex's value. The (Boolean) result is associated to the edges adjacent to the vertex.

Returns:

an edge image without localization information mapped to graph elements.

References mln::data::fill().

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_
	)			[inline]

Construct an edge image.

Parameters:

[in]	v_ima_	A vertex image.
[in]	fv_	A function mapping two vertices' values to a value. The result is associated to the corresponding edge.

Returns:

an edge image without localization information mapped to graph elements.

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_
	)			[inline]

Construct an edge image.

Parameters:

[in]	v_ima_	A vertex image.
[in]	pe	A p_edges mapping graph elements 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.

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
	)			[inline]

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.

template<typename FV, typename G>

mln::edge_image< void, typename FV::result, G > mln::make::edge_image	(	const Graph< G > &	g,
		const Function_v2v< FV > &	fv
	)			[inline]

Construct an edge image.

Parameters:

[in]	g	A graph.
[in]	fv	A function mapping edge ids to values.

Returns:

an edge image.

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
	)			[inline]

Construct an edge image.

Parameters:

[in]	g	A graph.
[in]	fv	A function mapping edge ids to values.

Returns:

an edge image.

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 S, unsigned R, unsigned C>

mln::image3d< V > mln::make::image

(

V(&)

values[S][R][C]

)

[inline]

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 R, unsigned C>

mln::image2d< V > mln::make::image

(

V(&)

values[R][C]

)

[inline]

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 L>

mln::image1d< V > mln::make::image

(

V(&)

values[L]

)

[inline]

Create an image1d from an 1D array of values.

Parameters:

[in]

values

1D array.

Returns:

A 1D image.

template<typename V, unsigned S>

mln::image2d< V > mln::make::image2d

(

V(&)

values[S]

)

[inline]

Create an image2d from an 2D array of values.

Parameters:

[in]

values

2D array.

Returns:

A 2D image.

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(), and mln::data::paste().

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(), and mln::box< P >::pmin().

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

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.

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.

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.

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.

References ord_pair().

Referenced by ord_pair().

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

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

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.

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.

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.

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)

	

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.

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::literal::zero.

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::literal::zero.

Referenced by mln::labeling::pack(), mln::labeling::pack_inplace(), mln::labeling::relabel(), mln::labeled_image_base< I, E >::relabel(), and mln::labeling::relabel_inplace().

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

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
	)			[inline]

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.

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
	)			[inline]

Construct a vertex image.

Parameters:

[in]	g	A graph.
[in]	fv	A function mapping vertex ids to values.

Returns:

A vertex image.

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.

References mln::util::graph::add_edge(), mln::util::graph::add_vertex(), 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::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.

Referenced by mln::linear::mln_ch_convolve(), 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().

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

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::w_window< D, W >::insert(), and mln::literal::zero.