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
00028 #ifndef OLENA_TRANSFORMS_DWT_HH
00029 # define OLENA_TRANSFORMS_DWT_HH
00030
00031 # include <oln/config/system.hh>
00032 # include <oln/basics.hh>
00033
00034 # include <ntg/basics.hh>
00035 # include <ntg/float.hh>
00036 # include <ntg/utils/cast.hh>
00037 # include <mlc/array/1d.hh>
00038
00039
00040
00041
00042 namespace oln {
00043
00047 namespace transforms {
00048
00049
00050
00051 # define Wavelet_coeffs_definition(Name, Type, Size) \
00052 struct Name : public oln::internal::wavelet_coeffs_<Type, Size, Name > \
00053 { \
00054 Name()
00055
00056 # define Wavelet_coeffs_begin \
00057 h = (wc_start =
00058
00059 # define Wavelet_coeffs_end \
00060 , end); \
00061 init(); \
00062 }
00063
00067 typedef enum {
00068 dwt_std,
00069 dwt_non_std
00070 } dwt_transform_type;
00071
00072 }
00073
00074 namespace internal
00075 {
00077 static const ntg::float_d ln_2_ = 0.6931471805599453092;
00078
00086 template <class T, unsigned N, class Self>
00087 struct wavelet_coeffs_
00088 {
00089 typedef T value_t;
00090 typedef Self self_t;
00091
00092 public:
00093
00094
00096 const value_t getG(unsigned i) const { return g[i]; }
00098 const value_t getInvG(unsigned i) const { return ig[i]; }
00100 const value_t getH(unsigned i) const { return h[i]; }
00102 const value_t getInvH(unsigned i) const { return ih[i]; }
00104 const unsigned size() const { return size_; }
00105
00106 protected:
00112 void init()
00113 {
00114 for (unsigned i = 0; i < size_; i += 2) {
00115 g[i] = -h[size_ - 1 - i];
00116 g[i + 1] = h[size_ - 2 - i];
00117 ig[size_ - 1 - i] = g[i + 1];
00118 ig[size_ - 2 - i] = h[i + 1];
00119 ih[size_ - 1 - i] = g[i];
00120 ih[size_ - 2 - i] = h[i];
00121 }
00122 }
00123
00127 wavelet_coeffs_(){}
00128
00134 ~wavelet_coeffs_()
00135 {
00136 mlc::is_false<N % 2>::ensure();
00137 }
00138
00139 mlc::array1d< mlc::array1d_info<N>, value_t> h;
00140 mlc::internal::array1d_start_<value_t> wc_start;
00141
00142 private:
00143
00144 value_t g[N];
00145 value_t ih[N];
00146 value_t ig[N];
00147 enum {
00148 size_ = N
00149 };
00150 };
00151
00164 template <class I, class K>
00165 void dwt_transform_step_(abstract::image<I>& im,
00166 const oln_point_type(I)& p_,
00167 const unsigned d,
00168 const unsigned n,
00169 const K& coeffs)
00170 {
00171 assertion(n >= coeffs.size());
00172
00173 const unsigned half = n >> 1;
00174 unsigned lim = n + 1 - coeffs.size();
00175 ntg::float_d* tmp = new ntg::float_d[n];
00176 oln_point_type(I) p(p_);
00177 unsigned i, j, k;
00178
00179 for (i = 0, j = 0; j < lim; j += 2, i++) {
00180 tmp[i] = 0;
00181 tmp[i + half] = 0;
00182 for (k = 0; k < coeffs.size(); k++) {
00183 p.nth(d) = j + k;
00184 tmp[i] += im[p] * coeffs.getH(k);
00185 tmp[i + half] += im[p] * coeffs.getG(k);
00186 }
00187 }
00188 for (; i < half; j += 2, i++) {
00189 tmp[i] = 0;
00190 tmp[i + half] = 0;
00191 for (unsigned k = 0; k < coeffs.size(); k++) {
00192 p.nth(d) = (j + k) % n;
00193 tmp[i] += im[p] * coeffs.getH(k);
00194 tmp[i + half] += im[p] * coeffs.getG(k);
00195 }
00196 }
00197
00198 for (i = 0; i < n; i++) {
00199 p.nth(d) = i;
00200 im[p] = tmp[i];
00201 }
00202
00203 delete[] tmp;
00204 }
00205
00218 template <class I, class K>
00219 void dwt_transform_inv_step_(abstract::image<I>& im,
00220 const oln_point_type(I)& p_,
00221 const unsigned d,
00222 const unsigned n,
00223 const K& coeffs)
00224 {
00225 assertion(n >= coeffs.size());
00226
00227 const unsigned half = n >> 1;
00228 unsigned lim = coeffs.size() - 2;
00229 ntg::float_d* tmp = new ntg::float_d[n];
00230 oln_point_type(I) p(p_), q(p_);
00231 unsigned i, j, k, l;
00232
00233 for (i = half - lim / 2, j = 0; j < lim; i++, j += 2) {
00234 tmp[j] = 0;
00235 tmp[j + 1] = 0;
00236 for (k = 0, l = 0; l < coeffs.size(); k++, l += 2) {
00237 p.nth(d) = (i + k) % half;
00238 q.nth(d) = p.nth(d) + half;
00239 tmp[j] += im[p] * coeffs.getInvH(l) + im[q] * coeffs.getInvH(l + 1);
00240 tmp[j + 1] += im[p] * coeffs.getInvG(l) + im[q] * coeffs.getInvG(l + 1);
00241 }
00242 }
00243 lim = n - 1;
00244 for (i = 0; j < lim; i++, j += 2) {
00245 tmp[j] = 0;
00246 tmp[j + 1] = 0;
00247 for (k = 0, l = 0; l < coeffs.size(); k++, l += 2) {
00248 p.nth(d) = i + k;
00249 q.nth(d) = p.nth(d) + half;
00250 tmp[j] += im[p] * coeffs.getInvH(l) + im[q] * coeffs.getInvH(l + 1);
00251 tmp[j + 1] += im[p] * coeffs.getInvG(l) + im[q] * coeffs.getInvG(l + 1);
00252 }
00253 }
00254
00255 for (i = 0; i < n; i++) {
00256 p.nth(d) = i;
00257 im[p] = tmp[i];
00258 }
00259
00260 delete[] tmp;
00261 }
00262
00263
00267 typedef enum {
00268 dwt_fwd,
00269 dwt_bwd
00270 } dwt_transform_dir_;
00271
00279 template <unsigned dim, unsigned skip,
00280 unsigned current = dim>
00281 struct dim_skip_iterate_rec_
00282 {
00286 template <class I, class K>
00287 static void doit(abstract::image<I>& im,
00288 oln_point_type(I)& p,
00289 const unsigned l1,
00290 const unsigned l2,
00291 const K& coeffs,
00292 dwt_transform_dir_ d)
00293 {
00294 if (current != skip) {
00295 for (unsigned i = 0; i < l2; i++) {
00296 p.nth(current - 1) = i;
00297 dim_skip_iterate_rec_<dim, skip, current - 1>::
00298 doit(im, p, l1, l2, coeffs, d);
00299 }
00300 p.nth(current - 1) = 0;
00301 }
00302 else
00303 dim_skip_iterate_rec_<dim, skip, current - 1>::
00304 doit(im, p, l1, l2, coeffs, d);
00305 }
00306 };
00307
00315 template <unsigned dim, unsigned skip>
00316 struct dim_skip_iterate_rec_<dim, skip, 0>
00317 {
00326 template <class I, class K>
00327 static void doit(abstract::image<I>& im,
00328 oln_point_type(I)& p,
00329 const unsigned l1,
00330 const unsigned l2,
00331 const K& coeffs,
00332 dwt_transform_dir_ d)
00333 {
00334 unsigned n;
00335
00336 switch (d) {
00337 case dwt_fwd:
00338 for (n = l2; n >= l1; n >>= 1)
00339 dwt_transform_step_(im, p, skip - 1, n, coeffs);
00340 break;
00341 case dwt_bwd:
00342 for (n = l1; n <= l2; n <<= 1)
00343 dwt_transform_inv_step_(im, p, skip - 1, n, coeffs);
00344 break;
00345 };
00346 }
00347 };
00348
00355 template <unsigned dim, unsigned skip>
00356 struct dim_iterate_rec_
00357 {
00364 template <class I, class K>
00365 static void doit(abstract::image<I>& im,
00366 oln_point_type(I)& p,
00367 const unsigned l1,
00368 const unsigned l2,
00369 const K& coeffs,
00370 dwt_transform_dir_ d)
00371 {
00372 dim_skip_iterate_rec_<dim, skip>::doit(im, p, l1, l2, coeffs, d);
00373 dim_iterate_rec_<dim, skip - 1>::doit(im, p, l1, l2, coeffs, d);
00374 }
00375 };
00376
00383 template <unsigned dim>
00384 struct dim_iterate_rec_<dim, 0>
00385 {
00386
00395 template <class I, class K>
00396 static void doit(abstract::image<I>& ,
00397 oln_point_type(I)& ,
00398 const unsigned ,
00399 const unsigned ,
00400 const K& ,
00401 dwt_transform_dir_ )
00402 {
00403
00404 }
00405 };
00406
00413 template <class I, class K>
00414 void dwt_transform_(abstract::image<I>& im,
00415 const unsigned l1,
00416 const unsigned l2,
00417 const K& coeffs,
00418 transforms::dwt_transform_type t)
00419 {
00420 oln_point_type(I) p;
00421
00422 switch (t) {
00423 case transforms::dwt_std:
00424 dim_iterate_rec_<I::dim, I::dim>::doit(im, p, l1, l2, coeffs, dwt_fwd);
00425 break;
00426 case transforms::dwt_non_std:
00427 for (unsigned n = l2; n >= l1; n >>= 1)
00428 dim_iterate_rec_<I::dim, I::dim>::doit(im, p, n, n, coeffs, dwt_fwd);
00429 break;
00430 }
00431 }
00432
00439 template <class I, class K>
00440 void dwt_transform_inv_(abstract::image<I>& im,
00441 const unsigned l1,
00442 const unsigned l2,
00443 const K& coeffs,
00444 transforms::dwt_transform_type t)
00445 {
00446 oln_point_type(I) p;
00447
00448 switch (t) {
00449 case transforms::dwt_std:
00450 dim_iterate_rec_<I::dim, I::dim>::doit(im, p, l1, l2, coeffs, dwt_bwd);
00451 break;
00452 case transforms::dwt_non_std:
00453 for (unsigned n = l1; n <= l2; n <<= 1)
00454 dim_iterate_rec_<I::dim, I::dim>::doit(im, p, n, n, coeffs, dwt_bwd);
00455 break;
00456 }
00457 }
00458
00459 }
00460
00461 namespace transforms {
00462
00469 template <class I, class K>
00470 class dwt
00471 {
00472 public:
00473
00474 typedef I original_im_t;
00475 typedef oln_value_type(I) original_im_value_t;
00476 typedef typename mute<I, ntg::float_d>::ret trans_im_t;
00477 typedef typename K::self_t coeffs_t;
00478
00486 dwt(const original_im_t& im) :
00487 original_im(im),
00488
00489
00490 coeffs()
00491 {
00492 ntg_is_a(original_im_value_t, ntg::real)::ensure();
00493
00494 im_size = im.size().nth(0);
00495 assertion(im_size >= coeffs.size());
00496 for (unsigned i = 1; i < original_im_t::dim; i++)
00497 assertion(im_size == static_cast<unsigned>(im.size().nth(i)));
00498
00499 max_level = static_cast<unsigned>(log(2 * im_size / coeffs.size()) /
00500 internal::ln_2_);
00501
00502 current_level = max_level;
00503
00504 assertion(!(im_size % (1 << max_level)));
00505
00506 trans_im = trans_im_t(im.size());
00507 }
00508
00514 const trans_im_t transformed_image() const
00515 {
00516 return trans_im;
00517 }
00518
00524 trans_im_t& transformed_image()
00525 {
00526 return trans_im;
00527 }
00528
00536 trans_im_t transform(dwt_transform_type t = dwt_non_std,
00537 bool normalized = true, unsigned l = 0)
00538 {
00539 if (l == 0) {
00540 l = max_level;
00541 current_level = max_level;
00542 } else {
00543 if (l > max_level)
00544 l = max_level;
00545 current_level = l;
00546 }
00547
00548 oln_iter_type(trans_im_t) it(trans_im);
00549
00550 if (normalized) {
00551 norm = pow(sqrt(2), original_im_t::dim * l);
00552 for_all(it)
00553 trans_im[it] = original_im[it] / norm;
00554 }
00555 else {
00556 norm = 1;
00557 for_all(it)
00558 trans_im[it] = original_im[it];
00559 }
00560
00561 unsigned lim = im_size >> (l - 1);
00562 transform_type = t;
00563
00564 internal::dwt_transform_(trans_im, lim, im_size, coeffs, t);
00565
00566 return trans_im;
00567 }
00568
00574 trans_im_t transform_inv(unsigned l = 0)
00575 {
00576 if (l == 0)
00577 l = current_level;
00578 else if (l > current_level)
00579 l = current_level;
00580
00581 trans_im_t new_im(trans_im.size());
00582 oln_iter_type(trans_im_t) it(trans_im);
00583
00584 if (norm != 1) {
00585 for_all(it)
00586 new_im[it] = trans_im[it] * norm;
00587 }
00588 else
00589 for_all(it)
00590 new_im[it] = trans_im[it];
00591
00592 unsigned lim1 = im_size >> (current_level - 1);
00593 unsigned lim2 = im_size >> (current_level - l);
00594
00595 internal::dwt_transform_inv_(new_im, lim1, lim2, coeffs, transform_type);
00596
00597 return new_im;
00598 }
00599
00607 template <class T1>
00608 typename mute<I, T1>::ret transform_inv(unsigned l = 0)
00609 {
00610 ntg_is_a(T1, ntg::real)::ensure();
00611
00612 trans_im_t tmp_im = transform_inv(l);
00613 typename mute<I, T1>::ret new_im(tmp_im.size());
00614
00615 oln_iter_type(trans_im_t) it(tmp_im);
00616
00617 for_all(it)
00618 new_im[it] = (tmp_im[it] >= ntg_inf_val(T1) ?
00619 (tmp_im[it] <= ntg_sup_val(T1) ?
00620 tmp_im [it] :
00621 ntg_sup_val(T1)) :
00622 ntg_inf_val(T1));
00623 return new_im;
00624 }
00625
00626 private:
00627
00628 const original_im_t& original_im;
00629 trans_im_t trans_im;
00630 const coeffs_t coeffs;
00631 unsigned im_size;
00632 unsigned max_level;
00633 unsigned current_level;
00634 ntg::float_d norm;
00635 dwt_transform_type transform_type;
00636 };
00637
00638 }
00639
00640 }
00641
00642 #endif // ! OLENA_TRANSFORMS_DWT_HH