Main Page | Class Hierarchy | Class List | File List | Class Members

TMatrix3D.h

00001 // TMatrix3D.h: Schnittstelle für die Klasse TMatrix3D.
00002 //
00004 
00005 #if !defined(AFX_TMATRIX3D_H__A4C4DBBF_648D_4404_9191_25D98E20B62B__INCLUDED_)
00006 #define AFX_TMATRIX3D_H__A4C4DBBF_648D_4404_9191_25D98E20B62B__INCLUDED_
00007 
00008 #if _MSC_VER > 1000
00009 #pragma once
00010 #endif // _MSC_VER > 1000
00011 
00012 
00013 #include <fcntl.h>
00014 #include <io.h>
00015 #include <stdlib.h> 
00016 #include <windows.h>
00017 #include <gl/gl.h>
00018 #include <math.h>
00019 
00020 #include "TKoo3d.h"
00021 
00022 #define EINHEITSMATRIX(matr)    matr[0][0]=1;matr[1][0]=0;matr[2][0]=0;matr[3][0]=0;\
00023                                                                 matr[0][1]=0;matr[1][1]=1;matr[2][1]=0;matr[3][1]=0;\
00024                                                                 matr[0][2]=0;matr[1][2]=0;matr[2][2]=1;matr[3][2]=0;\
00025                                                                 matr[0][3]=0;matr[1][3]=0;matr[2][3]=0;matr[3][3]=1;
00026 
00027 #define NULLMATRIX(matr)        matr[0][0]=0;matr[1][0]=0;matr[2][0]=0;matr[3][0]=0;\
00028                                                                 matr[0][1]=0;matr[1][1]=0;matr[2][1]=0;matr[3][1]=0;\
00029                                                                 matr[0][2]=0;matr[1][2]=0;matr[2][2]=0;matr[3][2]=0;\
00030                                                                 matr[0][3]=0;matr[1][3]=0;matr[2][3]=0;matr[3][3]=0;
00031 
00032 template <class T> class TMatrix3D
00033 {
00034 
00035 
00036         public:
00037                 T v[4] [4];
00038 
00039         //      TMatrix3D();
00040         //      TMatrix3D(float  mat[][4]);
00041 
00042                 double determinante ()
00043                 {
00044                         double buff1=0;
00045                         double buff2=1;
00046                         int feldnum;
00047 
00048                         int i;
00049    
00050                         for (i=0;i<=2;i++)
00051                         {
00052                                 buff2=1;
00053                                 for (int j=0;j<=2;j++)
00054                                 {
00055                                 feldnum=j+i;
00056                                         if (feldnum>2) feldnum-=3;
00057                                                 buff2*=v[feldnum][j];
00058                                 }
00059                                 buff1+=buff2;
00060                         }
00061 
00062                         for (i=0;i<=2;i++)
00063                         {
00064                                 buff2=1;
00065                                 for (int j=2;j>=0;j--)
00066                                 {
00067                                 feldnum=(2-j)+i;
00068                                         if (feldnum>2) feldnum-=3;
00069                                                 buff2*=v[feldnum][j];
00070                                 }
00071                                 buff1-=buff2;
00072                         }
00073                         return (buff1);
00074                 }
00075 
00076                 TMatrix3D<T> operator* (TMatrix3D<T>& m)
00077                 {
00078                         TMatrix3D<T> matrixbuff;
00079                         float vbuff;
00080 
00081                         for (int x=0; x<=3; x++)
00082                                 for (int y=0; y<=3; y++)
00083                                 {
00084                                 vbuff=0;
00085                                 for (int i=0; i<=3; i++)
00086                                         vbuff=(float)(vbuff+v[x][i]*m.v[i][y]);
00087                                 matrixbuff.v[x][y]=vbuff;
00088                                 }
00089 
00090                         return matrixbuff;
00091                 }
00092 
00093                 //inline void GLMatrixMult();
00094                 //inline void GLMatrixSet();
00095                 //inline void GLMatrixCapture();
00096                 //inline void GLMatrixCapture(GLenum matr);
00097                 //TMatrix3D fastInvert();
00098                 //inline TMatrix3D interpolate(TMatrix3D& m,float f);
00099                 static TMatrix3D<T> interpolate(TMatrix3D<T>* m[],float f[], int count)         
00100                 {
00101                         /*for (int x=0;x<=count;x++)
00102                                 if (f[x]!=0.0)
00103                                         f[x]=1.0;*/
00104                         
00105                         TMatrix3D<T> mBuff(NULL);
00106                         float max=0.0;
00107                         for (int l=0;l<=count;l++)
00108                                 max+=f[l];
00109                         int i,j;
00110                         for (int k=0;k<=count;k++)
00111                         {
00112                                 if (f[k]!=0.0f)
00113                                 {
00114                                         for (i=0;i<4;i++)
00115                                         {
00116                                                 for (j=0;j<4;j++)
00117                                                 {
00118                                                         
00119                                                         mBuff.v[i][j]+=f[k]*m[k]->v[i][j];
00120                                                 }
00121                                                 
00122                                                 
00123                                         }
00124                                 }
00125                                 
00126                         }
00127                         for (i=0;i<4;i++)
00128                         {
00129                                 for (j=0;j<4;j++)
00130                                 {
00131                                         
00132                                         mBuff.v[i][j]/=max;
00133                                 }
00134                                                 
00135                                                 
00136                         }
00137                         
00138                         return mBuff;
00139 /*
00140                         int max=0;
00141                         float maxW=0;
00142                         for (int i=0;i<=count;i++)
00143                         {
00144                                 if (f[i]>maxW)
00145                                 {
00146                                         max=i;
00147                                         maxW=f[i];
00148                                 }
00149                         }
00150                         return *m[max];*/
00151                 };
00152 
00153 
00154                 //TMatrix3D operator* (TMatrix3D& m);
00155    
00156                 //template <class A> TKoo3d<A> operator* (TKoo3d<A>& k);
00157                 template <class A> TKoo3d<A> operator* (TKoo3d<A>& k)
00158                 {
00159                         TKoo3d<A> koobuff;
00160 
00161                         koobuff.v[0]=(A)(v[0][0]*k.v[0]+v[1][0]*k.v[1]+v[2][0]*k.v[2]+v[3][0]);
00162                         koobuff.v[1]=(A)(v[0][1]*k.v[0]+v[1][1]*k.v[1]+v[2][1]*k.v[2]+v[3][1]);
00163                         koobuff.v[2]=(A)(v[0][2]*k.v[0]+v[1][2]*k.v[1]+v[2][2]*k.v[2]+v[3][2]);
00164 
00165 
00166                         return koobuff;
00167                 }
00168                 //inline TKoo3d<GLfloat> operator* (TKoo3d<GLfloat>& k);
00169                 //inline TKoo3dInt operator* (TKoo3dInt& k);
00170                 //void oneDivV();
00171                 virtual ~TMatrix3D()
00172                 {
00173                 };
00174                 TMatrix3D<T> getNormalized()
00175                 {
00176                         TMatrix3D<T> mBuff=*this;
00177                         mBuff.normalize();
00178                         return mBuff;
00179                 }
00180                 void normalize()
00181                 {
00182                         double fBuff;
00183                         for (int k=0;k<3;k++)
00184                         {
00185                                 
00186                                 fBuff=sqrt(v[k][0]*v[k][0]+v[k][1]*v[k][1]+v[k][2]*v[k][2]);
00187                                 v[k][0]=(T)(v[k][0]/fBuff);
00188                                 v[k][1]=(T)(v[k][1]/fBuff);
00189                                 v[k][2]=(T)(v[k][2]/fBuff);
00190 
00191                         }
00192                 };
00193                 TMatrix3D<T> operator+ (TMatrix3D<T>& m)
00194                 {
00195                         TMatrix3D<T> mBuff(NULL);
00196                         for (int i=0;i<4;i++)
00197                                 for (int j=0;j<4;j++)
00198                                         mBuff.v[i][j]=v[i][j]+m.v[i][j];
00199 
00200                         return mBuff;
00201                                         
00202                 }
00203                 TMatrix3D<T> getRotFract()
00204                 {
00205                         TMatrix3D<T> mBuff;
00206                         for (int i=0;i<3;i++)
00207                                 for (int j=0;j<3;j++)
00208                                         mBuff.v[i][j]=v[i][j];
00209                         return mBuff;
00210 
00211                 }
00212                 TKoo3d<T> getTransFract()
00213                 {
00214                         return TKoo3d<T> (v[3][0],v[3][1],v[3][2]);
00215                 }
00216                 void setRotFract(TMatrix3D<T>& m)
00217                 {
00218                         
00219                         for (int i=0;i<3;i++)
00220                                 for (int j=0;j<3;j++)
00221                                         v[i][j]=m.v[i][j];
00222                         
00223 
00224                 }
00225                 void setTransFract(TKoo3d<T>& t)
00226                 {
00227                         for (int i=0;i<3;i++)
00228                                 v[3][i]=t.v[i];
00229                 }
00230                 TMatrix3D<T> operator- (TMatrix3D<T>& m)
00231                 {
00232                         TMatrix3D<T> mBuff(NULL);
00233                         for (int i=0;i<4;i++)
00234                                 for (int j=0;j<4;j++)
00235                                         mBuff.v[i][j]=v[i][j]-m.v[i][j];
00236 
00237                         return mBuff;
00238                                         
00239                 }
00240                 TMatrix3D<T> operator* (float f)
00241                 {
00242                         TMatrix3D<T> mBuff(NULL);
00243                         for (int i=0;i<4;i++)
00244                                 for (int j=0;j<4;j++)
00245                                         mBuff.v[i][j]=v[i][j]*f;
00246 
00247                         return mBuff;
00248                                         
00249                 }
00250                 TMatrix3D()
00251                 {
00252                         /*for (int x=0; x<=3; x++)
00253                         for (int y=0; y<=3; y++)
00254                         v[x][y]=0;
00255                    v[0][0]=1;
00256                    v[1][1]=1;
00257                    v[2][2]=1;
00258                    v[3][3]=1;*/
00259                    EINHEITSMATRIX(v);
00260                 }
00261                 TMatrix3D(float  mat[][4])
00262                 {
00263                         if (mat)
00264                                 memcpy(v,mat,sizeof(GLfloat)*16);
00265                         else
00266                                 NULLMATRIX(v);
00267 
00268                 }
00269                 void oneDivV()
00270                 {
00271                         for (int i=0;i<=3;i++)
00272                                 for (int j=0;j<=3;j++)
00273                                         v[i][j]=(v[i][j])?1/v[i][j]:0;
00274                 }
00275                 TMatrix3D fastInvert();
00276 
00277                 void addLinCombRow(T* row, int ind, T linFakt)
00278                 {
00279                         v[0][ind]=v[0][ind]+row[0]*linFakt;
00280                         v[1][ind]=v[1][ind]+row[1]*linFakt;
00281                         v[2][ind]=v[2][ind]+row[2]*linFakt;
00282                         v[3][ind]=v[3][ind]+row[3]*linFakt;
00283                 }
00284 
00285                 TMatrix3D invert()
00286                 {
00287                         int i;
00288                         int j;
00289                         T rowBuff[4];
00290                         TMatrix3D<T> mBuff;
00291 
00292                         for (j=0;j<3;j++)
00293                         {
00294                                 rowBuff[0]=v[0][j];     
00295                                 rowBuff[1]=v[1][j];     
00296                                 rowBuff[2]=v[2][j];     
00297                                 rowBuff[3]=v[3][j];
00298                                 for (i=j+1;i<4;i++)
00299                                 {
00300                                         
00301                                         
00302                                         addLinCombRow(rowBuff,i, -v[j][i]/v[j][j]); 
00303                                         mBuff.addLinCombRow(rowBuff,i, -v[j][i]/v[j][j]);
00304                                 }
00305                         }
00306 
00307                         for (j=3;j>0;j--)
00308                         {
00309                                 rowBuff[0]=v[0][j];     
00310                                 rowBuff[1]=v[1][j];     
00311                                 rowBuff[2]=v[2][j];     
00312                                 rowBuff[3]=v[3][j];
00313                                 for (i=j-1;i>=0;i--)
00314                                 {
00315                                         
00316                                         
00317                                         addLinCombRow(rowBuff,i, -v[j][i]/v[j][j]); 
00318                                         mBuff.addLinCombRow(rowBuff,i, -v[j][i]/v[j][j]);
00319                                 }
00320                         }
00321 
00322                         for (j=0;j<4;j++)
00323                                 for (i=0;i<4;i++)
00324                                         mBuff.v[i][j]/=v[j][j];
00325 
00326                         return mBuff;   
00327                 }
00328 
00329 };
00330 
00331 template <class T> class TTransMatrix : public TMatrix3D<T>  
00332 {
00333 public:
00334         TTransMatrix(GLfloat x,GLfloat y,GLfloat z)
00335         {
00336                 v[3][0]=x;
00337                 v[3][1]=y;
00338                 v[3][2]=z;
00339 
00340         }
00341         virtual ~TTransMatrix()
00342         {
00343         };
00344 };
00345 
00346 template <class T> class TRollMatrix : public TMatrix3D<T>  
00347 {
00348 public:
00349         TRollMatrix()
00350         {
00351                 v[0][0]=0;
00352                 v[1][0]=1;
00353                 v[0][1]=1;
00354                 v[1][1]=0;
00355 
00356         }
00357         virtual ~TRollMatrix()
00358         {
00359         };
00360 };
00361 
00362 template <class T> class TRotMatrixZ : public TMatrix3D<T>  
00363 {
00364 public:
00365         TRotMatrixZ(double w)
00366         {
00367                 v[0][0]=(T)cos(w);v[1][0]=(T)-sin(w);
00368            v[0][1]=(T)sin(w);v[1][1]=(T)cos(w);
00369         };
00370         virtual ~TRotMatrixZ()
00371         {
00372         };
00373 
00374 };
00375 template <class T> class TRotMatrixX : public TMatrix3D<T>  
00376 {
00377 public:
00378         TRotMatrixX(double w)
00379         {
00380                 v[1][1]=(T)cos(w);v[2][1]=(T)-sin(w);
00381                 v[1][2]=(T)sin(w);v[2][2]=(T)cos(w);
00382         };
00383         virtual ~TRotMatrixX()
00384         {
00385         };
00386 
00387 };
00388 template <class T> class TRotMatrixY : public TMatrix3D<T>  
00389 {
00390 public:
00391         TRotMatrixY(double w)
00392         {
00393                 v[0][0]=(T)cos(w);v[2][0]=(T)-sin(w);
00394                 v[0][2]=(T)sin(w);v[2][2]=(T)cos(w);
00395         };
00396         virtual ~TRotMatrixY()
00397         {
00398         };
00399 
00400 };
00401 template <class T> class TRotMatrix : public TMatrix3D<T>  
00402 {
00403 public:
00404         template <class A> TRotMatrix(TKoo3d<A>& achse, float angle)
00405         {
00406                 TKoo3d<A> uz=achse.normalize();
00407                 TKoo3d<A> uy=(uz*TKoo3d<GLfloat>(1.0,0.0,0.0)).normalize();
00408                 if (uy==TKoo3d<A>(0.0,0.0,0.0))
00409                         uy=(uz*TKoo3d<A>(1.0,1.0,0.0)).normalize();
00410                 
00411                 TKoo3d<A> ux=(uy*uz).normalize();
00412 
00413                 TMatrix3D<T> mBuff;
00414                 for (int i=0;i<3;i++)
00415                 {
00416                         mBuff.v[i][0]=ux.v[i];
00417                         mBuff.v[i][1]=uy.v[i];
00418                         mBuff.v[i][2]=uz.v[i];
00419 
00420                 }
00421                 
00422 
00423                 mBuff=mBuff.fastInvert()*TRotMatrixZ<T>(angle)*mBuff;
00424                 memcpy(v,mBuff.v,sizeof(T)*16);
00425 
00426         };
00427 
00428         virtual ~TRotMatrix()
00429         {
00430         };
00431 
00432 };
00433 
00434 
00435 
00436 template <class T> TMatrix3D<T> TMatrix3D<T>::fastInvert()
00437 {
00438         TMatrix3D<T> mBuff;
00439 
00440         for (int i=0;i<3;i++)
00441         {
00442                                 
00443                 for (int j=0;j<3;j++)
00444                         mBuff.v[i][j]=v[j][i];
00445 
00446         }
00447         mBuff=TTransMatrix<T>(-v[3][0],-v[3][1],-v[3][2])*mBuff;
00448         return mBuff;
00449 }
00450 
00451 /*inline TMatrix3D TMatrix3D::interpolate(TMatrix3D& m, float f)
00452 {
00453         TMatrix3D mBuff;
00454         for (int i=0;i<4;i++)
00455                 for (int j=0;j<4;j++)
00456                         mBuff.v[i][j]=f*v[i][j]+(1.0f-f)*m.v[i][j];
00457 
00458         return mBuff;
00459         
00460 }*/
00461 
00462 
00463 /*inline void TMatrix3D::GLMatrixCapture(GLenum matr)
00464 {
00465         glGetFloatv(matr,&v[0][0]);
00466 }*/
00467 /*inline void TMatrix3D::GLMatrixCapture()
00468 {
00469         glGetFloatv(GL_MODELVIEW_MATRIX,&v[0][0]);
00470 }*/
00471 /*inline void TMatrix3D::GLMatrixSet()
00472 {
00473         glLoadMatrixf(&v[0][0]);
00474 }*/
00475 /*inline void TMatrix3D::GLMatrixMult()
00476 {
00477         glMultMatrixf(&v[0][0]);
00478 }*/
00479 
00480 /*inline TKoo3dInt TMatrix3D::operator* (TKoo3dInt& k)
00481 {
00482         TKoo3dInt koobuff;
00483 
00484         koobuff.x=TSglHelperClass::runden(v[0][0]*k.x+v[1][0]*k.y+v[2][0]*k.z+v[3][0]);
00485         koobuff.y=TSglHelperClass::runden(v[0][1]*k.x+v[1][1]*k.y+v[2][1]*k.z+v[3][1]);
00486         koobuff.z=TSglHelperClass::runden(v[0][2]*k.x+v[1][2]*k.y+v[2][2]*k.z+v[3][2]);
00487 
00488         return koobuff;
00489 }*/
00490 /*
00491 template <class A> inline TKoo3d<A> TMatrix3D::operator* (TKoo3d<A>& k)
00492 {
00493         TKoo3d<A> koobuff;
00494 
00495         koobuff.v[0]=(A)(v[0][0]*k.v[0]+v[1][0]*k.v[1]+v[2][0]*k.v[2]+v[3][0]);
00496         koobuff.v[1]=(A)(v[0][1]*k.v[0]+v[1][1]*k.v[1]+v[2][1]*k.v[2]+v[3][1]);
00497         koobuff.v[2]=(A)(v[0][2]*k.v[0]+v[1][2]*k.v[1]+v[2][2]*k.v[2]+v[3][2]);
00498 
00499 
00500         return koobuff;
00501 }*/
00502 
00503 
00504 #endif // !defined(AFX_TMATRIX3D_H__A4C4DBBF_648D_4404_9191_25D98E20B62B__INCLUDED_)
Generated on Mon Jan 19 02:06:39 2004 for flowvis by doxygen 1.3.5