re-creation
This commit is contained in:
ganovelli
parent
de4b5c1d43
commit
c97e11dbb8
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,996 @@
|
|||
/****************************************************************************
|
||||
* 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.2 2004/09/06 21:41:30 ganovelli
|
||||
*** empty log message ***
|
||||
|
||||
Revision 1.1 2004/09/03 13:01:51 ganovelli
|
||||
creation
|
||||
|
||||
/****************************************************************************/
|
||||
|
||||
|
||||
#ifndef __VCGLIB_SHOT
|
||||
#define __VCGLIB_SHOT
|
||||
|
||||
// #include <vector>
|
||||
// #include <vcg/Matrix44.h>
|
||||
// #include <vcg/Box3.h>
|
||||
#include <vcg/space/Point2.h>
|
||||
#include <vcg/space/Point3.h>
|
||||
#include <vcg/math/similarity.h>
|
||||
#include <vcg/math/camera.h>
|
||||
|
||||
namespace vcg{
|
||||
|
||||
template <class S>
|
||||
class Shot {
|
||||
public:
|
||||
typedef Camera<S> CameraType;
|
||||
typedef S ScalarType;
|
||||
|
||||
Camera<S> & camera; // the camera that shot
|
||||
vcg::Similarity<S> similarity; // the position from where it did it
|
||||
|
||||
Shot(const Camera<S> & c):camera(c){}
|
||||
|
||||
Camera<S> & Camera(){return camera;};
|
||||
|
||||
/// take the i-th axis of the coordinate system of the camera
|
||||
vcg::Point3<S>const & Axis(const int & i)const { vcg::Matrix44<S> m; similarity.rot.ToMatrix(m); return m.Column3(i);}
|
||||
|
||||
/// take the viewpoint
|
||||
vcg::Point3<S>const & ViewPoint();
|
||||
|
||||
/// convert a 3d point in camera coordinates
|
||||
vcg::Point3<S> ConvertToCameraCoordinates(const vcg::Point3<S> & p) const;
|
||||
|
||||
/// project onto the camera plane
|
||||
vcg::Point2<S> Shot<S>::Project(const vcg::Point3<S> & p) const;
|
||||
|
||||
/// take the distance from the point p and the plane parallel to the camera plane and passing through the view
|
||||
/// point. The would be z depth
|
||||
S Depth(const vcg::Point3<S> & p)const;
|
||||
}; // end class definition
|
||||
|
||||
template <class S>
|
||||
vcg::Point3<S>const & Shot<S>::ViewPoint(){
|
||||
Matrix44 m = similarity.Matrix();
|
||||
return Point3<S>(m[0][3],m[1][3],m[2][3]);
|
||||
}
|
||||
|
||||
template <class S>
|
||||
vcg::Point3<S> Shot<S>::ConvertToCameraCoordinates(const vcg::Point3<S> & p) const{
|
||||
vcg::Point3 tmp = similarity.Matrix()*p;
|
||||
}
|
||||
|
||||
template <class S>
|
||||
vcg::Point2<S> Shot<S>::Project(const vcg::Point3<S> & p) const{
|
||||
return cam->Project(ConvertToCameraCoordinates(p));
|
||||
}
|
||||
|
||||
template <class S>
|
||||
S Shot<S>::Depth(const vcg::Point3<S> & p)const {
|
||||
return (cam->Project(ConvertToCameraCoordinates(p))).
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//private:
|
||||
//
|
||||
// static inline S SQRT( S x) { return sqrt(fabs(x)); }
|
||||
// static inline S CBRT ( S x )
|
||||
// {
|
||||
// if (x == 0) return 0;
|
||||
// else if (x > 0) return pow (x, 1.0 / 3.0);
|
||||
// else return -pow (-x, 1.0 / 3.0);
|
||||
// }
|
||||
// static inline void SINCOS( S x, S & s, S & c)
|
||||
// {
|
||||
// s=sin(x);
|
||||
// c=cos(x);
|
||||
// }
|
||||
// static inline void SINCOSd( double x, double & s, double & c)
|
||||
// {
|
||||
// s=sin(x);
|
||||
// c=cos(x);
|
||||
// }
|
||||
// static inline S CUB( S x ) { return x*x*x; }
|
||||
// static inline S SQR( S x ) { return x*x; }
|
||||
//
|
||||
//public:
|
||||
// void undistorted_to_distorted_sensor_coord (S Xu, S Yu, S & Xd, S & Yd) const
|
||||
// {
|
||||
// const S SQRT3 = S(1.732050807568877293527446341505872366943);
|
||||
// S Ru,Rd,lambda,c,d,Q,R,D,S,T,sinT,cosT;
|
||||
//
|
||||
// if((Xu==0 && Yu==0) || k[0] == 0)
|
||||
// {
|
||||
// Xd = Xu;
|
||||
// Yd = Yu;
|
||||
// return;
|
||||
// }
|
||||
//
|
||||
// Ru = hypot (Xu, Yu); /* SQRT(Xu*Xu+Yu*Yu) */
|
||||
// c = 1 / k[0];
|
||||
// d = -c * Ru;
|
||||
//
|
||||
// Q = c / 3;
|
||||
// R = -d / 2;
|
||||
// D = CUB (Q) + SQR (R);
|
||||
//
|
||||
// if (D >= 0) /* one real root */
|
||||
// {
|
||||
// D = SQRT (D);
|
||||
// S = CBRT (R + D);
|
||||
// T = CBRT (R - D);
|
||||
// Rd = S + T;
|
||||
//
|
||||
// if (Rd < 0)
|
||||
// Rd = SQRT (-1 / (3 * k[0]));
|
||||
// }
|
||||
// else /* three real roots */
|
||||
// {
|
||||
// D = SQRT (-D);
|
||||
// S = CBRT (hypot (R, D));
|
||||
// T = atan2 (D, R) / 3;
|
||||
// SINCOS (T, sinT, cosT);
|
||||
//
|
||||
// /* the larger positive root is 2*S*cos(T) */
|
||||
// /* the smaller positive root is -S*cos(T) + SQRT(3)*S*sin(T) */
|
||||
// /* the negative root is -S*cos(T) - SQRT(3)*S*sin(T) */
|
||||
// Rd = -S * cosT + SQRT3 * S * sinT; /* use the smaller positive root */
|
||||
// }
|
||||
//
|
||||
// lambda = Rd / Ru;
|
||||
//
|
||||
// Xd = Xu * lambda;
|
||||
// Yd = Yu * lambda;
|
||||
// }
|
||||
//
|
||||
//
|
||||
//void correction(double k, float i, float j, float &disi, float &disj)
|
||||
//{
|
||||
// // (i,j) punto nell'immagine distorta
|
||||
// // (disi,disj) punto nell'immagine corretta (undistorted)
|
||||
// float hyp;
|
||||
// float I,J,ni,nj;
|
||||
// float ratio = 1;
|
||||
//
|
||||
// ni = i-viewport[0]/2;
|
||||
// nj = j-viewport[1]/2;
|
||||
// hyp = ni*ni + nj*nj;
|
||||
//
|
||||
// I = ni * (1+ k * hyp);
|
||||
// J = nj * (1+ k * hyp);
|
||||
//
|
||||
// disi = (I*ratio+viewport[0]/2);
|
||||
// disj = (J*ratio+viewport[1]/2);
|
||||
//}
|
||||
//
|
||||
//
|
||||
//
|
||||
//void distorsion( float k ,float i, float j,double & disi, double &disj)
|
||||
//{
|
||||
// // (i,j) punto nell'immagine corretta (undistorted)
|
||||
// // (disi,disj) punto nell'immagine distorta
|
||||
// float hyp;
|
||||
// int _I,_J;
|
||||
// float I,J,ni,nj;
|
||||
// I = i-viewport[0]/2;
|
||||
// J = j-viewport[1]/2;
|
||||
// hyp = sqrt(I*I + J*J);
|
||||
// if((k==0.0) || (hyp <0.001))
|
||||
// {
|
||||
// disi = i;
|
||||
// disj = j;
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// undistorted_to_distorted_sensor_coord (I, J, disi, disj);
|
||||
// disi += viewport[0]/2;
|
||||
// disj += viewport[1]/2;
|
||||
//
|
||||
//
|
||||
//// hyp = (viewport[0]*viewport[0] + viewport[1]*viewport[1])/4;
|
||||
//// ni = SX/2 + SX/2 * cam.k[0] * hyp;
|
||||
///// nj = SY/2 + SY/2 * cam.k[0] * hyp;
|
||||
//// float ratio = sqrt(hyp/(ni*ni + nj*nj));
|
||||
// float ratio=1;
|
||||
//
|
||||
//
|
||||
//
|
||||
// //----------- Maple
|
||||
// // float t0,t1,t2,sol;
|
||||
//
|
||||
// //t0 = 1/k*pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333)/6.0-2.0/pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333);
|
||||
//
|
||||
//
|
||||
// //t1 = -1/k*pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333)/12.0+1/pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*
|
||||
// //hyp*k)/k))*k*k,0.3333333333333333)+sqrt(-1.0)*sqrt(3.0)*(1/k*pow((108.0*hyp+
|
||||
// //12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333)/6.0+2.0/
|
||||
// //pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,
|
||||
// //0.3333333333333333))/2.0;
|
||||
//
|
||||
// //t2 = -1/k*pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333)/12.0+1/pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*
|
||||
// //hyp*k)/k))*k*k,0.3333333333333333)-sqrt(-1.0)*sqrt(3.0)*(1/k*pow((108.0*hyp+
|
||||
// //12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,0.3333333333333333)/6.0+2.0/
|
||||
// //pow((108.0*hyp+12.0*sqrt(3.0)*sqrt((4.0+27.0*hyp*hyp*k)/k))*k*k,
|
||||
// //0.3333333333333333))/2.0;
|
||||
//
|
||||
// //sol = (t0>t1)?t0:t1;
|
||||
// //sol = (sol<t2)?t2:sol;
|
||||
// //sol = t0;
|
||||
// //ni = sol*I/hyp;
|
||||
// //nj = sol*J/hyp;
|
||||
// ////-----------
|
||||
//
|
||||
// //disi = (ni*ratio+viewport[0]/2);
|
||||
// //disj = (nj*ratio+viewport[1]/2);
|
||||
// }
|
||||
//}
|
||||
// void ResizeGridMap(const int & si,const int & sj ){
|
||||
// int j;
|
||||
// gridMap.resize(sj+1);
|
||||
// for(j=0; j < sj+1; j++)
|
||||
// gridMap[j].resize(si+1);
|
||||
// }
|
||||
// void UpdateGridMap(){
|
||||
// int sj = gridMap.size();
|
||||
// int si = gridMap[0].size();
|
||||
// int i,j;
|
||||
// for(j=0; j < sj; j++)
|
||||
// for(i=0; i < gridMap[0].size(); i++)
|
||||
// // gridMap[i][j] = Point2<scalar> (i/(double)(si-1),j/(double)(sj-1));
|
||||
// {
|
||||
// double disi,disj;
|
||||
// distorsion( k[0] ,(i/(double)(si-1))*viewport[0], (j/(double)(sj-1))*viewport[1],disi,disj);
|
||||
// gridMap[i][j] = Point2<scalar> (disi/viewport[0],disj/viewport[1]);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// inline Camera()
|
||||
// {
|
||||
// k[0]=k[1]=k[2]=k[3]=0.0;
|
||||
// valid = false;
|
||||
// ortho = false;
|
||||
// ResizeGridMap(100,100);// da spostare altrove
|
||||
// }
|
||||
//
|
||||
// inline bool IsValid()
|
||||
// {
|
||||
// return valid;
|
||||
// }
|
||||
//
|
||||
// inline bool IsOrtho() const
|
||||
// {
|
||||
// return ortho;
|
||||
// }
|
||||
//
|
||||
// inline void SetInvalid()
|
||||
// {
|
||||
// valid = false;
|
||||
// }
|
||||
//
|
||||
// inline void SetOrtho(bool isOrtho=true)
|
||||
// {
|
||||
// ortho = isOrtho;
|
||||
// }
|
||||
//
|
||||
// // Genera una camera standard
|
||||
// void Standard()
|
||||
// {
|
||||
// valid = true;
|
||||
// ortho = false;
|
||||
// view_p = vectorial(0,0,0);
|
||||
// x_axis = vectorial(1,0,0);
|
||||
// y_axis = vectorial(0,1,0);
|
||||
// z_axis = vectorial(0,0,1);
|
||||
// f = 25.75;
|
||||
// s = Point2<S>(0.0074,0.0074);
|
||||
// c = Point2<S>(320,240);
|
||||
// viewport[0] = 640;
|
||||
// viewport[1] = 480;
|
||||
// k[0] = 0;
|
||||
// k[1] = 0;
|
||||
// k[2] = 0;
|
||||
// k[3] = 0;
|
||||
// }
|
||||
//
|
||||
// // Trasla la camera (world coordinate)
|
||||
// inline void Translate( const vectorial & t )
|
||||
// {
|
||||
// view_p += t;
|
||||
// }
|
||||
//
|
||||
// // Trasla la camera (camera coordinate)
|
||||
// inline void Move( const vectorial & t )
|
||||
// {
|
||||
// view_p+= x_axis * t[0]+y_axis * t[1] + z_axis * t[2];
|
||||
// }
|
||||
//
|
||||
// // scala la camera
|
||||
// inline void Scale(const scalar & sc){
|
||||
// view_p *=sc;
|
||||
// s[0]*=sc;
|
||||
// s[1]*=sc;
|
||||
// f*=sc;
|
||||
// //printf("sc\n");
|
||||
// }
|
||||
//
|
||||
//
|
||||
//
|
||||
// // NOTA funziona solo se l'ultima colonna di m e' 0,0,0,1
|
||||
// void Apply( const Matrix44<S> & m )
|
||||
// {
|
||||
// // Passo 1: calcolo pseudo inversa di m
|
||||
// S s11,s12,s13;
|
||||
// S s21,s22,s23;
|
||||
// S s31,s32,s33;
|
||||
// S s41,s42,s43;
|
||||
//
|
||||
// {
|
||||
// S t4 = m[0][0]*m[1][1];
|
||||
// S t6 = m[0][0]*m[2][1];
|
||||
// S t8 = m[1][0]*m[0][1];
|
||||
// S t10 = m[1][0]*m[2][1];
|
||||
// S t12 = m[2][0]*m[0][1];
|
||||
// S t14 = m[2][0]*m[1][1];
|
||||
// S t17 = 1/(t4*m[2][2]-t6*m[1][2]-t8*m[2][2]+t10*m[0][2]+t12*m[1][2]-t14*m[0][2]);
|
||||
// S t27 = m[1][0]*m[2][2];
|
||||
// S t28 = m[2][0]*m[1][2];
|
||||
// S t31 = m[0][0]*m[2][2];
|
||||
// S t32 = m[2][0]*m[0][2];
|
||||
// S t35 = m[0][0]*m[1][2];
|
||||
// S t36 = m[1][0]*m[0][2];
|
||||
// S t49 = m[3][0]*m[1][1];
|
||||
// S t51 = m[3][0]*m[2][1];
|
||||
// S t59 = m[3][0]*m[0][1];
|
||||
// s11 = -(-m[1][1]*m[2][2]+m[2][1]*m[1][2])*t17;
|
||||
// s12 = -( m[0][1]*m[2][2]-m[2][1]*m[0][2])*t17;
|
||||
// s13 = ( m[0][1]*m[1][2]-m[1][1]*m[0][2])*t17;
|
||||
// s21 = (-t27+t28)*t17;
|
||||
// s22 = -(-t31+t32)*t17;
|
||||
// s23 = -( t35-t36)*t17;
|
||||
// s31 = -(-t10+t14)*t17;
|
||||
// s32 = (-t6 +t12)*t17;
|
||||
// s33 = ( t4 -t8 )*t17;
|
||||
// s41 = -(t10*m[3][2]-t27*m[3][1]-t14*m[3][2]+t28*m[3][1]+t49*m[2][2]-t51*m[1][2])*t17;
|
||||
// s42 = -(-t6*m[3][2]+t31*m[3][1]+t12*m[3][2]-t32*m[3][1]-t59*m[2][2]+t51*m[0][2])*t17;
|
||||
// s43 = (-t4*m[3][2]+t35*m[3][1]+t8 *m[3][2]-t36*m[3][1]-t59*m[1][2]+t49*m[0][2])*t17;
|
||||
// 1.0;
|
||||
// }
|
||||
//
|
||||
// //Matrix44<S> t2 = tt*m;
|
||||
// //print(t2);
|
||||
// // Fase 2: Calcolo nuovo punto di vista
|
||||
// {
|
||||
// S t1 = view_p[2]*s31;
|
||||
// S t3 = view_p[2]*s21;
|
||||
// S t5 = s43*s21;
|
||||
// S t7 = s43*s31;
|
||||
// S t9 = view_p[1]*s31;
|
||||
// S t11 = view_p[1]*s21;
|
||||
// S t13 = s42*s31;
|
||||
// S t15 = s42*s21;
|
||||
// S t17 = view_p[0]*s32;
|
||||
// S t19 = view_p[0]*s22;
|
||||
// S t21 = s41*s32;
|
||||
// S t23 = s41*s22;
|
||||
// S t25 = -t1*s22+t3*s32-t5*s32+t7*s22+t9*s23-t11*s33-t13*s23+t15*s33-t17*s23+t19*s33+t21*s23-t23*s33;
|
||||
// S t39 = 1/(s11*s22*s33-s11*s32*s23-s21*s12*s33+s21*s32*s13+s31*s12*s23-s31*s22*s13);
|
||||
// S t41 = view_p[0]*s12;
|
||||
// S t45 = s41*s12;
|
||||
// S t47 = view_p[2]*s11;
|
||||
// S t50 = s43*s11;
|
||||
// S t53 = view_p[1]*s11;
|
||||
// S t56 = s42*s11;
|
||||
// S t59 = t41*s33-t17*s13+t21*s13-t45*s33+t47*s32-t1*s12-t50*s32+t7*s12-t53*s33+t9*s13+t56*s33-t13*s13;
|
||||
// S t73 = t15*s13-t56*s23+t19*s13-t41*s23-t23*s13+t45*s23-t11*s13+t53*s23+t3*s12-t47*s22-t5*s12+t50*s22;
|
||||
//
|
||||
// view_p[0] = t25*t39;
|
||||
// view_p[1] = -t59*t39;
|
||||
// view_p[2] = -t73*t39;
|
||||
// }
|
||||
//
|
||||
// // Fase 3: Calcol nuovo sistema di riferimento
|
||||
// {
|
||||
// S A00 = s11*x_axis[0]+s12*x_axis[1]+s13*x_axis[2];
|
||||
// S A01 = s11*y_axis[0]+s12*y_axis[1]+s13*y_axis[2];
|
||||
// S A02 = s11*z_axis[0]+s12*z_axis[1]+s13*z_axis[2];
|
||||
// // S A03 = 0.0;
|
||||
// S A10 = s21*x_axis[0]+s22*x_axis[1]+s23*x_axis[2];
|
||||
// S A11 = s21*y_axis[0]+s22*y_axis[1]+s23*y_axis[2];
|
||||
// S A12 = s21*z_axis[0]+s22*z_axis[1]+s23*z_axis[2];
|
||||
// // S A13 = 0.0;
|
||||
// S A20 = s31*x_axis[0]+s32*x_axis[1]+s33*x_axis[2];
|
||||
// S A21 = s31*y_axis[0]+s32*y_axis[1]+s33*y_axis[2];
|
||||
// S A22 = s31*z_axis[0]+s32*z_axis[1]+s33*z_axis[2];
|
||||
//
|
||||
// x_axis[0] = A00; x_axis[1] = A10; x_axis[2] = A20;
|
||||
// y_axis[0] = A01; y_axis[1] = A11; y_axis[2] = A21;
|
||||
// z_axis[0] = A02; z_axis[1] = A12; z_axis[2] = A22;
|
||||
// // S A1[2][3] = 0.0;
|
||||
// // S A1[3][0] = 0.0;
|
||||
// // S A1[3][1] = 0.0;
|
||||
// // S A1[3][2] = 0.0;
|
||||
// // S A1[3][3] = 1.0;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// /*
|
||||
// // Applica una trasformazione
|
||||
// void Apply( const Matrix44<S> & m )
|
||||
// {
|
||||
// Point3<S> tx = view_p+x_axis;
|
||||
// Point3<S> ty = view_p+y_axis;
|
||||
// Point3<S> tz = view_p+z_axis;
|
||||
//
|
||||
// view_p = m.Apply(view_p);
|
||||
//
|
||||
// x_axis = m.Apply(tx) - view_p;
|
||||
// y_axis = m.Apply(ty) - view_p;
|
||||
// z_axis = m.Apply(tz) - view_p;
|
||||
// }
|
||||
//
|
||||
// // Applica una trasformazione ma bene!
|
||||
// void Stable_Apply( const Matrix44<S> & m )
|
||||
// {
|
||||
// Point3<S> tx = view_p+x_axis;
|
||||
// Point3<S> ty = view_p+y_axis;
|
||||
// Point3<S> tz = view_p+z_axis;
|
||||
//
|
||||
// view_p = m.Stable_Apply(view_p);
|
||||
//
|
||||
// x_axis = m.Stable_Apply(tx) - view_p;
|
||||
// y_axis = m.Stable_Apply(ty) - view_p;
|
||||
// z_axis = m.Stable_Apply(tz) - view_p;
|
||||
// }
|
||||
//
|
||||
// */
|
||||
//
|
||||
// void Project( const vectorial & p, Point2<S> & q ) const
|
||||
// {
|
||||
// vectorial dp = p - view_p;
|
||||
// S dx = dp*x_axis;
|
||||
// S dy = dp*y_axis;
|
||||
// S dz = dp*z_axis;
|
||||
//
|
||||
// S tx = dx;
|
||||
// S ty = -dy;
|
||||
// S qx,qy;
|
||||
//
|
||||
// // nota: per le camere ortogonali viewportM vale 1
|
||||
// if(!IsOrtho())
|
||||
// {
|
||||
// tx *= f/dz;
|
||||
// ty *= f/dz;
|
||||
//
|
||||
// undistorted_to_distorted_sensor_coord(tx,ty,qx,qy);
|
||||
//
|
||||
// q[0] = qx/s[0]+c[0];
|
||||
// q[1] = qy/s[1]+c[1];
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// q[0] = tx/(s[0]*viewportM)+c[0];
|
||||
// q[1] = ty/(s[1]*viewportM)+c[1];
|
||||
// }
|
||||
// }
|
||||
//
|
||||
//#if 1
|
||||
// void Show( FILE * fp )
|
||||
// {
|
||||
// if(valid)
|
||||
// fprintf(fp,
|
||||
// "posiz.: %g %g %g\n"
|
||||
// "x axis: %g %g %g\n"
|
||||
// "y axis: %g %g %g\n"
|
||||
// "z axis: %g %g %g\n"
|
||||
// "focal : %g scale: %g %g center: %g %g\n"
|
||||
// "viewp.: %d %d distorsion: %g %g %g %g\n"
|
||||
// ,view_p[0],view_p[1],view_p[2]
|
||||
// ,x_axis[0],x_axis[1],x_axis[2]
|
||||
// ,y_axis[0],y_axis[1],y_axis[2]
|
||||
// ,z_axis[0],z_axis[1],z_axis[2]
|
||||
// ,f,s[0],s[1],c[0],c[1]
|
||||
// ,viewport[0],viewport[1],k[0],k[1],k[2],k[3]
|
||||
// );
|
||||
// else
|
||||
// fprintf(fp,"Invalid\n");
|
||||
// }
|
||||
//#endif
|
||||
//
|
||||
// // Legge una camera in descrizione tsai binario
|
||||
// static void load_tsai_bin (FILE *fp, tsai_camera_parameters *cp, tsai_calibration_constants *cc)
|
||||
// {
|
||||
// double sa,
|
||||
// ca,
|
||||
// sb,
|
||||
// cb,
|
||||
// sg,
|
||||
// cg;
|
||||
//
|
||||
// fread(&(cp->Ncx),sizeof(double),1,fp);
|
||||
// fread(&(cp->Nfx),sizeof(double),1,fp);
|
||||
// fread(&(cp->dx),sizeof(double),1,fp);
|
||||
// fread(&(cp->dy),sizeof(double),1,fp);
|
||||
// fread(&(cp->dpx),sizeof(double),1,fp);
|
||||
// fread(&(cp->dpy),sizeof(double),1,fp);
|
||||
// fread(&(cp->Cx),sizeof(double),1,fp);
|
||||
// fread(&(cp->Cy),sizeof(double),1,fp);
|
||||
// fread(&(cp->sx),sizeof(double),1,fp);
|
||||
//
|
||||
// fread(&(cc->f),sizeof(double),1,fp);
|
||||
// fread(&(cc->kappa1),sizeof(double),1,fp);
|
||||
// fread(&(cc->Tx),sizeof(double),1,fp);
|
||||
// fread(&(cc->Ty),sizeof(double),1,fp);
|
||||
// fread(&(cc->Tz),sizeof(double),1,fp);
|
||||
// fread(&(cc->Rx),sizeof(double),1,fp);
|
||||
// fread(&(cc->Ry),sizeof(double),1,fp);
|
||||
// fread(&(cc->Rz),sizeof(double),1,fp);
|
||||
//
|
||||
//
|
||||
// SINCOSd (cc->Rx, sa, ca);
|
||||
// SINCOSd (cc->Ry, sb, cb);
|
||||
// SINCOSd (cc->Rz, sg, cg);
|
||||
//
|
||||
// cc->r1 = cb * cg;
|
||||
// cc->r2 = cg * sa * sb - ca * sg;
|
||||
// cc->r3 = sa * sg + ca * cg * sb;
|
||||
// cc->r4 = cb * sg;
|
||||
// cc->r5 = sa * sb * sg + ca * cg;
|
||||
// cc->r6 = ca * sb * sg - cg * sa;
|
||||
// cc->r7 = -sb;
|
||||
// cc->r8 = cb * sa;
|
||||
// cc->r9 = ca * cb;
|
||||
//
|
||||
// fread(&(cc->p1),sizeof(double),1,fp);
|
||||
// fread(&(cc->p2),sizeof(double),1,fp);
|
||||
// }
|
||||
//
|
||||
// void load_tsai (FILE *fp, tsai_camera_parameters *cp, tsai_calibration_constants *cc)
|
||||
// {
|
||||
// double sa,
|
||||
// ca,
|
||||
// sb,
|
||||
// cb,
|
||||
// sg,
|
||||
// cg;
|
||||
//
|
||||
// fscanf (fp, "%lf", &(cp->Ncx));
|
||||
// fscanf (fp, "%lf", &(cp->Nfx));
|
||||
// fscanf (fp, "%lf", &(cp->dx));
|
||||
// fscanf (fp, "%lf", &(cp->dy));
|
||||
// fscanf (fp, "%lf", &(cp->dpx));
|
||||
// fscanf (fp, "%lf", &(cp->dpy));
|
||||
// fscanf (fp, "%lf", &(cp->Cx));
|
||||
// fscanf (fp, "%lf", &(cp->Cy));
|
||||
// fscanf (fp, "%lf", &(cp->sx));
|
||||
//
|
||||
// fscanf (fp, "%lf", &(cc->f));
|
||||
// fscanf (fp, "%lf", &(cc->kappa1));
|
||||
// fscanf (fp, "%lf", &(cc->Tx));
|
||||
// fscanf (fp, "%lf", &(cc->Ty));
|
||||
// fscanf (fp, "%lf", &(cc->Tz));
|
||||
// fscanf (fp, "%lf", &(cc->Rx));
|
||||
// fscanf (fp, "%lf", &(cc->Ry));
|
||||
// fscanf (fp, "%lf", &(cc->Rz));
|
||||
//
|
||||
// SINCOSd (cc->Rx, sa, ca);
|
||||
// SINCOSd (cc->Ry, sb, cb);
|
||||
// SINCOSd (cc->Rz, sg, cg);
|
||||
//
|
||||
// cc->r1 = cb * cg;
|
||||
// cc->r2 = cg * sa * sb - ca * sg;
|
||||
// cc->r3 = sa * sg + ca * cg * sb;
|
||||
// cc->r4 = cb * sg;
|
||||
// cc->r5 = sa * sb * sg + ca * cg;
|
||||
// cc->r6 = ca * sb * sg - cg * sa;
|
||||
// cc->r7 = -sb;
|
||||
// cc->r8 = cb * sa;
|
||||
// cc->r9 = ca * cb;
|
||||
//
|
||||
// fscanf (fp, "%lf", &(cc->p1));
|
||||
// fscanf (fp, "%lf", &(cc->p2));
|
||||
// }
|
||||
//
|
||||
// // Importa una camera dal formato tsai
|
||||
// void import( const tsai_camera_parameters & cp,
|
||||
// const tsai_calibration_constants & cc,
|
||||
// const int image_viewport[2]
|
||||
// )
|
||||
// {
|
||||
// assert(!IsOrtho());
|
||||
// valid = true;
|
||||
// x_axis[0] = cc.r1; x_axis[1] = cc.r2; x_axis[2] = cc.r3;
|
||||
// y_axis[0] = cc.r4; y_axis[1] = cc.r5; y_axis[2] = cc.r6;
|
||||
// z_axis[0] = cc.r7; z_axis[1] = cc.r8; z_axis[2] = cc.r9;
|
||||
//
|
||||
// view_p[0] = - (cc.Tx * x_axis[0] + cc.Ty * y_axis[0] + cc.Tz * z_axis[0]);
|
||||
// view_p[1] = - (cc.Tx * x_axis[1] + cc.Ty * y_axis[1] + cc.Tz * z_axis[1]);
|
||||
// view_p[2] = - (cc.Tx * x_axis[2] + cc.Ty * y_axis[2] + cc.Tz * z_axis[2]);
|
||||
//
|
||||
// s[0] = cp.dpx/cp.sx;
|
||||
// s[1] = cp.dpy;
|
||||
// c[0] = cp.Cx;
|
||||
// c[1] = cp.Cy;
|
||||
//
|
||||
// f = cc.f;
|
||||
// viewport[0] = image_viewport[0];
|
||||
// viewport[1] = image_viewport[1];
|
||||
//
|
||||
// k[0] = cc.kappa1;
|
||||
// k[1] = cc.kappa1;
|
||||
// k[2] = 0;
|
||||
// k[2] = 0;
|
||||
// }
|
||||
//
|
||||
// // Esporta una camera in formato tsai
|
||||
// void export( tsai_camera_parameters & cp,
|
||||
// tsai_calibration_constants & cc,
|
||||
// int image_viewport[2]
|
||||
// )
|
||||
// {
|
||||
// assert(!IsOrtho());
|
||||
// cc.r1 = x_axis[0]; cc.r2 = x_axis[1]; cc.r3= x_axis[2] ;
|
||||
// cc.r4 = y_axis[0]; cc.r5 = y_axis[1]; cc.r6= y_axis[2] ;
|
||||
// cc.r7 = z_axis[0]; cc.r8 = z_axis[1]; cc.r9= z_axis[2] ;
|
||||
//
|
||||
// cc.Tx = - (view_p[0] * x_axis[0] + view_p[1] * x_axis[1] + view_p[2] * x_axis[2]);
|
||||
// cc.Ty = - (view_p[0] * y_axis[0] + view_p[1] * y_axis[1] + view_p[2] * y_axis[2]);
|
||||
// cc.Tz = - (view_p[0] * z_axis[0] + view_p[1] * z_axis[1] + view_p[2] * z_axis[2]);
|
||||
//
|
||||
// cp.dpx = s[0];
|
||||
// cp.dpy = s[1];
|
||||
//
|
||||
// cp.Cx= c[0] ;
|
||||
// cp.Cy= c[1] ;
|
||||
// cp.sx= 1;
|
||||
//
|
||||
// cc.f= f ;
|
||||
//
|
||||
// image_viewport[0] = viewport[0];
|
||||
// image_viewport[1] = viewport[1];
|
||||
//
|
||||
// cc.kappa1= k[0] ;
|
||||
// cc.kappa1= k[1] ;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// void Save(FILE * out)
|
||||
// {
|
||||
// fprintf(out,"VIEW_POINT %f %f %f\n", view_p[0],view_p[1],view_p[2]);
|
||||
// fprintf(out,"X_AXIS %f %f %f\n", x_axis[0],x_axis[1],x_axis[2]);
|
||||
// fprintf(out,"Y_AXIS %f %f %f\n", y_axis[0],y_axis[1],y_axis[2]);
|
||||
// fprintf(out,"Z_AXIS %f %f %f\n", z_axis[0],z_axis[1],z_axis[2]);
|
||||
// fprintf(out,"FOCUS_LENGHT %f \n", f);
|
||||
// fprintf(out,"SCALE %f %f \n", s[0], s[1]);
|
||||
// fprintf(out,"VIEWPORT %d %d \n", viewport[0], viewport[1]);
|
||||
// fprintf(out,"VIEWPORTM %f\n", viewportM);
|
||||
// fprintf(out,"RADIAL_DISTORSION %.10g %.10g \n", k[0],k[1]);
|
||||
// fprintf(out,"CENTER %f %f \n", c[0], c[1]);
|
||||
// fprintf(out,"IS_VALID %d\n", IsValid());
|
||||
// fprintf(out,"END_CAMERA\n");
|
||||
// }
|
||||
//
|
||||
// void Load(FILE * in)
|
||||
// {
|
||||
// char row[255];
|
||||
// Standard();
|
||||
// while(!feof(in))
|
||||
// {
|
||||
// fscanf(in,"%s",row);
|
||||
// if(strcmp(row,"VIEW_POINT")==0)
|
||||
// fscanf(in,"%lg %lg %lg",&view_p[0],&view_p[1],&view_p[2]);
|
||||
// else
|
||||
// if(strcmp(row,"X_AXIS")==0)
|
||||
// fscanf(in,"%lg %lg %lg",& x_axis[0],&x_axis[1],&x_axis[2]);
|
||||
// else
|
||||
// if(strcmp(row,"Y_AXIS")==0)
|
||||
// fscanf(in,"%lg %lg %lg",& y_axis[0],&y_axis[1],&y_axis[2]);
|
||||
// else
|
||||
// if(strcmp(row,"Z_AXIS")==0)
|
||||
// fscanf(in,"%lg %lg %lg",& z_axis[0],&z_axis[1],&z_axis[2]);
|
||||
// else
|
||||
// if(strcmp(row,"FOCUS_LENGHT")==0)
|
||||
// fscanf(in,"%lg",&f);
|
||||
// else
|
||||
// if(strcmp(row,"SCALE")==0)
|
||||
// fscanf(in,"%lg %lg",&s[0],&s[1]);
|
||||
// else
|
||||
// if(strcmp(row,"VIEWPORT")==0)
|
||||
// fscanf(in,"%d %d", &viewport[0],&viewport[1]);
|
||||
// else
|
||||
// if(strcmp(row,"VIEWPORTM")==0)
|
||||
// fscanf(in,"%f", &viewportM);
|
||||
// else
|
||||
// if(strcmp(row,"CENTER")==0)
|
||||
// fscanf(in,"%lg %lg", &c[0],&c[1]);
|
||||
// else
|
||||
// if(strcmp(row,"RADIAL_DISTORSION")==0)
|
||||
// fscanf(in,"%lg %lg", &k[0],&k[1]);
|
||||
// else
|
||||
// if(strcmp(row,"IS_VALID")==0)
|
||||
// fscanf(in,"%d",&valid);
|
||||
// if(strcmp(row,"END_CAMERA")==0)
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
//#ifdef __GL_H__
|
||||
//
|
||||
//// Prende in ingresso il bounding box dell'oggetto da inquadrare e setta projection e modelmatrix
|
||||
//// in modo da matchare il piu' possibile quelle della camera. Ovviamente (?) si ignora le distorsioni radiali.
|
||||
//// Nota che bb viene utilizzato solo per settare i near e far plane in maniera sensata.
|
||||
//void SetGL(const Box3<scalar> &bb,scalar subx0=0, scalar subx1=1,scalar suby0=0,scalar suby1=1)
|
||||
//{
|
||||
// scalar _,__;
|
||||
// SetGL(_,__,bb,subx0, subx1, suby0, suby1);
|
||||
//
|
||||
//}
|
||||
//
|
||||
//void SetGL(scalar &znear, scalar &zfar,const Box3<scalar> &bb,scalar subx0=0,
|
||||
// scalar subx1=1,scalar suby0=0,scalar suby1=1)
|
||||
//{
|
||||
// glMatrixMode(GL_PROJECTION);
|
||||
// glLoadIdentity();
|
||||
// scalar left,right;
|
||||
// scalar bottom, top;
|
||||
// scalar w,h;
|
||||
//
|
||||
// // La lunghezza focale <f> e' la distanza del piano immagine dal centro di proiezione.
|
||||
// // il che mappa direttamente nella chiamata glFrustum che prende in ingresso
|
||||
// // le coordinate del piano immagine posto a znear.
|
||||
//
|
||||
// float imleft =-c[0]*s[0];
|
||||
// float imright =(viewport[0]-c[0])*s[0];
|
||||
// float imbottom =-c[1]*s[1];
|
||||
// float imtop =(viewport[1]-c[1])*s[1];
|
||||
// znear = Distance(view_p, bb.Center())-bb.Diag();
|
||||
// zfar = Distance(view_p, bb.Center())+bb.Diag();
|
||||
//
|
||||
// w=imright-imleft;
|
||||
// h=imtop-imbottom;
|
||||
//
|
||||
// // Quindi il frustum giusto sarebbe questo,
|
||||
// // glFrustum(imleft, imright, imbottom, imtop, f, zfar);
|
||||
// // ma per amor di opengl conviene spostare il near plane fino ad essere vicino all'oggetto da inquadrare.
|
||||
// // Cambiare f significa amplificare in maniera proporzionale anche i left right ecc.
|
||||
//
|
||||
// // 8/5/02 Nota che il near plane va spostato verso l'oggetto solo se quello calcolato sopra e' maggiore di 'f'
|
||||
// // nota che potrebbe anche succedere che znear <0 (viewpoint vicino ad un oggetto con il bb allungato);
|
||||
// if(znear<f) znear=f;
|
||||
//
|
||||
// float nof = znear/f;
|
||||
// if(subx0==0 && subx1 == 1 && suby0==0 && suby1 == 1)
|
||||
// {
|
||||
// if(!IsOrtho())
|
||||
// glFrustum(imleft*nof, imright*nof, imbottom*nof, imtop*nof, znear, zfar);
|
||||
// else
|
||||
// glOrtho(imleft*viewportM, imright*viewportM, imbottom*viewportM, imtop*viewportM, znear, zfar);
|
||||
// }
|
||||
// else {// nel caso si voglia fare subboxing
|
||||
// left = imleft+w*subx0;
|
||||
// right = imleft+w*subx1;
|
||||
// bottom = imbottom +h*suby0;
|
||||
// top = imbottom +h*suby1;
|
||||
// {
|
||||
// if(!IsOrtho())
|
||||
// glFrustum(left*nof, right*nof, bottom*nof, top*nof, znear, zfar);
|
||||
// else
|
||||
// glOrtho(left*viewportM, right*viewportM, bottom*viewportM, top*viewportM, znear, zfar);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// glMatrixMode(GL_MODELVIEW);
|
||||
// glLoadIdentity();
|
||||
// scalar l=max(scalar(1.0),view_p.Norm());
|
||||
// gluLookAt(view_p[0], view_p[1], view_p[2],
|
||||
// view_p[0] + (z_axis[0]*l),
|
||||
// view_p[1] + (z_axis[1]*l),
|
||||
// view_p[2] + (z_axis[2]*l),
|
||||
// y_axis[0],y_axis[1],y_axis[2]);
|
||||
//}
|
||||
//// Sposta la camera a caso di in maniera che l'angolo di variazione rispetto al punt c passato sia inferiore a RadAngle
|
||||
////
|
||||
//void Jitter(Point3<scalar> c, scalar RadAngle)
|
||||
//{
|
||||
// Point3<scalar> rnd(1.0 - 2.0*scalar(rand())/RAND_MAX,
|
||||
// 1.0 - 2.0*scalar(rand())/RAND_MAX,
|
||||
// 1.0 - 2.0*scalar(rand())/RAND_MAX);
|
||||
// rnd.Normalize();
|
||||
// Matrix44<scalar> m,t0,t1,tr;
|
||||
// Point3<scalar> axis = rnd ^ (view_p-c).Normalize();
|
||||
// scalar RadRandAngle=RadAngle*(1.0 - 2.0*scalar(rand())/RAND_MAX);
|
||||
// t0.Translate(c);
|
||||
// t1.Translate(-c);
|
||||
// m.Rotate(ToDeg(RadRandAngle),axis);
|
||||
// tr=t1*m*t0;
|
||||
// Apply(tr);
|
||||
//}
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//void glTexGen(int offx =0, // angolo basso sinistra della
|
||||
// int offy=0, // subtexture per la quale si vogliono settare le coordinate
|
||||
// int sx=1, // Dimensioni in Texel
|
||||
// int sy=1,
|
||||
// int Tx=1, // Dimensioni della texture
|
||||
// int Ty=1)
|
||||
//{
|
||||
// // prendi la rototraslazione che
|
||||
// // trasforma la coordinata nel
|
||||
// // sistema di coordinate della camera
|
||||
// Matrix44d M;
|
||||
// M[0][0] = x_axis[0];
|
||||
// M[0][1] = x_axis[1];
|
||||
// M[0][2] = x_axis[2];
|
||||
// M[0][3] = -view_p* x_axis ;
|
||||
//
|
||||
// M[1][0] = y_axis[0];
|
||||
// M[1][1] = y_axis[1];
|
||||
// M[1][2] = y_axis[2];
|
||||
// M[1][3] = -view_p* y_axis;
|
||||
//
|
||||
// M[2][0] = z_axis[0];
|
||||
// M[2][1] = z_axis[1];
|
||||
// M[2][2] = z_axis[2];
|
||||
// M[2][3] = -view_p* z_axis;
|
||||
//
|
||||
// M[3][0] = 0.0;
|
||||
// M[3][1] = 0.0;
|
||||
// M[3][2] = 0.0;
|
||||
// M[3][3] = 1.0;
|
||||
//
|
||||
// // prendi la matrice di proiezione
|
||||
// Matrix44d P;
|
||||
// P.Zero();
|
||||
//
|
||||
// if(!IsOrtho())// prospettica
|
||||
// {
|
||||
//
|
||||
// P[0][0] = sx/(s[0]*viewport[0]*Tx);
|
||||
// P[0][2] = (1/f)*(offx+0.5*sx)/Tx;
|
||||
//
|
||||
// P[1][1] = sy/(s[1]* viewport[1]*Ty);
|
||||
// P[1][2] = (1/f)*(offy+0.5*sy)/Ty;
|
||||
//
|
||||
// P[2][2] = 1;
|
||||
// P[3][2] = 1/f;
|
||||
// }
|
||||
// else // ortogonale
|
||||
// {
|
||||
// P[0][0] = sx/(s[0]*viewport[0]*viewportM*Tx);
|
||||
// P[0][3] = (offx+0.5*sx)/Tx; // l'effetto e' una traslazione di +1/2
|
||||
//
|
||||
// P[1][1] = sy/(s[1]* viewport[1]*viewportM*Ty);
|
||||
// P[1][3] = (offy+0.5*sy)/Ty; // l'effetto e' una traslazione di +1/2
|
||||
//
|
||||
// P[2][2] = 1;
|
||||
// P[3][3] = 1;
|
||||
// }
|
||||
// // componi
|
||||
// Matrix44d PM = P*M;
|
||||
//
|
||||
// glTexGend(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
// glTexGend(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
// glTexGend(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
//
|
||||
// glTexGendv(GL_S,GL_OBJECT_PLANE,&PM[0][0]);
|
||||
// glTexGendv(GL_T,GL_OBJECT_PLANE,&PM[1][0]);
|
||||
// glTexGendv(GL_Q,GL_OBJECT_PLANE,&PM[3][0]);
|
||||
//
|
||||
// glEnable(GL_TEXTURE_GEN_S);
|
||||
// glEnable(GL_TEXTURE_GEN_T);
|
||||
// glDisable(GL_TEXTURE_GEN_R);
|
||||
// glEnable(GL_TEXTURE_GEN_Q);
|
||||
//}
|
||||
//
|
||||
//// versione per le texture rettangolare NV_TEXTURE_RECTANGLE
|
||||
//// la differenza da glTexGen e' che il mapping e' in [0..sx]X[0..sy]
|
||||
//void glTexGen_NV(int sx, // Texture Size
|
||||
// int sy)
|
||||
//{
|
||||
// // prendi la rototraslazione che
|
||||
// // trasforma la coordinata nel
|
||||
// // sistema di coordinate della camera
|
||||
// Matrix44d M;
|
||||
// M[0][0] = x_axis[0];
|
||||
// M[0][1] = x_axis[1];
|
||||
// M[0][2] = x_axis[2];
|
||||
// M[0][3] = -view_p* x_axis ;
|
||||
//
|
||||
// M[1][0] = y_axis[0];
|
||||
// M[1][1] = y_axis[1];
|
||||
// M[1][2] = y_axis[2];
|
||||
// M[1][3] = -view_p* y_axis;
|
||||
//
|
||||
// M[2][0] = z_axis[0];
|
||||
// M[2][1] = z_axis[1];
|
||||
// M[2][2] = z_axis[2];
|
||||
// M[2][3] = -view_p* z_axis;
|
||||
//
|
||||
// M[3][0] = 0.0;
|
||||
// M[3][1] = 0.0;
|
||||
// M[3][2] = 0.0;
|
||||
// M[3][3] = 1.0;
|
||||
//
|
||||
// // prendi la matrice di proiezione
|
||||
// Matrix44d P;
|
||||
// P.Zero();
|
||||
//
|
||||
// if(!IsOrtho())// prospettica
|
||||
// {
|
||||
//
|
||||
// P[0][0] = sx/(s[0]*viewport[0]);
|
||||
// P[0][2] = sx*(1/f)*( 0.5);
|
||||
//
|
||||
// P[1][1] = sy/(s[1]* viewport[1] );
|
||||
// P[1][2] = sy*(1/f)*( 0.5);
|
||||
//
|
||||
// P[2][2] = 1;
|
||||
// P[3][2] = 1/f;
|
||||
// }
|
||||
// else // ortogonale
|
||||
// {
|
||||
// P[0][0] = sx/(s[0]*viewport[0]*viewportM);
|
||||
// P[0][3] = sx* 0.5 ; // l'effetto e' una traslazione di +1/2
|
||||
//
|
||||
// P[1][1] = sy/(s[1]* viewport[1]*viewportM);
|
||||
// P[1][3] = sy* 0.5 ; // l'effetto e' una traslazione di +1/2
|
||||
//
|
||||
// P[2][2] = 1;
|
||||
// P[3][3] = 1;
|
||||
// }
|
||||
// // componi
|
||||
// Matrix44d PM = P*M;
|
||||
//
|
||||
// glTexGend(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
// glTexGend(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
// glTexGend(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
//
|
||||
// glTexGendv(GL_S,GL_OBJECT_PLANE,&PM[0][0]);
|
||||
// glTexGendv(GL_T,GL_OBJECT_PLANE,&PM[1][0]);
|
||||
// glTexGendv(GL_Q,GL_OBJECT_PLANE,&PM[3][0]);
|
||||
//
|
||||
// glEnable(GL_TEXTURE_GEN_S);
|
||||
// glEnable(GL_TEXTURE_GEN_T);
|
||||
// glDisable(GL_TEXTURE_GEN_R);
|
||||
// glEnable(GL_TEXTURE_GEN_Q);
|
||||
//// glDisable(GL_TEXTURE_GEN_Q);
|
||||
//
|
||||
//}
|
||||
//#endif // __GL_H__
|
||||
//
|
||||
//};
|
||||
//} // End namespace vcg
|
||||
Loading…
Reference in New Issue