00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef MLN_ARITH_TIMES_HH
00027 # define MLN_ARITH_TIMES_HH
00028
00034
00035 # include <mln/arith/includes.hh>
00036
00037
00038
00039 # include <mln/arith/times.spe.hh>
00040
00041 namespace mln
00042 {
00043
00044
00045 namespace trait
00046 {
00047
00048 template <typename L, typename R>
00049 struct set_binary_< op::times, Image, L, Image, R >
00050 {
00051 typedef mln_trait_op_times(mln_value(L), mln_value(R)) value;
00052 typedef mln_ch_value(L, value) ret;
00053 };
00054
00055 template <typename I, typename S>
00056 struct set_binary_< op::times, Image, I, mln::value::Scalar, S >
00057 {
00058 typedef mln_trait_op_times(mln_value(I), S) value;
00059 typedef mln_ch_value(I, value) ret;
00060 };
00061
00062 }
00063
00064
00065
00066 template <typename L, typename R>
00067 mln_trait_op_times(L,R)
00068 operator*(const Image<L>& lhs, const Image<R>& rhs);
00069
00070 template <typename L, typename R>
00071 L&
00072 operator*=(Image<L>& lhs, const Image<R>& rhs);
00073
00074
00075 template <typename I, typename S>
00076 mln_trait_op_times(I,S)
00077 operator*(const Image<I>& ima, const value::Scalar<S>& s);
00078
00079 template <typename I, typename S>
00080 I&
00081 operator*=(Image<I>& ima, const value::Scalar<S>& s);
00082
00083
00084
00085 namespace arith
00086 {
00087
00089
00096 template <typename L, typename R, typename O>
00097 void times(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output);
00098
00099
00101
00108 template <typename I, typename V, typename O>
00109 void times_cst(const Image<I>& input, const V& val, Image<O>& output);
00110
00111
00113
00123 template <typename L, typename R>
00124 void times_inplace(Image<L>& lhs, const Image<R>& rhs);
00125
00126
00127 }
00128
00129
00130
00131
00132 # ifndef MLN_INCLUDE_ONLY
00133
00134
00135 template <typename L, typename R>
00136 inline
00137 mln_trait_op_times(L,R)
00138 operator*(const Image<L>& lhs, const Image<R>& rhs)
00139 {
00140 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
00141 mln_trait_op_times(L,R) tmp;
00142 initialize(tmp, lhs);
00143 arith::times(lhs, rhs, tmp);
00144 return tmp;
00145 }
00146
00147 template <typename L, typename R>
00148 inline
00149 L&
00150 operator*=(Image<L>& lhs, const Image<R>& rhs)
00151 {
00152 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
00153 arith::times_inplace(lhs, rhs);
00154 return exact(lhs);
00155 }
00156
00157
00158 template <typename I, typename S>
00159 inline
00160 mln_trait_op_times(I,S)
00161 operator*(const Image<I>& ima, const value::Scalar<S>& s)
00162 {
00163 mln_precondition(exact(ima).is_valid());
00164 mln_trait_op_times(I,S) tmp;
00165 initialize(tmp, ima);
00166 arith::times_cst(ima, exact(s), tmp);
00167 return tmp;
00168 }
00169
00170 template <typename I, typename S>
00171 inline
00172 I&
00173 operator*=(Image<I>& ima, const value::Scalar<S>& s)
00174 {
00175 mln_precondition(exact(ima).is_valid());
00176 arith::times_cst(ima, exact(s), ima);
00177 return exact(ima);
00178 }
00179
00180
00181
00182 namespace arith
00183 {
00184
00185 namespace impl
00186 {
00187
00188 namespace generic
00189 {
00190
00191 template <typename L, typename R, typename O>
00192 inline
00193 void times_(const L& lhs, const R& rhs, O& output)
00194 {
00195 trace::entering("arith::impl::generic::times_");
00196
00197 mln_piter(L) p(lhs.domain());
00198 for_all(p)
00199 output(p) = lhs(p) * rhs(p);
00200
00201 trace::exiting("arith::impl::generic::times_");
00202 }
00203
00204 template <typename L, typename R>
00205 inline
00206 void times_inplace_(L& lhs, const R& rhs)
00207 {
00208 trace::entering("arith::impl::generic::times_inplace_");
00209
00210 mln_piter(R) p(rhs.domain());
00211 for_all(p)
00212 lhs(p) *= rhs(p);
00213
00214 trace::exiting("arith::impl::generic::times_inplace_");
00215 }
00216
00217 }
00218
00219 }
00220
00221
00222
00223
00224 template <typename L, typename R, typename O>
00225 inline
00226 void times(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output)
00227 {
00228 trace::entering("arith::times");
00229
00230 mln_precondition(exact(rhs).domain() == exact(lhs).domain());
00231 mln_precondition(exact(output).domain() == exact(lhs).domain());
00232 impl::times_(mln_trait_image_speed(L)(), exact(lhs),
00233 mln_trait_image_speed(R)(), exact(rhs),
00234 mln_trait_image_speed(O)(), exact(output));
00235
00236 trace::exiting("arith::times");
00237 }
00238
00239 template <typename I, typename V, typename O>
00240 inline
00241 void times_cst(const Image<I>& input, const V& val, Image<O>& output)
00242 {
00243 trace::entering("arith::times_cst");
00244
00245 mln_precondition(exact(output).domain() == exact(input).domain());
00246 times(input, pw::cst(val) | exact(input).domain(), output);
00247
00248
00249 trace::exiting("arith::times_cst");
00250 }
00251
00252 template <typename L, typename R>
00253 inline
00254 void times_inplace(Image<L>& lhs, const Image<R>& rhs)
00255 {
00256 trace::entering("arith::times_inplace");
00257
00258 mln_precondition(exact(rhs).domain() <= exact(lhs).domain());
00259 impl::times_inplace_(mln_trait_image_speed(L)(), exact(lhs),
00260 mln_trait_image_speed(R)(), exact(rhs));
00261
00262 trace::exiting("arith::times_inplace");
00263 }
00264
00265 template <typename I, typename V>
00266 inline
00267 void times_cst_inplace(Image<I>& input, const V& val)
00268 {
00269 trace::entering("arith::times_cst_inplace");
00270
00271 mln_precondition(exact(input).is_valid());
00272 times_inplace(input, pw::cst(val) | exact(input).domain());
00273
00274
00275 trace::exiting("arith::times_cst_inplace");
00276 }
00277
00278 }
00279
00280 # endif // ! MLN_INCLUDE_ONLY
00281
00282 }
00283
00284
00285 #endif // ! MLN_ARITH_TIMES_HH