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_IMAGE_HH
00027 # define MLN_LABELING_COMPUTE_IMAGE_HH
00028
00038
00039 # include <mln/core/concept/image.hh>
00040 # include <mln/core/concept/accumulator.hh>
00041 # include <mln/core/concept/meta_accumulator.hh>
00042
00043 # include <mln/labeling/compute.hh>
00044
00045
00046 namespace mln
00047 {
00048
00049 namespace labeling
00050 {
00051
00062 template <typename A, typename I, typename L>
00063 mln_ch_value(L, mln_result(A))
00064 compute_image(const util::array<mln_result(A)>& a,
00065 const Image<I>& input,
00066 const Image<L>& labels,
00067 const mln_value(L)& nlabels);
00068
00080 template <typename A, typename I, typename L>
00081 inline
00082 mln_ch_value(L, mln_result(A))
00083 compute_image(const Accumulator<A>& accu,
00084 const Image<I>& input,
00085 const Image<L>& labels,
00086 const mln_value(L)& nlabels);
00087
00088
00100 template <typename A, typename I, typename L>
00101 inline
00102 mln_ch_value(L, mln_meta_accu_result(A, mln_value(I)))
00103 compute_image(const Meta_Accumulator<A>& accu,
00104 const Image<I>& input,
00105 const Image<L>& labels,
00106 const mln_value(L)& nlabels);
00107
00108
00109 # ifndef MLN_INCLUDE_ONLY
00110
00111 namespace internal
00112 {
00113
00114 template <typename A, typename L>
00115 mln_ch_value(L, A)
00116 compute_image(const util::array<A>& a,
00117 const Image<L>& labels_,
00118 const mln_value(L)& nlabels)
00119 {
00120 const L& labels = exact(labels_);
00121
00122 typedef mln_ch_value(L, A) O;
00123 O output;
00124 initialize(output, labels);
00125
00126 mln_piter(L) p(labels.domain());
00127 for_all(p)
00128 {
00129 mln_assertion(labels(p) < nlabels);
00130 output(p) = a[labels(p)];
00131 }
00132
00133 return output;
00134 }
00135
00136 }
00137
00138
00139 template <typename A, typename I, typename L>
00140 inline
00141 mln_ch_value(L, mln_result(A))
00142 compute_image(const util::array<mln_result(A)>& a,
00143 const Image<L>& labels,
00144 const mln_value(L)& nlabels)
00145 {
00146 (void) nlabels;
00147
00148 trace::entering("labeling::compute_image");
00149
00150 mln_ch_value(L, mln_result(A)) output =
00151 labeling::internal::compute_image(a, labels, nlabels);
00152
00153 trace::exiting("labeling::compute_image");
00154 return output;
00155 }
00156
00157 template <typename A, typename I, typename L>
00158 inline
00159 mln_ch_value(L, mln_result(A))
00160 compute_image(const Accumulator<A>& accu,
00161 const Image<I>& input,
00162 const Image<L>& labels,
00163 const mln_value(L)& nlabels)
00164 {
00165 trace::entering("labeling::compute_image");
00166
00167 util::array<mln_result(A)> res =
00168 compute(accu, input, labels, nlabels);
00169
00170 mln_ch_value(L, mln_result(A)) output =
00171 internal::compute_image(res, labels, nlabels);
00172
00173 trace::exiting("labeling::compute_image");
00174 return output;
00175 }
00176
00177 template <typename A, typename I, typename L>
00178 inline
00179 mln_ch_value(L, mln_meta_accu_result(A, mln_value(I)))
00180 compute_image(const Meta_Accumulator<A>& accu,
00181 const Image<I>& input,
00182 const Image<L>& labels,
00183 const mln_value(L)& nlabels)
00184 {
00185 trace::entering("labeling::compute_image");
00186
00187 typedef mln_meta_accu_result(A, mln_value(I)) T;
00188
00189 util::array<T> res =
00190 compute(accu, input, labels, nlabels);
00191
00192 mln_ch_value(L, T) output =
00193 labeling::internal::compute_image(res, labels, nlabels);
00194
00195 trace::exiting("labeling::compute_image");
00196 return output;
00197 }
00198
00199 # endif // ! MLN_INCLUDE_ONLY
00200
00201 }
00202
00203 }
00204
00205 #endif // ! MLN_LABELING_COMPUTE_IMAGE_HH