26 #ifndef MLN_ARITH_MINUS_HH
27 # define MLN_ARITH_MINUS_HH
35 # include <mln/arith/includes.hh>
45 template <
typename L,
typename R>
46 struct set_binary_< op::
minus, Image, L, Image, R >
48 typedef mln_trait_op_minus(mln_value(L), mln_value(R)) value;
49 typedef mln_ch_value(L, value) ret;
52 template <typename I, typename S>
53 struct set_binary_< op::minus, Image, I, mln::value::Scalar, S >
55 typedef mln_trait_op_minus(mln_value(I), S) value;
56 typedef mln_ch_value(I, value) ret;
63 template <typename L, typename R>
64 mln_trait_op_minus(L,R)
65 operator-(const Image<L>& lhs, const Image<R>& rhs);
68 template <typename L, typename R>
70 operator-=(Image<L>& lhs, const Image<R>& rhs);
73 template <typename I, typename S>
74 mln_trait_op_minus(I,S)
75 operator-(const Image<I>& ima, const value::Scalar<S>& s);
78 template <typename I, typename S>
80 operator-=(Image<I>& ima, const value::Scalar<S>& s);
95 template <
typename L,
typename R>
96 mln_trait_op_minus(L, R)
97 minus(const Image<L>& lhs, const Image<R>& rhs);
109 template <typename L, typename R, typename F>
110 mln_ch_value(L, mln_result(F))
111 minus(const Image<L>& lhs, const Image<R>& rhs, const Function_v2v<F>& f);
124 template <typename V, typename L, typename R>
126 minus(const Image<L>& lhs, const Image<R>& rhs);
140 template <typename L, typename R>
142 minus_inplace(Image<L>& lhs, const Image<R>& rhs);
153 template <typename I, typename V>
154 mln_trait_op_minus(I, V)
155 minus_cst(const Image<I>& input, const V& val);
167 template <typename I, typename V, typename F>
168 mln_ch_value(I, mln_result(F))
169 minus_cst(const Image<I>& input, const V& val, const Function_v2v<F>& f);
179 template <typename I, typename V>
181 minus_cst_inplace(Image<I>& input, const V& val);
189 # ifndef MLN_INCLUDE_ONLY
192 template <
typename L,
typename R>
194 mln_trait_op_minus(L,R)
195 operator-(const Image<L>& lhs, const Image<R>& rhs)
197 trace::entering(
"operator::minus");
199 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
200 mln_trait_op_minus(L,R) output = arith::minus(lhs, rhs);
202 trace::exiting("operator::minus");
206 template <typename L, typename R>
209 operator-=(Image<L>& lhs, const Image<R>& rhs)
211 trace::entering(
"operator::minus_eq");
213 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
216 trace::exiting(
"operator::minus_eq");
221 template <
typename I,
typename S>
223 mln_trait_op_minus(I,S)
224 operator-(const Image<I>& ima, const value::Scalar<S>& s)
226 trace::entering(
"operator::minus");
228 mln_precondition(exact(ima).is_valid());
229 mln_trait_op_minus(I,S) output = arith::minus_cst(ima, exact(s));
231 trace::exiting("operator::minus");
235 template <typename I, typename S>
238 operator-=(Image<I>& ima, const value::Scalar<S>& s)
240 trace::entering(
"operator::minus_eq");
242 mln_precondition(exact(ima).is_valid());
245 trace::exiting(
"operator::minus_eq");
257 template <
typename L,
typename R,
typename O>
259 void minus_(trait::image::speed::any,
const L& lhs,
260 trait::image::speed::any,
const R& rhs, O& output)
262 mln_piter(L) p(lhs.domain());
264 output(p) = lhs(p) - rhs(p);
267 template <typename L, typename R, typename F, typename O>
269 void minus_(trait::image::speed::any, const L& lhs,
270 trait::image::speed::any, const R& rhs, const F& f, O& output)
272 mln_piter(L) p(lhs.domain());
274 output(p) = f(lhs(p) - rhs(p));
277 template <typename L, typename R, typename O>
279 void minus_(trait::image::speed::fastest, const L& lhs,
280 trait::image::speed::fastest, const R& rhs, O& output)
282 mln_pixter(
const L) lp(lhs);
283 mln_pixter(const R) rp(rhs);
284 mln_pixter(O) op(output);
285 for_all_3(lp, rp, op)
286 op.val() = lp.val() - rp.val();
289 template <typename L, typename R, typename F, typename O>
291 void minus_(trait::image::speed::fastest, const L& lhs,
292 trait::image::speed::fastest, const R& rhs, const F& f, O& output)
294 mln_pixter(
const L) lp(lhs);
295 mln_pixter(const R) rp(rhs);
296 mln_pixter(O) op(output);
297 for_all_3(lp, rp, op)
298 op.val() = f(lp.val() - rp.val());
301 template <typename L, typename R>
303 void minus_inplace_(trait::image::speed::any, L& lhs,
304 trait::image::speed::any, const R& rhs)
306 mln_piter(L) p(lhs.domain());
311 template <typename L, typename R>
313 void minus_inplace_(trait::image::speed::fastest, L& lhs,
314 trait::image::speed::fastest, const R& rhs)
316 mln_pixter(L) lp(lhs);
317 mln_pixter(const R) rp(rhs);
319 lp.val() -= rp.val();
328 template <typename L, typename R>
330 mln_trait_op_minus(L, R)
331 minus(const Image<L>& lhs, const Image<R>& rhs)
333 trace::entering(
"arith::minus");
335 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
337 mln_trait_op_minus(L, R) output;
339 impl::minus_(mln_trait_image_speed(L)(), exact(lhs),
340 mln_trait_image_speed(R)(), exact(rhs), output);
342 trace::exiting(
"arith::minus");
347 template <
typename L,
typename R,
typename F>
349 mln_ch_value(L, mln_result(F))
350 minus(const Image<L>& lhs, const Image<R>& rhs, const
Function_v2v<F>& f)
352 trace::entering(
"arith::minus");
354 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
356 mln_ch_value(L, mln_result(F)) output;
358 impl::minus_(mln_trait_image_speed(L)(), exact(lhs),
359 mln_trait_image_speed(R)(), exact(rhs), exact(f), output);
361 trace::exiting(
"arith::minus");
366 template <
typename V,
typename L,
typename R>
369 minus(const Image<L>& lhs, const Image<R>& rhs)
371 trace::entering(
"arith::minus");
373 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
376 mln_ch_value(L, V) output = minus(lhs, rhs,
377 mln::fun::v2v::cast<V>());
379 trace::exiting(
"arith::minus");
384 template <
typename I,
typename V>
386 mln_trait_op_minus(I, V)
387 minus_cst(const Image<I>& input, const V& val)
389 trace::entering(
"arith::minus_cst");
391 mln_precondition(exact(input).is_valid());
394 mln_trait_op_minus(I, V) output = minus(input,
395 pw::cst(val) | exact(input).domain());
397 trace::exiting(
"arith::minus_cst");
402 template <
typename I,
typename V,
typename F>
404 mln_ch_value(I, mln_result(F))
405 minus_cst(const Image<I>& input, const V& val, const
Function_v2v<F>& f)
407 trace::entering(
"arith::minus_cst");
409 mln_precondition(exact(input).is_valid());
412 mln_ch_value(I, mln_result(F)) output = minus(input,
413 pw::cst(val) | exact(input).domain(),
416 trace::exiting(
"arith::minus_cst");
421 template <
typename L,
typename R>
426 trace::entering(
"arith::minus_inplace");
428 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
430 impl::minus_inplace_(mln_trait_image_speed(L)(), exact(lhs),
431 mln_trait_image_speed(R)(), exact(rhs));
433 trace::exiting(
"arith::minus_inplace");
437 template <
typename I,
typename V>
442 trace::entering(
"arith::minus_cst_inplace");
444 mln_precondition(exact(input).is_valid());
448 pw::cst(val) | exact(input).domain());
450 trace::exiting(
"arith::minus_cst_inplace");
456 # endif // ! MLN_INCLUDE_ONLY
461 #endif // ! MLN_ARITH_MINUS_HH