include/wipal/filter/linear_regression_synchronizer.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef FILTER_SYNCHRONIZER_HXX_
# define FILTER_SYNCHRONIZER_HXX_

# include "linear_regression_synchronizer.hh"

# include <wipal/tool/linear_regression.hh>
# include <wipal/tool/window.hh>
# include <wipal/filter/intersector.hh>
# include <wipal/filter/reference_blacklist.hh>

namespace wpl
{

  namespace filter
  {

    template <class OriginalFrameType, class ImplType>
    synchronized_frame<OriginalFrameType, ImplType>::
    synchronized_frame(const OriginalFrameType& orig,
                       const coefs_type&        coefs):
      OriginalFrameType (orig),
      coefs (coefs)
    {
    }

    namespace internals
    {

      template <class I, class B1, class B2>
      lr_sync_iterator<I, B1, B2>::
      lr_sync_iterator(const iterable_type& iterable, bool end):
        iterable_ (&iterable),
        win_ (end ? iterable.last_ : iterable.first_),
        wpos_ (0)
      {
        if (not end and win_ != iterable_->last_)
          while (not update_value() and advance())
            ;
      }

      template <class I, class B1, class B2>
      bool
      lr_sync_iterator<I, B1, B2>::equal(const exact_type& rhs) const
      {
        if (not rhs.value())
          return not this->value();
        return wpos_ == rhs.wpos_ and win_ == rhs.win_;
      }

      template <class I, class B1, class B2>
      bool
      lr_sync_iterator<I, B1, B2>::advance()
      {
        assert(win_ != iterable_->last_);

        const size_t    win_size = win_->size();

        if (wpos_ < win_size / 2)       // First window of trace.
          ++wpos_;
        else if (not win_.last())       // General case, middle of trace.
          ++win_;
        else if (++wpos_ >= win_size)   // Last window of trace.
          {
            // End of trace reached.
            this->value() = boost::none_t ();

            // Push win_ to the end and set wpos_ to zero just for safety.
            ++win_;
            wpos_ = 0;

            assert(win_ == iterable_->last_);
            return false;
          }
        assert(win_ != iterable_->last_);
        return true;
      }

      template <class I, class B1, class B2>
      bool
      lr_sync_iterator<I, B1, B2>::update_value()
      {
        typedef typename I::value_type::value_type              ref_type;

        assert(win_ != iterable_->last_);

        try
          {
            typedef typename value_type::impl_type              impl_type;
            typedef typename
              tool::lr::pair_with_microseconds<impl_type>       adapter_type;

            const std::pair<impl_type, impl_type> p =
              tool::linear_regression<impl_type, adapter_type>(win_->begin(),
                                                               win_->end());

            const ref_type&     ref = win_[wpos_];
            const impl_type     t1 = ref.first.microseconds();
            const impl_type     t2 = ref.second.microseconds();
            const impl_type     error = t2 - t1 * p.first - p.second;
            const impl_type     precision = iterable_->precision_;

            if (error < -precision or precision < error)
              {
                std::cerr << ref.first << '-' << ref.second
                          << ": Ignoring this ref. because of a "
                          << "high sync. error (" << error << ")."
                          << std::endl;
                return false;
              }
            if (p.first < 0.9 or 1.1 < p.first)
              std::cerr << ref.first << '-' << ref.second
                        << ": Dubious sync. coef. of " << p.first
                        << '.' << std::endl;

            this->value() = value_type (ref, p);
            return true;
          }
        catch (const std::invalid_argument& i)
          {
            assert(not win_->empty());

            const ref_type&     b = win_->front();
            const ref_type&     e = win_->back();

            std::cerr << b.first << '-' << b.second << ": " << i.what()
                      << ".\n" << e.first << '-' << e.second
                      << ": Sync. window's last reference." << std::endl;
            return false;
          }
      }

      template <class I, class B1, class B2>
      void
      lr_sync_iterator<I, B1, B2>::increment()
      {
        while (advance() and not update_value())
          ;
      }

    } // End of namespace wpl::filter::internals.

    template <class I, class B>
    linear_regression_synchronizer<I, B>::
    linear_regression_synchronizer(const I&             first,
                                   const I&             last,
                                   const unsigned       precision):
      first_ (first),
      last_ (last),
      precision_ (precision)
    {
    }

    namespace internals
    {

      template <class F>
      struct lrsync_wrapper
      {
        enum
          {
            window_size =

#ifdef WP_LRSYNC_WINDOW_SIZE
            WP_LRSYNC_WINDOW_SIZE
#else // ! WP_LRSYNC_WINDOW_SIZE
            4
#endif

          };

        typedef std::set< std::pair<unsigned, unsigned> >       ref_blacklist;

        lrsync_wrapper(F&                       func,
                       const ref_blacklist&     blist,
                       const unsigned&          prec):
          func_ (func),
          blist_ (blist),
          prec_ (prec)
        {
        }

        template <class Intersector>
        void
        operator () (const Intersector& i)
        {
          typedef typename Intersector::const_iterator          i_iterator;
          typedef reference_blacklist<i_iterator>               blist;
          typedef typename blist::const_iterator                b_iterator;
          typedef tool::window_maker<b_iterator, window_size>   window_maker;
          typedef typename window_maker::const_iterator         w_iterator;
          typedef linear_regression_synchronizer<w_iterator>    synchronizer;

          blist         l (i.begin(), i.end(), blist_);
          window_maker  w (l.begin(), l.end());
          synchronizer  s (w.begin(), w.end(), prec_);

          func_(s);
        }

      private:
        F&                      func_;
        const ref_blacklist&    blist_;
        const unsigned& prec_;
      };

    } // End of namespace wpl::filter::internals.

    template <class U, class HT, template <class, class, class> class Int,
              class I1, class I2, class F>
    void
    provide_lr_synchronizer(const I1& first1, const I1& last1,
                            const I2& first2, const I2& last2,
                            opt::list&  options,
                            F&          func)
    {
      typedef internals::lrsync_wrapper<F>      wrapper;
      typedef typename wrapper::ref_blacklist   blacklist;

      const blacklist&  blist = (options["ref_blacklist"].get<blacklist>());
      const unsigned&   prec = options["precision"].get<unsigned>();
      wrapper           wrap (func, blist, prec);

      provide_intersector<U, HT, Int>(first1, last1,
                                      first2, last2, options, wrap);
    }

  } // End of namespace wpl::filter.

} // End of namespace wpl.

#endif // ! FILTER_SYNCHRONIZER_HXX_

---