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
00027 #ifndef MLN_LABELING_COMPUTE_HH
00028 # define MLN_LABELING_COMPUTE_HH
00029
00047
00048 # include <mln/core/concept/image.hh>
00049 # include <mln/core/concept/accumulator.hh>
00050 # include <mln/core/concept/meta_accumulator.hh>
00051 # include <mln/util/array.hh>
00052 # include <mln/convert/from_to.hh>
00053 # include <mln/geom/ncols.hh>
00054 # include <mln/value/next.hh>
00055
00056
00057 namespace mln
00058 {
00059
00060 namespace labeling
00061 {
00062
00071
00072 template <typename A, typename I, typename L>
00073 util::array<mln_result(A)>
00074 compute(const Accumulator<A>& a,
00075 const Image<I>& input,
00076 const Image<L>& label,
00077 const mln_value(L)& nlabels);
00078
00079
00088
00089 template <typename A, typename I, typename L>
00090 util::array<mln_meta_accu_result(A, mln_value(I))>
00091 compute(const Meta_Accumulator<A>& a,
00092 const Image<I>& input,
00093 const Image<L>& label,
00094 const mln_value(L)& nlabels);
00095
00096
00104
00105 template <typename A, typename L>
00106 util::array<mln_result(A)>
00107 compute(const Accumulator<A>& a,
00108 const Image<L>& label,
00109 const mln_value(L)& nlabels);
00110
00111
00119
00120 template <typename A, typename L>
00121 util::array<mln_meta_accu_result(A, mln_psite(L))>
00122 compute(const Meta_Accumulator<A>& a,
00123 const Image<L>& label,
00124 const mln_value(L)& nlabels);
00125
00126
00135
00136 template <typename A, typename I, typename L>
00137 util::array<mln_result(A)>
00138 compute(util::array<A>& a,
00139 const Image<I>& input,
00140 const Image<L>& label,
00141 const mln_value(L)& nlabels);
00142
00143
00144
00145 # ifndef MLN_INCLUDE_ONLY
00146
00147 namespace internal
00148 {
00149
00150 template <typename A, typename L>
00151 inline
00152 void
00153 compute_tests(const Accumulator<A>& a,
00154 const Image<L>& label,
00155 const mln_value(L)& nlabels)
00156 {
00157 mln_precondition(exact(label).is_valid());
00158
00159 (void) a;
00160 (void) label;
00161 (void) nlabels;
00162 }
00163
00164
00165 template <typename A, typename I, typename L>
00166 inline
00167 void
00168 compute_tests(const Accumulator<A>& a,
00169 const Image<I>& input,
00170 const Image<L>& label,
00171 const mln_value(L)& nlabels)
00172 {
00173 mln_precondition(exact(input).is_valid());
00174 mln_precondition(exact(label).is_valid());
00175
00176 (void) a;
00177 (void) input;
00178 (void) label;
00179 (void) nlabels;
00180 }
00181
00182 }
00183
00184
00185
00186 namespace impl
00187 {
00188
00189 namespace generic
00190 {
00191
00192
00200
00201 template <typename A, typename L>
00202 inline
00203 util::array<mln_result(A)>
00204 compute(const Accumulator<A>& a_,
00205 const Image<L>& label_,
00206 const mln_value(L)& nlabels)
00207 {
00208 trace::entering("labeling::impl::generic::compute");
00209 internal::compute_tests(a_, label_, nlabels);
00210
00211 const A& a = exact(a_);
00212 const L& label = exact(label_);
00213
00214 util::array<A> accus(value::next(nlabels), a);
00215
00216 mln_piter(L) p(label.domain());
00217 for_all(p)
00218 accus[label(p)].take(p);
00219
00220 util::array<mln_result(A)> res;
00221 convert::from_to(accus, res);
00222
00223 trace::exiting("labeling::impl::generic::compute");
00224 return res;
00225 }
00226
00237
00238 template <typename A, typename L>
00239 inline
00240 util::array<mln_result(A)>
00241 compute(util::array<A>& accus,
00242 const Image<L>& label_,
00243 const mln_value(L)& nlabels)
00244 {
00245 trace::entering("labeling::impl::generic::compute");
00246 internal::compute_tests(A(), label_, nlabels);
00247
00248 if (value::next(nlabels) != accus.size())
00249 {
00250 accus.resize(0);
00251
00252
00253 accus.resize(value::next(nlabels));
00254 }
00255
00256 const L& label = exact(label_);
00257
00258 mln_piter(L) p(label.domain());
00259 for_all(p)
00260 accus[label(p)].take(p);
00261
00262 util::array<mln_result(A)> res;
00263 convert::from_to(accus, res);
00264
00265 trace::exiting("labeling::impl::generic::compute");
00266 return res;
00267 }
00268
00269
00270
00279
00280 template <typename A, typename I, typename L>
00281 inline
00282 util::array<mln_result(A)>
00283 compute(const Accumulator<A>& a_,
00284 const Image<I>& input_,
00285 const Image<L>& label_,
00286 const mln_value(L)& nlabels)
00287 {
00288 trace::entering("labeling::impl::generic::compute");
00289 internal::compute_tests(a_, input_, label_, nlabels);
00290
00291 const A& a = exact(a_);
00292 const I& input = exact(input_);
00293 const L& label = exact(label_);
00294
00295 util::array<A> accus(value::next(nlabels), a);
00296
00297 mln_piter(I) p(input.domain());
00298 for_all(p)
00299 accus[label(p)].take(input(p));
00300
00301 util::array<mln_result(A)> res;
00302 convert::from_to(accus, res);
00303
00304 trace::exiting("labeling::impl::generic::compute");
00305 return res;
00306 }
00307
00308
00317
00318 template <typename A, typename I, typename L>
00319 inline
00320 util::array<mln_result(A)>
00321 compute(util::array<A>& accus,
00322 const Image<I>& input_,
00323 const Image<L>& label_,
00324 const mln_value(L)& nlabels)
00325 {
00326 trace::entering("labeling::impl::generic::compute");
00327
00328
00329
00330 const I& input = exact(input_);
00331 const L& label = exact(label_);
00332 (void) nlabels;
00333
00334 if (value::next(nlabels) != accus.size())
00335 {
00336 accus.resize(0);
00337
00338
00339 accus.resize(value::next(nlabels));
00340 }
00341
00342 mln_piter(I) p(input.domain());
00343 for_all(p)
00344 accus[label(p)].take(input(p));
00345
00346 util::array<mln_result(A)> res;
00347 convert::from_to(accus, res);
00348
00349 trace::exiting("labeling::impl::generic::compute");
00350 return res;
00351 }
00352
00353 }
00354
00355
00356
00357
00358
00359
00360
00369
00370 template <typename A, typename I, typename L>
00371 inline
00372 util::array<mln_result(A)>
00373 compute_fastest(const Accumulator<A>& a_,
00374 const Image<I>& input_,
00375 const Image<L>& label_,
00376 const mln_value(L)& nlabels)
00377 {
00378 trace::entering("labeling::impl::compute_fastest");
00379 internal::compute_tests(a_, input_, label_, nlabels);
00380
00381 const A& a = exact(a_);
00382 const I& input = exact(input_);
00383 const L& label = exact(label_);
00384
00385
00386
00387 util::array<A> accus(value::next(nlabels), a);
00388
00389 unsigned ncols = geom::ncols(label);
00390
00391 typedef mln_site(I) P;
00392 typedef const mln_value(I) * iptr_t;
00393 typedef const mln_value(L) * lptr_t;
00394 box_runstart_piter<P> p(label.domain());
00395 for_all(p)
00396 {
00397 iptr_t iptr = & input(p);
00398 lptr_t lptr = & label(p);
00399
00400 for (unsigned i = 0; i < ncols; ++i)
00401 accus[*lptr++].take(*iptr++);
00402 }
00403
00404 util::array<mln_result(A)> res;
00405 convert::from_to(accus, res);
00406
00407 trace::exiting("labeling::impl::generic::compute_fastest");
00408 return res;
00409 }
00410
00411
00412
00413
00414
00423
00424 template <typename A, typename I, typename L>
00425 inline
00426 util::array<mln_result(A)>
00427 compute_fastest(util::array<A>& accus,
00428 const Image<I>& input_,
00429 const Image<L>& label_,
00430 const mln_value(L)& nlabels)
00431 {
00432 trace::entering("labeling::impl::generic::compute_fastest");
00433
00434
00435
00436
00437
00438 const I& input = exact(input_);
00439 const L& label = exact(label_);
00440 (void) nlabels;
00441
00442 if (value::next(nlabels) != accus.size())
00443 {
00444 accus.resize(0);
00445
00446
00447 accus.resize(value::next(nlabels));
00448 }
00449
00450 unsigned ncols = geom::ncols(label);
00451
00452 typedef mln_site(I) P;
00453 typedef const mln_value(I) * iptr_t;
00454 typedef const mln_value(L) * lptr_t;
00455 box_runstart_piter<P> p(label.domain());
00456 for_all(p)
00457 {
00458 iptr_t iptr = & input(p);
00459 lptr_t lptr = & label(p);
00460
00461 for (unsigned i = 0; i < ncols; ++i)
00462 accus[*lptr++].take(*iptr++);
00463 }
00464
00465 util::array<mln_result(A)> res;
00466 convert::from_to(accus, res);
00467
00468 trace::exiting("labeling::impl::generic::compute_fastest");
00469 return res;
00470 }
00471
00472
00473
00474 }
00475
00476
00477
00478 namespace internal
00479 {
00480
00481
00482 template <typename A, typename L>
00483 inline
00484 util::array<mln_result(A)>
00485 compute_dispatch(const Accumulator<A>& a,
00486 const Image<L>& label,
00487 const mln_value(L)& nlabels)
00488 {
00489 return impl::generic::compute(a, label, nlabels);
00490 }
00491
00492
00493
00494
00495
00496 template <typename A, typename I, typename L>
00497 inline
00498 util::array<mln_result(A)>
00499 compute_dispatch(
00500 mln::trait::image::value_access::any,
00501 mln::trait::image::value_access::any,
00502 mln::trait::image::ext_domain::any,
00503 mln::trait::image::ext_domain::any,
00504 const Accumulator<A>& a,
00505 const Image<I>& input,
00506 const Image<L>& label,
00507 const mln_value(L)& nlabels)
00508 {
00509 return impl::generic::compute(a, input, label, nlabels);
00510 }
00511
00512
00513 template <typename A, typename I, typename L>
00514 inline
00515 util::array<mln_result(A)>
00516 compute_dispatch(
00517 mln::trait::image::value_access::direct,
00518 mln::trait::image::value_access::direct,
00519 mln::trait::image::ext_domain::some,
00520 mln::trait::image::ext_domain::some,
00521 const Accumulator<A>& a,
00522 const Image<I>& input,
00523 const Image<L>& label,
00524 const mln_value(L)& nlabels)
00525 {
00526 return impl::compute_fastest(a, input, label, nlabels);
00527 }
00528
00529
00530 template <typename A, typename I, typename L>
00531 inline
00532 util::array<mln_result(A)>
00533 compute_dispatch(mln::trait::image::value_storage::any,
00534 mln::trait::image::value_storage::any,
00535 const Accumulator<A>& a,
00536 const Image<I>& input,
00537 const Image<L>& label,
00538 const mln_value(L)& nlabels)
00539 {
00540 return impl::generic::compute(a, input, label, nlabels);
00541 }
00542
00543
00544 template <typename A, typename I, typename L>
00545 inline
00546 util::array<mln_result(A)>
00547 compute_dispatch(mln::trait::image::value_storage::one_block,
00548 mln::trait::image::value_storage::one_block,
00549 const Accumulator<A>& a,
00550 const Image<I>& input_,
00551 const Image<L>& label_,
00552 const mln_value(L)& nlabels)
00553 {
00554 const I& input = exact(input_);
00555 const L& label = exact(label_);
00556
00558 if (mlc_is(mln_trait_image_value_alignment(I),
00559 trait::image::value_alignment::with_grid)::value &&
00560 mlc_is(mln_trait_image_value_alignment(L),
00561 trait::image::value_alignment::with_grid)::value)
00562 {
00563 return compute_dispatch(
00564 mln_trait_image_value_access(I)(),
00565 mln_trait_image_value_access(L)(),
00566 mln_trait_image_ext_domain(I)(),
00567 mln_trait_image_ext_domain(L)(),
00568 a, input, label, nlabels);
00569 }
00570 else
00571 return impl::generic::compute(a, input, label, nlabels);
00572 }
00573
00574
00575 template <typename A, typename I, typename L>
00576 inline
00577 util::array<mln_result(A)>
00578 compute_dispatch(const Accumulator<A>& a,
00579 const Image<I>& input,
00580 const Image<L>& label,
00581 const mln_value(L)& nlabels)
00582 {
00583 return compute_dispatch(mln_trait_image_value_storage(I)(),
00584 mln_trait_image_value_storage(L)(),
00585 a, input, label, nlabels);
00586 }
00587
00588
00589
00590
00591
00592
00593
00594
00595 template <typename A, typename I, typename L>
00596 inline
00597 util::array<mln_result(A)>
00598 compute_dispatch(
00599 mln::trait::image::value_access::any,
00600 mln::trait::image::value_access::any,
00601 mln::trait::image::ext_domain::any,
00602 mln::trait::image::ext_domain::any,
00603 util::array<A>& a,
00604 const Image<I>& input,
00605 const Image<L>& label,
00606 const mln_value(L)& nlabels)
00607 {
00608 return impl::generic::compute(a, input, label, nlabels);
00609 }
00610
00611
00612 template <typename A, typename I, typename L>
00613 inline
00614 util::array<mln_result(A)>
00615 compute_dispatch(
00616 mln::trait::image::value_access::direct,
00617 mln::trait::image::value_access::direct,
00618 mln::trait::image::ext_domain::some,
00619 mln::trait::image::ext_domain::some,
00620 util::array<A>& a,
00621 const Image<I>& input,
00622 const Image<L>& label,
00623 const mln_value(L)& nlabels)
00624 {
00625 return impl::compute_fastest(a, input, label, nlabels);
00626 }
00627
00628
00629 template <typename A, typename I, typename L>
00630 inline
00631 util::array<mln_result(A)>
00632 compute_dispatch(mln::trait::image::value_storage::one_block,
00633 mln::trait::image::value_storage::one_block,
00634 util::array<A>& a,
00635 const Image<I>& input_,
00636 const Image<L>& label_,
00637 const mln_value(L)& nlabels)
00638 {
00639 const I& input = exact(input_);
00640 const L& label = exact(label_);
00641
00643 if (mlc_is(mln_trait_image_value_alignment(I),
00644 trait::image::value_alignment::with_grid)::value &&
00645 mlc_is(mln_trait_image_value_alignment(L),
00646 trait::image::value_alignment::with_grid)::value)
00647 {
00648 return compute_dispatch(
00649 mln_trait_image_value_access(I)(),
00650 mln_trait_image_value_access(L)(),
00651 mln_trait_image_ext_domain(I)(),
00652 mln_trait_image_ext_domain(L)(),
00653 a, input, label, nlabels);
00654 }
00655 else
00656 return impl::generic::compute(a, input, label, nlabels);
00657 }
00658
00659
00660 template <typename A, typename I, typename L>
00661 inline
00662 util::array<mln_result(A)>
00663 compute_dispatch(util::array<A>& a,
00664 const Image<I>& input,
00665 const Image<L>& label,
00666 const mln_value(L)& nlabels)
00667 {
00668 return compute_dispatch(mln_trait_image_value_storage(I)(),
00669 mln_trait_image_value_storage(L)(),
00670 a, input, label, nlabels);
00671 }
00672
00673
00674
00675
00676
00677 template <typename A, typename L>
00678 inline
00679 util::array<mln_result(A)>
00680 compute_dispatch(util::array<A>& accus,
00681 const Image<L>& label,
00682 const mln_value(L)& nlabels)
00683 {
00684 return impl::generic::compute(accus, label, nlabels);
00685 }
00686
00687 }
00688
00689
00690
00691
00692
00693 template <typename A, typename I, typename L>
00694 inline
00695 util::array<mln_result(A)>
00696 compute(util::array<A>& a,
00697 const Image<I>& input,
00698 const Image<L>& label,
00699 const mln_value(L)& nlabels)
00700 {
00701 trace::entering("labeling::compute");
00702
00703
00704
00705 typedef util::array<mln_result(A)> R;
00706 R res = internal::compute_dispatch(a, input, label, nlabels);
00707
00708 trace::exiting("labeling::compute");
00709 return res;
00710 }
00711
00712 template <typename A, typename I, typename L>
00713 inline
00714 util::array<mln_result(A)>
00715 compute(const Accumulator<A>& a,
00716 const Image<I>& input,
00717 const Image<L>& label,
00718 const mln_value(L)& nlabels)
00719 {
00720 trace::entering("labeling::compute");
00721
00722 internal::compute_tests(a, input, label, nlabels);
00723
00724 typedef util::array<mln_result(A)> R;
00725 R res = internal::compute_dispatch(a, input, label, nlabels);
00726
00727 trace::exiting("labeling::compute");
00728 return res;
00729 }
00730
00731 template <typename A, typename I, typename L>
00732 inline
00733 util::array<mln_meta_accu_result(A, mln_value(I))>
00734 compute(const Meta_Accumulator<A>& a,
00735 const Image<I>& input,
00736 const Image<L>& label,
00737 const mln_value(L)& nlabels)
00738 {
00739 typedef mln_accu_with(A, mln_value(I)) A_;
00740 A_ a_ = accu::unmeta(exact(a), mln_value(I)());
00741
00742 return compute(a_, input, label, nlabels);
00743 }
00744
00745
00746 template <typename A, typename L>
00747 inline
00748 util::array<mln_result(A)>
00749 compute(util::array<A>& accus,
00750 const Image<L>& label,
00751 const mln_value(L)& nlabels)
00752 {
00753 trace::entering("labeling::compute");
00754
00755 internal::compute_tests(A(), label, nlabels);
00756
00757 typedef util::array<mln_result(A)> R;
00758 R res = internal::compute_dispatch(accus, label, nlabels);
00759
00760 mln_postcondition(res.nelements() == value::next(nlabels));
00761
00762 trace::exiting("labeling::compute");
00763 return res;
00764 }
00765
00766
00767
00768 template <typename A, typename L>
00769 inline
00770 util::array<mln_result(A)>
00771 compute(const Accumulator<A>& a,
00772 const Image<L>& label,
00773 const mln_value(L)& nlabels)
00774 {
00775 trace::entering("labeling::compute");
00776
00777 internal::compute_tests(a, label, nlabels);
00778
00779 typedef util::array<mln_result(A)> R;
00780 R res = internal::compute_dispatch(a, label, nlabels);
00781
00782 mln_postcondition(res.nelements() == value::next(nlabels));
00783
00784 trace::exiting("labeling::compute");
00785 return res;
00786 }
00787
00788
00789 template <typename A, typename L>
00790 inline
00791 util::array<mln_meta_accu_result(A, mln_psite(L))>
00792 compute(const Meta_Accumulator<A>& a,
00793 const Image<L>& label,
00794 const mln_value(L)& nlabels)
00795 {
00796 typedef mln_accu_with(A, mln_psite(L)) A_;
00797 A_ a_ = accu::unmeta(exact(a), mln_psite(L)());
00798
00799 return compute(a_, label, nlabels);
00800 }
00801
00802
00803 # endif // ! MLN_INCLUDE_ONLY
00804
00805 }
00806
00807 }
00808
00809
00810 #endif // ! MLN_LABELING_COMPUTE_HH