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_DATA_TRANSFORM_HH
00027 # define MLN_DATA_TRANSFORM_HH
00028
00036
00037 # include <mln/core/concept/image.hh>
00038 # include <mln/core/concept/function.hh>
00039 # include <mln/value/set.hh>
00040
00041
00042 # include <mln/data/transform.spe.hh>
00043
00044
00045 namespace mln
00046 {
00047
00048 namespace data
00049 {
00050
00060 template <typename I, typename F>
00061 mln_ch_value(I, mln_result(F))
00062 transform(const Image<I>& input, const Function_v2v<F>& f);
00063
00064
00074 template <typename I1, typename I2, typename F>
00075 mln_ch_value(I1, mln_result(F))
00076 transform(const Image<I1>& input1,
00077 const Image<I2>& input2,
00078 const Function_vv2v<F>& f);
00079
00080
00081
00082 # ifndef MLN_INCLUDE_ONLY
00083
00084 namespace internal
00085 {
00086
00087 template <typename I, typename F>
00088 void transform_tests(const Image<I>& input,
00089 const Function_v2v<F>& f)
00090 {
00091
00092 mln_precondition(exact(input).is_valid());
00093
00094
00095
00096 (void) input;
00097 (void) f;
00098 }
00099
00100 template <typename I1, typename I2, typename F>
00101 void transform_tests(const Image<I1>& input1, const Image<I2>& input2,
00102 const Function_vv2v<F>& f)
00103 {
00104
00105 mln_precondition(exact(input1).is_valid());
00106 mln_precondition(exact(input2).is_valid());
00107 mln_precondition(exact(input2).domain() == exact(input1).domain());
00108
00109
00110
00111 (void) input1;
00112 (void) input2;
00113 (void) f;
00114 }
00115
00116 }
00117
00118
00119
00120 namespace impl
00121 {
00122
00123
00124
00125
00126
00127 namespace generic
00128 {
00129
00134
00135 template <typename I, typename F>
00136 mln_ch_value(I, mln_result(F))
00137 transform(const Image<I>& input_, const Function_v2v<F>& f_)
00138 {
00139 trace::entering("data::impl::generic::transform");
00140
00141 const I& input = exact(input_);
00142 const F& f = exact(f_);
00143
00144 data::internal::transform_tests(input, f);
00145
00146 mln_ch_value(I, mln_result(F)) output;
00147 initialize(output, input);
00148
00149 mln_piter(I) p(input.domain());
00150 for_all(p)
00151 output(p) = f(input(p));
00152
00153 trace::exiting("data::impl::generic::transform");
00154 return output;
00155 }
00156
00157
00163
00164 template <typename I1, typename I2, typename F>
00165 mln_ch_value(I1, mln_result(F))
00166 transform(const Image<I1>& input1_,
00167 const Image<I2>& input2_,
00168 const Function_vv2v<F>& f_)
00169 {
00170 trace::entering("data::impl::generic::transform");
00171
00172 const I1& input1 = exact(input1_);
00173 const I2& input2 = exact(input2_);
00174 const F& f = exact(f_);
00175
00176 data::internal::transform_tests(input1, input2, f);
00177
00178 mln_ch_value(I1, mln_result(F)) output;
00179 initialize(output, input1);
00180
00181 mln_piter(I1) p(input1.domain());
00182 for_all(p)
00183 output(p) = f(input1(p), input2(p));
00184
00185 trace::exiting("data::impl::generic::transform");
00186 return output;
00187 }
00188
00189 }
00190
00191
00192 }
00193
00194
00195
00196
00197
00198
00199 template <typename I, typename F>
00200 inline
00201 mln_ch_value(I, mln_result(F))
00202 transform(const Image<I>& input, const Function_v2v<F>& f)
00203 {
00204 trace::entering("data::transform");
00205
00206 internal::transform_tests(input, f);
00207
00208 mln_ch_value(I, mln_result(F)) output;
00209 output = internal::transform_dispatch(input, f);
00210
00211 trace::exiting("data::transform");
00212 return output;
00213 }
00214
00215
00216 template <typename I1, typename I2, typename F>
00217 inline
00218 mln_ch_value(I1, mln_result(F))
00219 transform(const Image<I1>& input1, const Image<I2>& input2,
00220 const Function_vv2v<F>& f)
00221 {
00222 trace::entering("data::transform");
00223
00224 internal::transform_tests(input1, input2, f);
00225
00226 mln_ch_value(I1, mln_result(F)) output;
00227 output = internal::transform_dispatch(input1, input2, f);
00228
00229 trace::exiting("data::transform");
00230 return output;
00231 }
00232
00233
00234 # endif // ! MLN_INCLUDE_ONLY
00235
00236 }
00237
00238 }
00239
00240
00241 #endif // ! MLN_DATA_TRANSFORM_HH