vcglib: shot.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 /****************************************************************************
00024   History
00025 $Log: not supported by cvs2svn $
00026 Revision 1.24  2008/02/22 17:41:48  ponchio
00027 Changed to reflect quaternion toMatrix inversion.
00028 
00029 Revision 1.23  2007/02/06 08:54:07  corsini
00030 fix names
00031 
00032 Revision 1.22  2007/02/05 14:17:21  corsini
00033 add extrinsic parameters accessors
00034 
00035 Revision 1.21  2006/12/18 16:02:55  matteodelle
00036 minor eroor correction on variable names
00037 
00038 Revision 1.20  2006/12/18 09:46:39  callieri
00039 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.
00040 
00041 Revision 1.19  2006/01/22 17:01:40  cignoni
00042 Corrected intialization of flag, must be zero.
00043 
00044 Revision 1.18  2005/12/12 16:53:43  callieri
00045 corrected UnProject, it's necessary also a ZDepth value to perform inverse projection
00046 
00047 Revision 1.17  2005/12/07 10:57:52  callieri
00048 added commodity function ProjectWorldtoViewport() to obtain directly pixel indices without calling two separate function of two different objects
00049 
00050 Revision 1.16  2005/12/02 16:14:35  callieri
00051 in Shot<S>::Axis changed Row3  to  GetRow3 . row3 was the old method name of Matrix44
00052 
00053 Revision 1.15  2005/12/01 01:03:37  cignoni
00054 Removed excess ';' from end of template functions, for gcc compiling
00055 
00056 Revision 1.14  2005/11/23 14:18:35  ganovelli
00057 added access to similarity (just for symmetry with Camera() )
00058 
00059 Revision 1.13  2005/11/23 11:58:52  ganovelli
00060 Empty constructor added, untemplated class Shotf and Shotd added
00061 usage: Shotf myShot;
00062 corrected member access rights
00063 
00064 Revision 1.12  2005/07/11 13:12:35  cignoni
00065 small gcc-related compiling issues (typenames,ending cr, initialization order)
00066 
00067 Revision 1.11  2005/01/22 11:20:20  ponchio
00068 <...Point3.h> -> <...point3.h>
00069 
00070 Revision 1.10  2005/01/05 13:26:15  ganovelli
00071 corretto cambiamento di sistema di rif.
00072 
00073 Revision 1.9  2004/12/15 18:45:50  tommyfranken
00074 *** empty log message ***
00075 
00076 Revision 1.4  2004/10/07 14:41:31  fasano
00077 Little fix on ViewPoint() method
00078 
00079 Revision 1.3  2004/10/07 14:24:53  ganovelli
00080 added LookAt,LookToward
00081 
00082 Revision 1.2  2004/10/05 19:04:25  ganovelli
00083 version 5-10-2004 in progress
00084 
00085 Revision 1.1  2004/09/15 22:58:05  ganovelli
00086 re-creation
00087 
00088 Revision 1.2  2004/09/06 21:41:30  ganovelli
00089 *** empty log message ***
00090 
00091 Revision 1.1  2004/09/03 13:01:51  ganovelli
00092 creation
00093 
00094 ****************************************************************************/
00095 
00119 #ifndef __VCGLIB_SHOT
00120 #define __VCGLIB_SHOT
00121 
00122 #include <vcg/space/point2.h>
00123 #include <vcg/space/point3.h>
00124 #include <vcg/math/similarity.h>
00125 #include <vcg/math/camera.h>
00126 
00127 namespace vcg{
00128 
00129 template <class S, class RotationType = Matrix44<S> >
00130 class Shot {
00131 public:
00132         typedef Camera<S> CameraType;
00133         typedef S ScalarType;
00134 
00135         template <class ScalarType, class RotoType >
00136         class ReferenceFrame {
00137                 friend class Shot<ScalarType, RotoType>;
00138                         RotoType rot;    // rotation
00139                         Point3<S> tra; // viewpoint
00140         public:
00141                         void SetIdentity(){ rot.SetIdentity(); tra = Point3<S>(0.0,0.0,0.0);}
00142                         void SetTra(const Point3<S> & tr) {tra = tr;}
00143                         void SetRot(const  RotoType & rt) {rot = rt;}
00144                         Point3<ScalarType>   Tra() const  { return tra;}
00145                         RotoType Rot() const  { return rot;}
00146         };
00147 
00148         Camera<S>                                                                                               Intrinsics;             // the camera that made the shot
00149         ReferenceFrame<S,RotationType>  Extrinsics;             // the position and orientation of the camera
00150 
00151 
00152         Shot(Camera<S> c)
00153         {
00154                 Intrinsics = c;
00155                 Extrinsics.SetIdentity();
00156         }
00157 
00158         Shot()
00159         {
00160                 Extrinsics.SetIdentity();
00161         }
00162 
00163 
00165         vcg::Point3<S> Axis(const int & i)const;
00166 
00168         const vcg::Point3<S> GetViewPoint()const;
00170         void SetViewPoint(const vcg::Point3<S> & viewpoint);
00171 
00173         void LookAt(const vcg::Point3<S> & point,const vcg::Point3<S> & up);
00174 
00176         void LookAt(const S & eye_x,const S & eye_y,const S & eye_z,
00177                                 const S & at_x,const S & at_y,const S & at_z,
00178                                 const S & up_x,const S & up_y,const S & up_z);
00179 
00181         void LookTowards(const vcg::Point3<S> & z_dir,const vcg::Point3<S> & up);
00182 
00184         vcg::Point3<S>  ConvertWorldToCameraCoordinates(const vcg::Point3<S> & p) const;
00185 
00187         vcg::Point3<S>  ConvertCameraToWorldCoordinates(const vcg::Point3<S> & p) const;
00188 
00191         vcg::Point3<S> ConvertCameraToWorldCoordinates_Substitute(const vcg::Point3<S> & p) const;
00192 
00194         vcg::Point2<S> Project(const vcg::Point3<S> & p) const;
00195 
00197         vcg::Point3<S> UnProject(const vcg::Point2<S> & p, const S & d) const;
00198 
00201         vcg::Point3<S> UnProject_Substitute(const vcg::Point2<S> & p, const S & d) const;
00202 
00204         S Depth(const vcg::Point3<S> & p)const;
00205 
00206 
00207 // accessors
00208 public:
00209 
00210         /* Returns the matrix M such that
00211           3dpoint_in_world_coordinates = M * 3dpoint_in_local_coordinates
00212         */
00213                 Matrix44<S> GetExtrinsicsToWorldMatrix() const {
00214                                 Matrix44<S> rotM ;
00215                                 Extrinsics.rot.ToMatrix(rotM);
00216                                 return Matrix44<S>().SetTranslate(Extrinsics.tra) * rotM.transpose();
00217                 }
00218 
00219         /* Returns the matrix M such that
00220           3dpoint_in_local_coordinates = M * 3dpoint_in_world_coordinates
00221         */
00222                 Matrix44<S> GetWorldToExtrinsicsMatrix() const {
00223                                 Matrix44<S> rotM ;
00224                                 Extrinsics.rot.ToMatrix(rotM);
00225                                 return rotM  * Matrix44<S>().SetTranslate(-Extrinsics.tra) ;
00226                 }
00227 
00228         /*  multiply the current reference frame for the matrix passed
00229          note: it is up to the caller to check the the matrix passed is a pure rototraslation
00230          */
00231         void MultMatrix(    vcg::Matrix44<S>    m44)
00232         {
00233                 Extrinsics.tra = m44 * Extrinsics.tra;
00234                 m44[0][3] = m44[1][3] = m44[2][3] =  0.0;
00235                 Extrinsics.rot = m44 * Extrinsics.rot ;
00236         }
00237 
00238         /*  multiply the current reference frame for the similarity passed
00239          note: it is up to the caller to check the the matrix passed is a pure rototraslation
00240          */
00241         void MultSimilarity( const Similarity<S> & s){ MultMatrix(s.Matrix());}
00242         
00243         bool IsValid() const 
00244         {
00245                 return Intrinsics.PixelSizeMm[0]>0 && Intrinsics.PixelSizeMm[1]>0;
00246         }
00247 
00248 }; // end class definition
00249 
00250 
00251 
00252 //---
00254 template <class S, class RotationType>
00255 const vcg::Point3<S> Shot<S,RotationType>::GetViewPoint() const
00256 {
00257         return  Extrinsics.tra;
00258 }
00260 template <class S, class RotationType>
00261 void Shot<S,RotationType>::SetViewPoint(const vcg::Point3<S> & viewpoint)
00262 {
00263         Extrinsics.SetTra( viewpoint );
00264 }
00265 //---
00266 
00268 template <class S, class RotationType>
00269 vcg::Point3<S>  Shot<S,RotationType>::Axis(const int & i) const
00270 {
00271         vcg::Matrix44<S> m;
00272         Extrinsics.rot.ToMatrix(m);
00273         vcg::Point3<S> aa = m.GetRow3(i);
00274         return aa;
00275 }
00276 
00278 template <class S, class RotationType>
00279 void Shot<S,RotationType>::LookAt(const vcg::Point3<S> & z_dir,const vcg::Point3<S> & up)
00280 {
00281           LookTowards(z_dir-GetViewPoint(),up);
00282 }
00283 
00285 template <class S, class RotationType>
00286 void Shot<S,RotationType>::LookAt(const S & eye_x, const S & eye_y, const S & eye_z,
00287                                          const S & at_x, const S & at_y, const S & at_z,
00288                                          const S & up_x,const S & up_y,const S & up_z)
00289 {
00290         SetViewPoint(Point3<S>(eye_x,eye_y,eye_z));
00291         LookAt(Point3<S>(at_x,at_y,at_z),Point3<S>(up_x,up_y,up_z));
00292 }
00293 
00295 template <class S, class RotationType>
00296 void Shot<S,RotationType>::LookTowards(const vcg::Point3<S> & z_dir,const vcg::Point3<S> & up)
00297 {
00298         vcg::Point3<S> x_dir = up ^-z_dir;
00299         vcg::Point3<S> y_dir = -z_dir ^x_dir;
00300 
00301         Matrix44<S> m;
00302         m.SetIdentity();
00303         *(vcg::Point3<S> *)&m[0][0] =  x_dir/x_dir.Norm();
00304         *(vcg::Point3<S> *)&m[1][0] =  y_dir/y_dir.Norm();
00305         *(vcg::Point3<S> *)&m[2][0] = -z_dir/z_dir.Norm();
00306 
00307         Extrinsics.rot.FromMatrix(m);
00308 }
00309 
00310 //--- Space transformation methods
00311 
00313 template <class S, class RotationType>
00314 vcg::Point3<S> Shot<S,RotationType>::ConvertWorldToCameraCoordinates(const vcg::Point3<S> & p) const
00315 {
00316         Matrix44<S> rotM;
00317         Extrinsics.rot.ToMatrix(rotM);
00318         vcg::Point3<S> cp = rotM * (p - GetViewPoint() );
00319         cp[2]=-cp[2];   // note: camera reference system is right handed
00320         return cp;
00321         }
00322 
00324 template <class S, class RotationType>
00325 vcg::Point3<S> Shot<S,RotationType>::ConvertCameraToWorldCoordinates(const vcg::Point3<S> & p) const
00326 {
00327         Matrix44<S> rotM;
00328         vcg::Point3<S> cp = p;
00329         cp[2]=-cp[2];   // note: World reference system is left handed
00330         Extrinsics.rot.ToMatrix(rotM);
00331         cp = rotM.transpose() * cp + GetViewPoint();
00332         return cp;
00333 }
00334 
00337 template <class S, class RotationType>
00338 vcg::Point3<S> Shot<S,RotationType>::ConvertCameraToWorldCoordinates_Substitute(const vcg::Point3<S> & p) const
00339 {
00340         Matrix44<S> rotM;
00341         vcg::Point3<S> cp = p;
00342         cp[2]=-cp[2];   // note: World reference system is left handed
00343         Extrinsics.rot.ToMatrix(rotM);
00344         cp = Inverse(rotM) * cp + GetViewPoint(); // use invert istead of transpose to dela with non-rigid cases
00345         return cp;
00346 }
00347 
00349 template <class S, class RotationType>
00350 vcg::Point2<S> Shot<S,RotationType>::Project(const vcg::Point3<S> & p) const
00351 {
00352         Point3<S> cp = ConvertWorldToCameraCoordinates(p);
00353         Point2<S> pp = Intrinsics.Project(cp);
00354         Point2<S> vp = Intrinsics.LocalToViewportPx(pp);
00355         return vp;
00356 }
00357 
00359 template <class S, class RotationType>
00360 vcg::Point3<S> Shot<S,RotationType>::UnProject(const vcg::Point2<S> & p, const S & d) const
00361 {
00362         Point2<S> lp = Intrinsics.ViewportPxToLocal(p);
00363         Point3<S> cp = Intrinsics.UnProject(lp,d);
00364         Point3<S> wp = ConvertCameraToWorldCoordinates(cp);
00365         return wp;
00366 }
00367 
00370 template <class S, class RotationType>
00371 vcg::Point3<S> Shot<S,RotationType>::UnProject_Substitute(const vcg::Point2<S> & p, const S & d) const
00372 {
00373         Point2<S> lp = Intrinsics.ViewportPxToLocal(p);
00374         Point3<S> cp = Intrinsics.UnProject(lp,d);
00375         Point3<S> wp = ConvertCameraToWorldCoordinates_Substitute(cp);
00376         return wp;
00377 }
00378 
00380 template <class S, class RotationType>
00381 S Shot<S,RotationType>::Depth(const vcg::Point3<S> & p)const
00382 {
00383         return ConvertWorldToCameraCoordinates(p).Z();
00384 }
00385 
00386 
00387 
00388 //--------------------------------
00389 
00390 
00391 //--- utility definitions
00392 class Shotf: public Shot<float>{};
00393 class Shotd: public Shot<double>{};
00394 //-----------------------
00395 
00396 } // end name space
00397 
00398 #endif
00399 
00400 
00401 
00402