mitkTrackBall.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/


#ifndef __mitkTrackBall_h
#define __mitkTrackBall_h

#include "mitkMatrix.h"
#include "mitkQuaternion.h"
#include "mitkVisualizationIncludes.h"

const unsigned int RENORMCOUNT = 97;

class MITK_VISUALIZATION_API mitkTrackBall
{
public:
    mitkTrackBall();
    ~mitkTrackBall();

    void Start(float x, float y);
    void Update(float x, float y);
    void BuildRotMatrix(mitkMatrix &mat);
    const mitkQuaternion& GetCurrentQuat() { return m_CurQuat; }
    const mitkQuaternion& GetUpdateQuat() { return m_LastQuat; }
    

protected:

private:
//  void  _vZero(mitkVector &vec);
//  void  _normalizeQuat(mitkVector &quat);
    float _projectToSphere(float r, float x, float y);
//  void  _addQuats(mitkVector &q1, mitkVector &q2, mitkVector &dest);
//  void  _axisToQuat(mitkVector &a, float phi, mitkVector &q);
    
    static float          m_BallSize;
    static unsigned int   m_Count;

    mitkQuaternion m_CurQuat;
    mitkQuaternion m_LastQuat;
    float      m_LastX;
    float      m_LastY;
};

//inline void mitkTrackBall::_vZero(mitkVector &vec)
//{
//  vec.ele[0] = 0.0f;
//  vec.ele[1] = 0.0f;
//  vec.ele[2] = 0.0f;
//}

//inline void mitkTrackBall::_normalizeQuat(mitkVector &quat)
//{
//  float *q = quat;
//  float  t = 1.0f / (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
//
//  q[0] *= t;
//  q[1] *= t;
//  q[2] *= t;
//  q[3] *= t;
//}

inline float mitkTrackBall::_projectToSphere(float r, float x, float y)
{
    float d, z;
    
    d = x*x + y*y;
    if (d < r * r * 0.5f) // d < r / sqrt(2) --> inside sphere
    {
        z = sqrtf(r*r - d);
    }
    else // On hyperbola
    {
        z = 0.5f * r * r / sqrtf(d);
    }

    return z;
}

//inline void mitkTrackBall::_axisToQuat(mitkVector &a, float phi, mitkVector &q)
//{
//  a.Normalize();
//  q = a;
//  q *= sinf(phi*0.5f);
//  q.ele[3] = cosf(phi*0.5f);  
//}

//inline void mitkTrackBall::_addQuats(mitkVector &q1, mitkVector &q2, mitkVector &dest)
//{
//  mitkVector t1(q1), t2(q2), t3 ,tf;
//
//  t1 *= q2.ele[3];
//  t2 *= q1.ele[3];
//  t3 = q2 % q1; //cross
//  tf = t1 + t2 + t3;
//  tf.ele[3] = q1.ele[3] * q2.ele[3] - q1 * q2;
//
//  dest = tf;
//
//  if (++m_Count > RENORMCOUNT)
//  {
//      m_Count = 0;
//      this->_normalizeQuat(dest);
//  }
//}

inline void mitkTrackBall::Start(float x, float y)
{
    m_LastX = x;
    m_LastY = y;
    //this->_vZero(m_LastQuat);
    
    //m_LastQuat.ele[3] = 1.0f; 

    m_LastQuat.Identity();
}

inline void mitkTrackBall::Update(float x, float y)
{
    mitkVector a; /* Axis of rotation */
    mitkVector p1, p2, d;
    float phi;  /* how much to rotate about axis */
    float t;

    //  Might just be able to return here.
    if (m_LastX == x && m_LastY == y) 
    {
        /* Zero rotation */
        //this->_vZero(m_LastQuat);
        //m_LastQuat[3] = 1.0;
        m_LastQuat.Identity();
        return;
    }

    /*
     * First, figure out z-coordinates for projection of P1 and P2 to
     * deformed sphere
     */
    p1.ele[0] = m_LastX;
    p1.ele[1] = m_LastY;
    p1.ele[2] = this->_projectToSphere(m_BallSize, m_LastX, m_LastY);

    p2.ele[0] = x;
    p2.ele[1] = y;
    p2.ele[2] = this->_projectToSphere(m_BallSize, x, y);

    /*
     *  Now, we want the cross product of P1 and P2
     */
    a = p1 % p2;

    /*
     *  Figure out how much to rotate around that axis.
     */
    d = p1 - p2;
    t = d.Length() / (2.0f * m_BallSize);

    /*
     * Avoid problems with out-of-control values...
     */
    if (t > 1.0f) t = 1.0f;
    if (t < -1.0f) t = -1.0f;
    phi = 2.0f * asinf(t);

    //this->_axisToQuat(a, phi, m_LastQuat);
    m_LastQuat.AxisRadToQuat(a[0], a[1], a[2], phi);
//  this->_axisToQuat(a, phi, m_CurQuat);

    m_LastX = x;
    m_LastY = y;

    m_CurQuat = m_LastQuat * m_CurQuat;

    if (++m_Count > RENORMCOUNT)
    {
        m_Count = 0;
        m_CurQuat.Normalize();
    }

//  this->_addQuats(m_LastQuat, m_CurQuat, m_CurQuat);  
}

inline void mitkTrackBall::BuildRotMatrix(mitkMatrix &mat)
{
//  float *m = mat;

    m_CurQuat.BuildMatrix(mat);

/*
    m[0]  = 1.0f - 2.0f * (m_CurQuat[1] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[2]);
    m[1]  = 2.0f * (m_CurQuat[0] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[3]);
    m[2]  = 2.0f * (m_CurQuat[2] * m_CurQuat[0] - m_CurQuat[1] * m_CurQuat[3]);
    m[3]  = 0.0f;

    m[4]  = 2.0f * (m_CurQuat[0] * m_CurQuat[1] - m_CurQuat[2] * m_CurQuat[3]);
    m[5]  = 1.0f - 2.0f * (m_CurQuat[2] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[0]);
    m[6]  = 2.0f * (m_CurQuat[1] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[3]);
    m[7]  = 0.0f;

    m[8]  = 2.0f * (m_CurQuat[2] * m_CurQuat[0] + m_CurQuat[1] * m_CurQuat[3]);
    m[9]  = 2.0f * (m_CurQuat[1] * m_CurQuat[2] - m_CurQuat[0] * m_CurQuat[3]);
    m[10] = 1.0f - 2.0f * (m_CurQuat[0] * m_CurQuat[0] + m_CurQuat[1] * m_CurQuat[1]);
    m[11] = 0.0f;

    m[12] = 0.0f;
    m[13] = 0.0f;
    m[14] = 0.0f;
    m[15] = 1.0f;   
*/


/*
    m[0]  = 1.0f - 2.0f * (m_CurQuat[1] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[2]);
    m[1]  = 2.0f * (m_CurQuat[0] * m_CurQuat[1] - m_CurQuat[2] * m_CurQuat[3]);
    m[2]  = 2.0f * (m_CurQuat[2] * m_CurQuat[0] + m_CurQuat[1] * m_CurQuat[3]);
    m[3]  = 0.0f;

    m[4]  = 2.0f * (m_CurQuat[0] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[3]);
    m[5]  = 1.0f - 2.0f * (m_CurQuat[2] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[0]);
    m[6]  = 2.0f * (m_CurQuat[1] * m_CurQuat[2] - m_CurQuat[0] * m_CurQuat[3]);
    m[7]  = 0.0f;

    m[8]  = 2.0f * (m_CurQuat[2] * m_CurQuat[0] - m_CurQuat[1] * m_CurQuat[3]);
    m[9]  = 2.0f * (m_CurQuat[1] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[3]);
    m[10] = 1.0f - 2.0f * (m_CurQuat[0] * m_CurQuat[0] + m_CurQuat[1] * m_CurQuat[1]);
    m[11] = 0.0f;

    m[12] = 0.0f;
    m[13] = 0.0f;
    m[14] = 0.0f;
    m[15] = 1.0f;   */



/*
    m[0] = 1.0f - 2.0f * (m_CurQuat[1] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[2]);
    m[1] = 2.0f * (m_CurQuat[0] * m_CurQuat[1] - m_CurQuat[2] * m_CurQuat[3]);
    m[2] = 2.0f * (m_CurQuat[2] * m_CurQuat[0] + m_CurQuat[1] * m_CurQuat[3]);
    m[3] = 0.0f;

    m[4] = 2.0f * (m_CurQuat[0] * m_CurQuat[1] + m_CurQuat[2] * m_CurQuat[3]);
    m[5] = 1.0f - 2.0f * (m_CurQuat[2] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[0]);
    m[6] = 2.0f * (m_CurQuat[1] * m_CurQuat[2] - m_CurQuat[0] * m_CurQuat[3]);
    m[7] = 0.0f;

    m[8] = 2.0f * (m_CurQuat[2] * m_CurQuat[0] - m_CurQuat[1] * m_CurQuat[3]);
    m[9] = 2.0f * (m_CurQuat[1] * m_CurQuat[2] + m_CurQuat[0] * m_CurQuat[3]);
    m[10] = 1.0f - 2.0f * (m_CurQuat[1] * m_CurQuat[1] + m_CurQuat[0] * m_CurQuat[0]);
    m[11] = 0.0f;

    m[12] = 0.0f;
    m[13] = 0.0f;
    m[14] = 0.0f;
    m[15] = 1.0f;
*/
}

/*
 * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 * Permission to use, copy, modify, and distribute this software for
 * any purpose and without fee is hereby granted, provided that the above
 * copyright notice appear in all copies and that both the copyright notice
 * and this permission notice appear in supporting documentation, and that
 * the name of Silicon Graphics, Inc. not be used in advertising
 * or publicity pertaining to distribution of the software without specific,
 * written prior permission.
 *
 * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
 * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
 * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
 * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
 * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
 * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
 * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
 * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * US Government Users Restricted Rights
 * Use, duplication, or disclosure by the Government is subject to
 * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
 * (c)(1)(ii) of the Rights in Technical Data and Computer Software
 * clause at DFARS 252.227-7013 and/or in similar or successor
 * clauses in the FAR or the DOD or NASA FAR Supplement.
 * Unpublished-- rights reserved under the copyright laws of the
 * United States.  Contractor/manufacturer is Silicon Graphics,
 * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
 *
 * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
 */

#endif

---