olena_ dwt.hh source file.txt

DWT变换源代码

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         // end of recursion
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   } // end of namespace internal
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) : original_im(im)
00487       {
00488         ntg_is_a(original_im_value_t, ntg::real)::ensure();
00489 
00490         im_size = im.size().nth(0);
00491         assertion(im_size >= coeffs.size());
00492         for (unsigned i = 1; i < original_im_t::dim; i++)
00493           assertion(im_size == static_cast<unsigned>(im.size().nth(i)));
00494 
00495         max_level = static_cast<unsigned>(log(2 * im_size / coeffs.size()) /
00496                                internal::ln_2_);
00497 
00498         current_level = max_level;
00499 
00500         assertion(!(im_size % (1 << max_level)));
00501 
00502         trans_im = trans_im_t(im.size());
00503       }
00504 
00510       const trans_im_t transformed_image() const
00511       {
00512         return trans_im;
00513       }
00514 
00520       trans_im_t& transformed_image()
00521       {
00522         return trans_im;
00523       }
00524 
00532       trans_im_t transform(dwt_transform_type t = dwt_non_std,
00533                            bool normalized = true, unsigned l = 0)
00534       {
00535         if (l == 0) {
00536           l = max_level;
00537           current_level = max_level;
00538         } else {
00539           if (l > max_level)
00540             l = max_level;
00541           current_level = l;
00542         }
00543 
00544         oln_iter_type(trans_im_t) it(trans_im);
00545 
00546         if (normalized) {
00547           norm = pow(sqrt(2), original_im_t::dim * l);
00548           for_all(it)
00549             trans_im[it] = original_im[it] / norm;
00550         }
00551         else {
00552           norm = 1;
00553           for_all(it)
00554             trans_im[it] = original_im[it];
00555         }
00556 
00557         unsigned lim = im_size >> (l - 1);
00558         transform_type = t;
00559 
00560         internal::dwt_transform_(trans_im, lim, im_size, coeffs, t);
00561 
00562         return trans_im;
00563       }
00564 
00570       trans_im_t transform_inv(unsigned l = 0)
00571       {
00572         if (l == 0)
00573           l = current_level;
00574         else if (l > current_level)
00575           l = current_level;
00576 
00577         trans_im_t new_im(trans_im.size());
00578         oln_iter_type(trans_im_t) it(trans_im);
00579 
00580         if (norm != 1) {
00581           for_all(it)
00582             new_im[it] = trans_im[it] * norm;
00583         }
00584         else
00585           for_all(it)
00586             new_im[it] = trans_im[it];
00587 
00588         unsigned lim1 = im_size >> (current_level - 1);
00589         unsigned lim2 = im_size >> (current_level - l);
00590 
00591         internal::dwt_transform_inv_(new_im, lim1, lim2, coeffs, transform_type);
00592 
00593         return new_im;
00594       }
00595 
00603       template <class T1>
00604       typename mute<I, T1>::ret transform_inv(unsigned l = 0)
00605       {
00606         ntg_is_a(T1, ntg::real)::ensure();
00607 
00608         trans_im_t tmp_im = transform_inv(l);
00609         typename mute<I, T1>::ret new_im(tmp_im.size());
00610 
00611         oln_iter_type(trans_im_t) it(tmp_im);
00612 
00613         for_all(it)
00614           new_im[it] = (tmp_im[it] >= ntg_inf_val(T1) ?
00615                         (tmp_im[it] <= ntg_sup_val(T1) ?
00616                          tmp_im [it] :
00617                          ntg_sup_val(T1)) :
00618                         ntg_inf_val(T1));
00619         return new_im;
00620       }
00621 
00622     private:
00623 
00624       const original_im_t&      original_im; 
00625       trans_im_t                trans_im; 
00626       const coeffs_t            coeffs; 
00627       unsigned                  im_size; 
00628       unsigned                  max_level; 
00629       unsigned                  current_level; 
00630       ntg::float_d              norm; 
00631       dwt_transform_type        transform_type; 
00632     };
00633 
00634   } // end of namespace transforms
00635 
00636 } // end of namespace oln
00637 
00638 #endif // ! OLENA_TRANSFORMS_DWT_HH