shot.h

Go to the documentation of this file.

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* 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 (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/
/****************************************************************************
  History
$Log: not supported by cvs2svn $
Revision 1.12  2006/12/18 16:02:57  matteodelle
minor eroor correction on variable names

Revision 1.11  2006/12/18 15:26:24  callieri
added a function to approximate a far plane value given a shot and the mesh bbox

Revision 1.10  2006/12/18 14:28:07  matteodelle
*** empty log message ***

Revision 1.9  2006/12/18 09:46:39  callieri
camera+shot revamp: changed field names to something with more sense, cleaning of various functions, correction of minor bugs/incongruences, removal of the infamous reference in shot.

Revision 1.8  2006/01/11 16:06:25  matteodelle
*** empty log message ***


Revision 1.8  2005/01/11 17:06:30  dellepiane
FromTrackball() coorected (similarity->Extrinsics

Revision 1.7  2005/11/25 10:33:33  spinelli
shot.camera  -> shot.Intrinsics
shot.similarity.Matrix() -> shot.Extrinsics.Matrix()

Revision 1.6  2005/02/22 11:15:01  ganovelli
added vcg namespace

Revision 1.5  2005/02/11 11:43:09  tommyfranken
FromTrackball() corrected

Revision 1.4  2004/12/15 18:45:06  tommyfranken
*** empty log message ***

Revision 1.3  2004/11/03 09:41:57  ganovelli
added FromTrackball and fixed include names (Poiint to point)

Revision 1.2  2004/10/05 19:04:45  ganovelli
changed from classes to functions

Revision 1.1  2004/09/15 22:59:13  ganovelli
creation

Revision 1.2  2004/09/06 21:41:30  ganovelli
*** empty log message ***

Revision 1.1  2004/09/03 13:01:51  ganovelli
creation

****************************************************************************/


#ifndef __VCGLIB_GLSHOT
#define __VCGLIB_GLSHOT

// include vcg stuff
#include <vcg/space/point2.h>
#include <vcg/space/point3.h>
#include <vcg/math/similarity.h>

#include <vcg/math/shot.h>

// include wrap stuff
#include <wrap/gui/trackball.h>
#include <wrap/gl/math.h>
#include <wrap/gl/camera.h>

template <class ShotType>
struct GlShot {

        typedef typename ShotType::ScalarType ScalarType;
        typedef GlCamera<typename ShotType::CameraType> GlCameraType;

static void MatrixGL(ShotType & shot,vcg::Matrix44<ScalarType> & m) 
{
        m = shot.GetWorldToExtrinsicsMatrix();
}

static void TransformGL(vcg::Shot<ScalarType> & shot)
{
        vcg::Matrix44<ScalarType> m;
        MatrixGL(shot,m);
        glMultMatrix(m);
}

static void SetView(vcg::Shot<ScalarType> & shot, ScalarType nearDist, ScalarType farDist)
{
        assert(glGetError() == 0);
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        assert(glGetError() == 0);
        GlCameraType::TransformGL(shot.Intrinsics, nearDist, farDist); // apply camera/projection transformation
        assert(glGetError() == 0);

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        GlShot<ShotType>::TransformGL(shot);    // apply similarity/modelview transformation
        assert(glGetError() == 0);
}

static void     UnsetView()
{
        glPushAttrib(GL_TRANSFORM_BIT);
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glPopAttrib();
}

static ScalarType GetFarPlane(vcg::Shot<ScalarType> & shot, vcg::Box3<ScalarType> bbox)
{
        ScalarType farDist;

        vcg::Point3<ScalarType> farcorner;
    vcg::Point3<ScalarType> campos = shot.Extrinsics.Tra();
         
         if (abs(campos.X() - bbox.max.X()) > abs(campos.X() - bbox.min.X()))
                 farcorner.X() = bbox.max.X();
         else
                 farcorner.X() = bbox.min.X();

         if (abs(campos.Y() - bbox.max.Y()) > abs(campos.Y() - bbox.min.Y()))
                 farcorner.Y() = bbox.max.Y();
         else
                 farcorner.Y() = bbox.min.Y();

         if (abs(campos.Z() - bbox.max.Z()) > abs(campos.Z() - bbox.min.Z()))
                 farcorner.Z() = bbox.max.Z();
         else
                 farcorner.Z() = bbox.min.Z();

         farDist = (campos - farcorner).Norm();

        return farDist;
}


static void GetNearFarPlanes(vcg::Shot<ScalarType> & shot, vcg::Box3<ScalarType> bbox, ScalarType &nr, ScalarType &fr)
{
  vcg::Point3<ScalarType> zaxis = shot.Axis(2); 
  ScalarType offset = zaxis * shot.GetViewPoint();
  bool first = true;
  for(int i = 0; i < 8; i++) {
    vcg::Point3<ScalarType> c = bbox.P(i);
    ScalarType d = -(zaxis * c - offset);
    if(first || d < nr)  
      nr = d;
    if(first || d > fr)   
      fr = d;
    first = false;
  }
}



static void SetSubView(vcg::Shot<ScalarType> & shot,
                                           vcg::Point2<ScalarType> p1,
                                           vcg::Point2<ScalarType> p2)
{
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        assert(glGetError() == 0);
        GlCameraType::SetSubView(shot.Intrinsics,p1,0,1000,p2);
        assert(glGetError() == 0);
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        GlShot<ShotType>::TransformGL(shot);                                                    // apply similarity/modelview transformation
        assert(glGetError() == 0);
}


        
/**********************************
DEFINE SHOT FROM TRACKBALL
Adds to a given shot the trackball transformations.
After this operation the trackball should be resetted, to avoid
multiple apply of the same transformation.
***********************************/
static void FromTrackball(const vcg::Trackball & tr, 
                                                  vcg::Shot<ScalarType> & sShot, 
                                                  vcg::Shot<ScalarType> & shot )
{
        vcg::Point3<ScalarType>         cen; cen.Import(tr.center);
        vcg::Point3<ScalarType>         tra; tra.Import(tr.track.tra);
        vcg::Matrix44<ScalarType>       trM; trM.FromMatrix(tr.track.Matrix());

        vcg::Point3<ScalarType>         vp = Inverse(trM)*(sShot.GetViewPoint()-cen) +cen;// +tra;

        shot.SetViewPoint(vp);
        shot.Extrinsics.SetRot(sShot.Extrinsics.Rot()*trM);
//      shot.Extrinsics.sca     =       sShot.Extrinsics.sca*(ScalarType)tr.track.sca;
}
};
#endif