mln::arith Namespace Reference

Namespace of arithmetic. More...

Namespaces
namespace	impl
	Implementation namespace of arith namespace.
Functions
template<typename I>
mln::trait::concrete< I >::ret	diff_abs (const Image< I > &lhs, const Image< I > &rhs)
	Point-wise absolute difference of images lhs and rhs.
template<typename L, typename R, typename O>
void	div (const Image< L > &lhs, const Image< R > &rhs, Image< O > &output)
	Point-wise division of images lhs and rhs.
template<typename I, typename V, typename O>
void	div_cst (const Image< I > &input, const V &val, Image< O > &output)
	Point-wise division of the value val to image input.
template<typename L, typename R>
void	div_inplace (Image< L > &lhs, const Image< R > &rhs)
	Point-wise division of image rhs in image lhs.
template<typename L, typename R>
mln::trait::concrete< L >::ret	min (const Image< L > &lhs, const Image< R > &rhs)
	Point-wise min of images lhs and rhs.
template<typename L, typename R>
void	min_inplace (Image< L > &lhs, const Image< R > &rhs)
	Point-wise min of image lhs in image rhs.
template<typename L, typename R, typename F>
mln::trait::ch_value< L, typename F::result >::ret	minus (const Image< L > &lhs, const Image< R > &rhs, const Function_v2v< F > &f)
	Point-wise addition of images lhs and rhs.
template<typename L, typename R>
mln::trait::op::minus< L, R >::ret	minus (const Image< L > &lhs, const Image< R > &rhs)
	Point-wise addition of images lhs and rhs.
template<typename I, typename V, typename F>
mln::trait::ch_value< I, typename F::result >::ret	minus_cst (const Image< I > &input, const V &val, const Function_v2v< F > &f)
	Point-wise addition of the value val to image input.
template<typename I, typename V>
mln::trait::op::minus< I, V >::ret	minus_cst (const Image< I > &input, const V &val)
	Point-wise addition of the value val to image input.
template<typename I, typename V>
I &	minus_cst_inplace (Image< I > &input, const V &val)
	Point-wise addition of the value val to image input.
template<typename L, typename R>
void	minus_inplace (Image< L > &lhs, const Image< R > &rhs)
	Point-wise addition of image rhs in image lhs.
template<typename L, typename R, typename F>
mln::trait::ch_value< L, typename F::result >::ret	plus (const Image< L > &lhs, const Image< R > &rhs, const Function_v2v< F > &f)
	Point-wise addition of images lhs and rhs.
template<typename L, typename R>
mln::trait::op::plus< L, R >::ret	plus (const Image< L > &lhs, const Image< R > &rhs)
	Point-wise addition of images lhs and rhs.
template<typename I, typename V, typename F>
mln::trait::ch_value< I, typename F::result >::ret	plus_cst (const Image< I > &input, const V &val, const Function_v2v< F > &f)
	Point-wise addition of the value val to image input.
template<typename I, typename V>
mln::trait::op::plus< I, V >::ret	plus_cst (const Image< I > &input, const V &val)
	Point-wise addition of the value val to image input.
template<typename I, typename V>
I &	plus_cst_inplace (Image< I > &input, const V &val)
	Point-wise addition of the value val to image input.
template<typename L, typename R>
void	plus_inplace (Image< L > &lhs, const Image< R > &rhs)
	Point-wise addition of image rhs in image lhs.
template<typename I>
mln::trait::concrete< I >::ret	revert (const Image< I > &input)
	Point-wise reversion of image input.
template<typename I>
void	revert_inplace (Image< I > &input)
	Point-wise in-place reversion of image input.
template<typename L, typename R, typename O>
void	times (const Image< L > &lhs, const Image< R > &rhs, Image< O > &output)
	Point-wise addition of images lhs and rhs.
template<typename I, typename V, typename O>
void	times_cst (const Image< I > &input, const V &val, Image< O > &output)
	Point-wise addition of the value val to image input.
template<typename L, typename R>
void	times_inplace (Image< L > &lhs, const Image< R > &rhs)
	Point-wise addition of image rhs in image lhs.

---

Detailed Description

Namespace of arithmetic.

---

Function Documentation

template<typename I>

mln::trait::concrete< I >::ret mln::arith::diff_abs	(	const Image< I > &	lhs,
		const Image< I > &	rhs
	)			[inline]

Point-wise absolute difference of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

References mln::data::transform().

template<typename L, typename R, typename O>

void mln::arith::div	(	const Image< L > &	lhs,
		const Image< R > &	rhs,
		Image< O > &	output
	)			[inline]

Point-wise division of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.
[out]	output	The result image.

Precondition:

output.domain == lhs.domain == rhs.domain

template<typename I, typename V, typename O>

void mln::arith::div_cst	(	const Image< I > &	input,
		const V &	val,
		Image< O > &	output
	)			[inline]

Point-wise division of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.
[out]	output	The result image.

Precondition:

output.domain == input.domain

References div_cst().

Referenced by div_cst().

template<typename L, typename R>

void mln::arith::div_inplace	(	Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise division of image rhs in image lhs.

Parameters:

[in]	lhs	First operand image (subject to division).
[in,out]	rhs	Second operand image (to div lhs).

This addition performs:
for all p of rhs.domain
lhs(p) /= rhs(p)

Precondition:

rhs.domain <= lhs.domain

References div_inplace().

Referenced by div_inplace().

template<typename L, typename R>

mln::trait::concrete< L >::ret mln::arith::min	(	const Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise min of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

References mln::initialize().

template<typename L, typename R>

void mln::arith::min_inplace	(	Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise min of image lhs in image rhs.

Parameters:

[in,out]	lhs	First operand image.
[in]	rhs	Second operand image.

Precondition:

rhs.domain == lhs.domain

template<typename L, typename R, typename F>

mln::trait::ch_value< L, typename F::result >::ret mln::arith::minus	(	const Image< L > &	lhs,
		const Image< R > &	rhs,
		const Function_v2v< F > &	f
	)			[inline]

Point-wise addition of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.
[in]	f	Function.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

References mln::initialize().

template<typename L, typename R>

mln::trait::ch_value< L, V >::ret mln::arith::minus	(	const Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise addition of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

The free parameter V sets the destination value type.

Precondition:

lhs.domain == rhs.domain

References mln::initialize().

template<typename I, typename V, typename F>

mln::trait::ch_value< I, typename F::result >::ret mln::arith::minus_cst	(	const Image< I > &	input,
		const V &	val,
		const Function_v2v< F > &	f
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.
[in]	f	Function.

Returns:

The result image.

Precondition:

input.is_valid

template<typename I, typename V>

mln::trait::op::minus< I, V >::ret mln::arith::minus_cst	(	const Image< I > &	input,
		const V &	val
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.

Returns:

The result image.

Precondition:

input.is_valid

template<typename I, typename V>

I & mln::arith::minus_cst_inplace	(	Image< I > &	input,
		const V &	val
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in,out]	input	The image.
[in]	val	The value.

Precondition:

input.is_valid

References minus_cst_inplace(), and minus_inplace().

Referenced by minus_cst_inplace().

template<typename L, typename R>

void mln::arith::minus_inplace	(	Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise addition of image rhs in image lhs.

Parameters:

[in,out]	lhs	First operand image (subject to addition).
[in]	rhs	Second operand image (to be added to lhs).

This addition performs:
for all p of rhs.domain
lhs(p) -= rhs(p)

Precondition:

rhs.domain == lhs.domain

References minus_inplace().

Referenced by minus_cst_inplace(), and minus_inplace().

template<typename L, typename R, typename F>

mln::trait::ch_value< L, typename F::result >::ret mln::arith::plus	(	const Image< L > &	lhs,
		const Image< R > &	rhs,
		const Function_v2v< F > &	f
	)			[inline]

Point-wise addition of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.
[in]	f	Function.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

References mln::initialize().

template<typename L, typename R>

mln::trait::ch_value< L, V >::ret mln::arith::plus	(	const Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise addition of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

Precondition:

lhs.domain == rhs.domain

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.

Returns:

The result image.

The free parameter V sets the destination value type.

Precondition:

lhs.domain == rhs.domain

References mln::initialize().

Referenced by mln::morpho::contrast().

template<typename I, typename V, typename F>

mln::trait::ch_value< I, typename F::result >::ret mln::arith::plus_cst	(	const Image< I > &	input,
		const V &	val,
		const Function_v2v< F > &	f
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.
[in]	f	Function.

Returns:

The result image.

Precondition:

input.is_valid

template<typename I, typename V>

mln::trait::ch_value< I, W >::ret mln::arith::plus_cst	(	const Image< I > &	input,
		const V &	val
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.

Returns:

The result image.

Precondition:

input.is_valid

template<typename I, typename V>

I & mln::arith::plus_cst_inplace	(	Image< I > &	input,
		const V &	val
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in,out]	input	The image.
[in]	val	The value.

Precondition:

input.is_valid

References plus_cst_inplace(), and plus_inplace().

Referenced by plus_cst_inplace().

template<typename L, typename R>

void mln::arith::plus_inplace	(	Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise addition of image rhs in image lhs.

Parameters:

[in,out]	lhs	First operand image (subject to addition).
[in]	rhs	Second operand image (to be added to lhs).

This addition performs:
for all p of rhs.domain
lhs(p) += rhs(p)

Precondition:

rhs.domain == lhs.domain

Referenced by plus_cst_inplace().

template<typename I>

mln::trait::concrete< I >::ret mln::arith::revert

(

const Image< I > &

input

)

[inline]

Point-wise reversion of image input.

Parameters:

[in]

input

the input image.

Returns:

The result image.

Precondition:

input.is_valid

It performs:
for all p of input.domain
output(p) = min + (max - input(p))

References mln::initialize().

template<typename I>

void mln::arith::revert_inplace

(

Image< I > &

input

)

[inline]

Point-wise in-place reversion of image input.

Parameters:

[in,out]

input

The target image.

Precondition:

input.is_valid

It performs:
for all p of input.domain
input(p) = min + (max - input(p))

template<typename L, typename R, typename O>

void mln::arith::times	(	const Image< L > &	lhs,
		const Image< R > &	rhs,
		Image< O > &	output
	)			[inline]

Point-wise addition of images lhs and rhs.

Parameters:

[in]	lhs	First operand image.
[in]	rhs	Second operand image.
[out]	output	The result image.

Precondition:

output.domain == lhs.domain == rhs.domain

template<typename I, typename V, typename O>

void mln::arith::times_cst	(	const Image< I > &	input,
		const V &	val,
		Image< O > &	output
	)			[inline]

Point-wise addition of the value val to image input.

Parameters:

[in]	input	The image.
[in]	val	The value.
[out]	output	The result image.

Precondition:

output.domain == input.domain

References times_cst().

Referenced by times_cst().

template<typename L, typename R>

void mln::arith::times_inplace	(	Image< L > &	lhs,
		const Image< R > &	rhs
	)			[inline]

Point-wise addition of image rhs in image lhs.

Parameters:

[in]	lhs	First operand image (subject to addition).
[in,out]	rhs	Second operand image (to be added to lhs).

This addition performs:
for all p of rhs.domain
lhs(p) *= rhs(p)

Precondition:

rhs.domain <= lhs.domain

References times_inplace().

Referenced by times_inplace().