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_LABELING_COMPUTE_HH
00027 # define MLN_LABELING_COMPUTE_HH
00028
00046
00047 # include <mln/core/concept/image.hh>
00048 # include <mln/core/concept/accumulator.hh>
00049 # include <mln/core/concept/meta_accumulator.hh>
00050 # include <mln/util/array.hh>
00051 # include <mln/convert/from_to.hh>
00052
00053
00054 namespace mln
00055 {
00056
00057 namespace labeling
00058 {
00059
00068
00069 template <typename A, typename I, typename L>
00070 util::array<mln_result(A)>
00071 compute(util::array<A>& a,
00072 const Image<I>& input,
00073 const Image<L>& label,
00074 const mln_value(L)& nlabels);
00075
00076
00085
00086 template <typename A, typename I, typename L>
00087 util::array<mln_result(A)>
00088 compute(const Accumulator<A>& a,
00089 const Image<I>& input,
00090 const Image<L>& label,
00091 const mln_value(L)& nlabels);
00092
00093
00102
00103 template <typename A, typename I, typename L>
00104 util::array<mln_meta_accu_result(A, mln_value(I))>
00105 compute(const Meta_Accumulator<A>& a,
00106 const Image<I>& input,
00107 const Image<L>& label,
00108 const mln_value(L)& nlabels);
00109
00110
00118
00119 template <typename A, typename L>
00120 util::array<mln_result(A)>
00121 compute(const Accumulator<A>& a,
00122 const Image<L>& label,
00123 const mln_value(L)& nlabels);
00124
00125
00133
00134 template <typename A, typename L>
00135 util::array<mln_meta_accu_result(A, mln_psite(L))>
00136 compute(const Meta_Accumulator<A>& a,
00137 const Image<L>& label,
00138 const mln_value(L)& nlabels);
00139
00140
00141
00142 # ifndef MLN_INCLUDE_ONLY
00143
00144 namespace internal
00145 {
00146
00147 template <typename A, typename L>
00148 inline
00149 void
00150 compute_tests(const Accumulator<A>& a,
00151 const Image<L>& label,
00152 const mln_value(L)& nlabels)
00153 {
00154 mln_precondition(exact(label).is_valid());
00155
00156 (void) a;
00157 (void) label;
00158 (void) nlabels;
00159 }
00160
00161
00162 template <typename A, typename I, typename L>
00163 inline
00164 void
00165 compute_tests(const Accumulator<A>& a,
00166 const Image<I>& input,
00167 const Image<L>& label,
00168 const mln_value(L)& nlabels)
00169 {
00170 mln_precondition(exact(input).is_valid());
00171 mln_precondition(exact(label).is_valid());
00172
00173 (void) a;
00174 (void) input;
00175 (void) label;
00176 (void) nlabels;
00177 }
00178
00179 }
00180
00181
00182
00183 namespace impl
00184 {
00185
00186 namespace generic
00187 {
00188
00189
00197
00198 template <typename A, typename L>
00199 inline
00200 util::array<mln_result(A)>
00201 compute(const Accumulator<A>& a_,
00202 const Image<L>& label_,
00203 const mln_value(L)& nlabels)
00204 {
00205 trace::entering("labeling::impl::generic::compute");
00206 internal::compute_tests(a_, label_, nlabels);
00207
00208 const A& a = exact(a_);
00209 const L& label = exact(label_);
00210
00211 util::array<A> accus(static_cast<unsigned>(nlabels) + 1, a);
00212
00213 mln_piter(L) p(label.domain());
00214 for_all(p)
00215 accus[label(p)].take(p);
00216
00217 util::array<mln_result(A)> res;
00218 convert::from_to(accus, res);
00219
00220 trace::exiting("labeling::impl::generic::compute");
00221 return res;
00222 }
00223
00224
00233
00234 template <typename A, typename I, typename L>
00235 inline
00236 util::array<mln_result(A)>
00237 compute(const Accumulator<A>& a_,
00238 const Image<I>& input_,
00239 const Image<L>& label_,
00240 const mln_value(L)& nlabels)
00241 {
00242 trace::entering("labeling::impl::generic::compute");
00243 internal::compute_tests(a_, input_, label_, nlabels);
00244
00245 const A& a = exact(a_);
00246 const I& input = exact(input_);
00247 const L& label = exact(label_);
00248
00249 util::array<A> accus(static_cast<unsigned>(nlabels) + 1, a);
00250
00251 mln_piter(I) p(input.domain());
00252 for_all(p)
00253 accus[label(p)].take(input(p));
00254
00255 util::array<mln_result(A)> res;
00256 convert::from_to(accus, res);
00257
00258 trace::exiting("labeling::impl::generic::compute");
00259 return res;
00260 }
00261
00262
00271
00272 template <typename A, typename I, typename L>
00273 inline
00274 util::array<mln_result(A)>
00275 compute(util::array<A>& accus,
00276 const Image<I>& input_,
00277 const Image<L>& label_,
00278 const mln_value(L)& nlabels)
00279 {
00280 trace::entering("labeling::impl::generic::compute");
00281
00282
00283
00284 const I& input = exact(input_);
00285 const L& label = exact(label_);
00286 (void) nlabels;
00287
00288
00289
00290
00291 mln_piter(I) p(input.domain());
00292 for_all(p)
00293 accus[label(p)].take(input(p));
00294
00295 util::array<mln_result(A)> res;
00296 convert::from_to(accus, res);
00297
00298 trace::exiting("labeling::impl::generic::compute");
00299 return res;
00300 }
00301
00302 }
00303
00304 }
00305
00306
00307
00308 namespace internal
00309 {
00310
00311
00312 template <typename A, typename L>
00313 inline
00314 util::array<mln_result(A)>
00315 compute_dispatch(const Accumulator<A>& a,
00316 const Image<L>& label,
00317 const mln_value(L)& nlabels)
00318 {
00319 return impl::generic::compute(a, label, nlabels);
00320 }
00321
00322
00323 template <typename A, typename I, typename L>
00324 inline
00325 util::array<mln_result(A)>
00326 compute_dispatch(const Accumulator<A>& a,
00327 const Image<I>& input,
00328 const Image<L>& label,
00329 const mln_value(L)& nlabels)
00330 {
00331 return impl::generic::compute(a, input, label, nlabels);
00332 }
00333
00334
00335 template <typename A, typename I, typename L>
00336 inline
00337 util::array<mln_result(A)>
00338 compute_dispatch(util::array<A>& a,
00339 const Image<I>& input,
00340 const Image<L>& label,
00341 const mln_value(L)& nlabels)
00342 {
00343 return impl::generic::compute(a, input, label, nlabels);
00344 }
00345
00346
00347 }
00348
00349
00350
00351
00352
00353 template <typename A, typename I, typename L>
00354 inline
00355 util::array<mln_result(A)>
00356 compute(util::array<A>& a,
00357 const Image<I>& input,
00358 const Image<L>& label,
00359 const mln_value(L)& nlabels)
00360 {
00361 trace::entering("labeling::compute");
00362
00363
00364
00365 typedef util::array<mln_result(A)> R;
00366 R res = internal::compute_dispatch(a, input, label, nlabels);
00367
00368 trace::exiting("labeling::compute");
00369 return res;
00370 }
00371
00372 template <typename A, typename I, typename L>
00373 inline
00374 util::array<mln_result(A)>
00375 compute(const Accumulator<A>& a,
00376 const Image<I>& input,
00377 const Image<L>& label,
00378 const mln_value(L)& nlabels)
00379 {
00380 trace::entering("labeling::compute");
00381
00382 internal::compute_tests(a, input, label, nlabels);
00383
00384 typedef util::array<mln_result(A)> R;
00385 R res = internal::compute_dispatch(a, input, label, nlabels);
00386
00387 trace::exiting("labeling::compute");
00388 return res;
00389 }
00390
00391 template <typename A, typename I, typename L>
00392 inline
00393 util::array<mln_meta_accu_result(A, mln_value(I))>
00394 compute(const Meta_Accumulator<A>& a,
00395 const Image<I>& input,
00396 const Image<L>& label,
00397 const mln_value(L)& nlabels)
00398 {
00399 typedef mln_accu_with(A, mln_value(I)) A_;
00400 A_ a_ = accu::unmeta(exact(a), mln_value(I)());
00401
00402 return compute(a_, input, label, nlabels);
00403 }
00404
00405
00406 template <typename A, typename L>
00407 inline
00408 util::array<mln_result(A)>
00409 compute(const Accumulator<A>& a,
00410 const Image<L>& label,
00411 const mln_value(L)& nlabels)
00412 {
00413 trace::entering("labeling::compute");
00414
00415 internal::compute_tests(a, label, nlabels);
00416
00417 typedef util::array<mln_result(A)> R;
00418 R res = internal::compute_dispatch(a, label, nlabels);
00419
00420 mln_postcondition(res.nelements() == static_cast<unsigned>(nlabels) + 1);
00421
00422 trace::exiting("labeling::compute");
00423 return res;
00424 }
00425
00426
00427 template <typename A, typename L>
00428 inline
00429 util::array<mln_meta_accu_result(A, mln_psite(L))>
00430 compute(const Meta_Accumulator<A>& a,
00431 const Image<L>& label,
00432 const mln_value(L)& nlabels)
00433 {
00434 typedef mln_accu_with(A, mln_psite(L)) A_;
00435 A_ a_ = accu::unmeta(exact(a), mln_psite(L)());
00436
00437 return compute(a_, label, nlabels);
00438 }
00439
00440
00441 # endif // ! MLN_INCLUDE_ONLY
00442
00443 }
00444
00445 }
00446
00447
00448 #endif // ! MLN_LABELING_COMPUTE_HH