UFTR.H

Go to the documentation of this file.

/* File: UFTR.H
   Auth: Andy Forsberg <asf@cs.brown.edu>
         Nicholas Yang <nyang@cs.brown.edu>
   Desc: The UserFriendlyTrackerRegistration class stores both registered
         and raw unregistered samples of the free-tracker and the
         head-tracker.  The user-friendly registration algorithm is
         implemented here in this file.
*/

#ifndef __UFTR_H__
#define __UFTR_H__

#include <fstream>
void write_matrix( char *filename, cWtransf &xf )
{
  ofstream str(filename);
  for(int i=0;i<16;i++) {
    char buf[256];
    double val = xf.matrix()[i];
    sprintf(buf, "%10.4lf", val);
    str << buf << " ";
  }
}

int read_matrix( char *filename, cWtransf &xf )
{
  ifstream str(filename);
  if (str.bad() || str.fail())
    return 0;

  for(int i=0;i<16;i++) {
    double val;
    str >> val;
    *((double *)xf.matrix()+i) = val;
  }
  return 1;
}


class UserFriendlyTrackerRegistration
{
  protected:
    int     _done_basic_reg;   // Flag for completion of basic registration
    int     _done_head_reg;    // Flag for completion of head registration

    Wtransf _K;                // Transformation to the known point K
    Wtransf _sample_basic_C;   // Raw free-tracker value at known point K
    Wtransf _sample_head_D;    // Raw head-tracker value at known point K

    Wtransf _raw_basic;        // Raw unregistered free-tracker value
    Wtransf _raw_head;         // Raw unregistered head-tracker value

    Wtransf _reg_basic;        // Registered free-tracker value
    Wtransf _reg_head;         // Registered head-tracker value

    Wtransf _mid_eye;          // Location of the mid-eye point

  public:
    UserFriendlyTrackerRegistration()
    {
      _done_basic_reg = _done_head_reg = 0;

      // Define the known point K here in a transformation matrix; in our
      // case, we had the known point positioned at 1' 1/4" in front of the
      // screen (the 1/4" was added to account for the tracker's thickness)
      _K = Wtransf::translation(Wvec(0, 0, 1.0 + 1.0/12.0/4.0));
    }

    int done_basic_registration() const { return _done_basic_reg; }
    int done_head_registration () const { return _done_head_reg; }

    // Returns samples for the free-tracker and head-tracker
    cWtransf &reg_basic() const { return _reg_basic; }
    cWtransf &reg_head() const { return _mid_eye; }
    cWtransf &raw_basic() const { return _raw_basic; }
    cWtransf &raw_head() const { return _raw_head; }

    cWtransf &sample_basic_C() const { return _sample_basic_C; }
    cWtransf &sample_head_D()  const { return _sample_head_D; }
    cWtransf &K()              const { return _K; }

    // Changes the known point K; registration should be performed again if
    // this is changed while the program is running
    void set_K(cWtransf &K) { _K = K; }

    // Changes the saved sample point C for the free-tracker
    void grab_basic_sample_C()
    {
      _done_basic_reg = 1;
      _sample_basic_C = _raw_basic;
      write_matrix(".LAST-RUN-basic", _sample_basic_C);
    }

    // Changes the saved sample point D for the head-tracker
    void grab_head_sample_D()
    {
      _done_head_reg = 1;
      _sample_head_D = _reg_head;
      write_matrix(".LAST-RUN-head",  _sample_head_D);
    }

    void use_last_runs_registration() {
      // use values from last run for basic & head registration
      read_matrix(".LAST-RUN-basic", _sample_basic_C);
      _done_basic_reg = 1;
      read_matrix(".LAST-RUN-head",  _sample_head_D);
      _done_head_reg = 1;
    }

    // Sets the saved raw unregistered transformation of the free-tracker
    void set_raw_basic_tracker_xf(cWtransf &xf)
    {
      _raw_basic = xf;

      if (_done_basic_reg)
        _reg_basic = register_basic_sample(_raw_basic);
    }

    // Sets the saved raw unregistered transformation of the head-tracker
    void set_raw_head_tracker_xf(cWtransf &xf)
    {
      _raw_head = xf;

      if (_done_basic_reg) {
        _reg_head = register_basic_sample(_raw_head);

        if (_done_head_reg)
          _mid_eye = register_head_sample(_reg_head);
      }
    }

    // BASIC REGISTRATION: This is where the equation:
    //
    //     X_reg = (K * C_inverted) * X_unreg
    //
    // is applied.  It should be constantly called by the tracker handler
    // function, because as the tracker moves, the transformation matrix
    // X_unreg (this is what the function is returning), which corrects the
    // tracker transformations based on the registration, has to be
    // constantly updated.
    Wtransf register_basic_sample(cWtransf &xf)
    {
      return (_K * _sample_basic_C.invert() * xf);
    }

    // TRACKED GLASSES REGISTRATION: This is where the head-tracking equation:
    //
    //     H = X_reg * (R_inverted * (K * T_inverted))
    //
    // is applied.  This is constantly called by the tracker handler because
    // as the head moves, H (this is what the function is returning), which
    // corrects the head-tracking transformations based on the registration,
    // has to be constantly updated.  Notice that it must make use of the
    // basic registration X_reg (the parameter xf below).
    Wtransf register_head_sample(cWtransf &xf)
    {
      // Get the rotation by zero-ing out the translation components
      Wtransf R = _sample_head_D;
      R(0, 3) = R(1, 3) = R(2, 3) = 0;

      // Get the transformation matrix for the translation
      Wtransf T = Wtransf::translation(Wvec(_sample_head_D(0, 3),
          _sample_head_D(1, 3), _sample_head_D(2, 3)));

      return (xf * (R.invert() * (_K * T.invert())));
    }
};

#endif // __UFTR_H__

---