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_MORPHO_TREE_COMPUTE_ATTRIBUTE_IMAGE_HH
00027 # define MLN_MORPHO_TREE_COMPUTE_ATTRIBUTE_IMAGE_HH
00028
00034
00035 # include <mln/core/routine/duplicate.hh>
00036 # include <mln/core/concept/image.hh>
00037 # include <mln/morpho/tree/data.hh>
00038 # include <mln/trait/accumulators.hh>
00039 # include <mln/util/pix.hh>
00040 # include <mln/data/fill.hh>
00041
00042
00043 namespace mln
00044 {
00045
00046 namespace morpho
00047 {
00048
00049 namespace tree
00050 {
00051
00079 template <typename A, typename T>
00080 mln_ch_value(typename T::function, mln_result(A))
00081 compute_attribute_image(const Accumulator<A>& a,
00082 const T& t,
00083 mln_ch_value(typename T::function, A)* accu_image = 0);
00084
00085
00086
00097 template <typename A, typename T, typename V>
00098 mln_ch_value(typename T::function, mln_result(A))
00099 compute_attribute_image_from(const Accumulator<A>& a,
00100 const T& t,
00101 const Image<V>& values,
00102 mln_ch_value(typename T::function, A)* accu_image = 0);
00103
00104
00105
00106 # ifndef MLN_INCLUDE_ONLY
00107
00108
00109 namespace internal
00110 {
00111 template <typename A, typename I, typename P>
00112 void take_as_init (trait::accumulator::when_pix::use_none, A& accu,
00113 const I& input, const P& p)
00114 {
00115 (void)input;
00116 (void)p;
00117 accu.take_as_init();
00118 }
00119
00120 template <typename A, typename I, typename P>
00121 void take_as_init (trait::accumulator::when_pix::use_pix, A& accu,
00122 const I& input, const P& p)
00123 {
00124 accu.take_as_init(make::pix(input, p));
00125 }
00126
00127 template <typename A, typename I, typename P>
00128 void take_as_init (trait::accumulator::when_pix::use_v, A& accu,
00129 const I& input, const P& p)
00130 {
00131 accu.take_as_init(input(p));
00132 }
00133
00134 template <typename A, typename I, typename P>
00135 void take_as_init (trait::accumulator::when_pix::use_p, A& accu,
00136 const I& input, const P& p)
00137 {
00138 accu.take_as_init(p);
00139 }
00140
00141
00142 template <typename A, typename I, typename P>
00143 void take_as_init (A& accu, const I& input, const P& p)
00144 {
00145 take_as_init (mln_trait_accumulator_when_pix(A)(), accu, input, p);
00146 }
00147
00148
00149 template <typename A, typename T, typename V>
00150 inline
00151 mln_ch_value(typename T::function, mln_result(A))
00152 compute_attribute_image(const A& a,
00153 const T& t,
00154 const V& values,
00155 mln_ch_value(typename T::function, A)* accu_image = 0)
00156 {
00157
00158 typedef typename T::function I;
00159 mln_ch_value(I, A) acc;
00160 initialize(acc, t.f());
00161
00162 {
00163
00164
00165
00166
00167 mln::data::fill(acc, a);
00168 }
00169
00170 {
00171
00172 mln_site_piter(T) p(t);
00173 for_all(p)
00174 take_as_init(acc(p), values, p);
00175 }
00176
00177 {
00178 mln_up_site_piter(T) p(t);
00179
00180 for_all(p)
00181 if (! t.is_root(p))
00182 acc(t.parent(p)).take(acc(p));
00183
00184
00185
00186
00187
00188 for_all(p)
00189 if (! t.is_a_node(p))
00190 {
00191 mln_assertion(t.is_a_node(t.parent(p)));
00192 acc(p) = acc(t.parent(p));
00193 }
00194 }
00195
00196
00197
00198 if (accu_image)
00199 *accu_image = duplicate(acc);
00200
00201 typedef typename T::function I;
00202 mln_ch_value(I, mln_result(A)) output;
00203 initialize(output, acc);
00204 mln::data::fill(output, acc);
00205
00206 return output;
00207 }
00208 }
00209
00210
00211
00212 template <typename A, typename T>
00213 inline
00214 mln_ch_value(typename T::function, mln_result(A))
00215 compute_attribute_image(const Accumulator<A>& a_,
00216 const T& t,
00217 mln_ch_value(typename T::function, A)* accu_image = 0)
00218 {
00219 trace::entering("morpho::tree::compute_attribute_image");
00220
00221 mln_ch_value(typename T::function, mln_result(A)) output;
00222 output = internal::compute_attribute_image(exact(a_), t, t.f(),
00223 accu_image);
00224
00225 trace::exiting("morpho::tree::compute_attribute_image");
00226 return (output);
00227 }
00228
00229 template <typename A, typename T, typename V>
00230 inline
00231 mln_ch_value(typename T::function, mln_result(A))
00232 compute_attribute_image_from(const Accumulator<A>& a_,
00233 const T& t,
00234 const Image<V>& values,
00235 mln_ch_value(typename T::function, A)* accu_image = 0)
00236 {
00237 trace::entering("morpho::tree::compute_attribute_image_from");
00238
00239
00240 mln_ch_value(typename T::function, mln_result(A)) output;
00241 output = internal::compute_attribute_image(exact(a_), t, exact(values),
00242 accu_image);
00243
00244 trace::exiting("morpho::tree::compute_attribute_image_from");
00245 return output;
00246 }
00247
00248
00249
00250
00251 # endif // ! MLN_INCLUDE_ONLY
00252
00253 }
00254
00255 }
00256
00257 }
00258
00259
00260 #endif // ! MLN_MORPHO_TREE_COMPUTE_ATTRIBUTE_IMAGE_HH