Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Regular/Unimodal/3d/1B/Intensity/Splat/splat.cpp

Go to the documentation of this file.
00001 #include "splat.h"
00002 #include "vuTFunc/simpleFuncs.h"
00003 #include <fstream.h>
00004 #include <math.h>
00005 
00006 //----------------------------------------------------------------------------
00007 //------------------------- Static texture variables -------------------------
00008 //----------------------------------------------------------------------------
00009 
00010 static float texcoord0[2] = {0.0f, 0.0f};
00011 static float texcoord1[2] = {0.0f, 1.0f};
00012 static float texcoord2[2] = {1.0f, 1.0f};
00013 static float texcoord3[2] = {1.0f, 0.0f};
00014 
00015 //----------------------------------------------------------------------------
00016 //------------------------- The default constructor --------------------------
00017 //----------------------------------------------------------------------------
00018 
00019 vu1112111::vu1112111()
00020 {
00021     m_Normals = 0;
00022 
00023     m_FPSize    = 256;
00024     m_Footprint = 0;
00025     m_GLSplat   = 0;
00026 
00027     computeSplat();
00028 }
00029 
00030 //----------------------------------------------------------------------------
00031 //------------------------- The copy constructor -----------------------------
00032 //----------------------------------------------------------------------------
00033 
00034 vu1112111::vu1112111(const vu1112111& inst) : vu111211(inst)
00035 {
00036     dword i;
00037 
00038     m_NTable = inst.m_NTable;
00039 
00040 #if defined(QUANTIZE_NORMALS)
00041     m_Normals = new byte[m_DataSize];
00042 #else
00043     m_Normals = new float[m_DataSize*3];
00044 #endif
00045     for(i=0;i<m_DataSize;++i)
00046         m_Normals[i] = inst.m_Normals[i];
00047 
00048     m_FPSize = inst.m_FPSize;
00049     computeSplat();
00050 }
00051 
00052 //----------------------------------------------------------------------------
00053 //------------------------- The destructor -----------------------------------
00054 //----------------------------------------------------------------------------
00055 
00056 vu1112111::~vu1112111()
00057 {
00058     if (m_Normals)
00059         delete [] m_Normals;
00060     if (m_Footprint)
00061     {
00062         delete [] m_Footprint;
00063         glDeleteTextures(1, &m_GLSplat);
00064     }
00065 }
00066 
00067 //----------------------------------------------------------------------------
00068 //------------------------- The assignment operator --------------------------
00069 //----------------------------------------------------------------------------
00070 
00071 vu1112111& vu1112111::operator=(const vu1112111& rhs)
00072 {
00073     if (this != &rhs)
00074     {
00075         vu111211::operator=(rhs);
00076 
00077         dword i;
00078 
00079         m_NTable = rhs.m_NTable;
00080 
00081         if (m_Normals)
00082             delete [] m_Normals;
00083 
00084 #if defined(QUANTIZE_NORMALS)
00085         m_Normals = new byte[m_DataSize];
00086 #else
00087         m_Normals = new float[m_DataSize*3];
00088 #endif
00089         for(i=0;i<m_DataSize;++i)
00090             m_Normals[i] = rhs.m_Normals[i];
00091 
00092         m_FPSize = rhs.m_FPSize;
00093 
00094         computeSplat();
00095     }
00096     return *this;
00097 }
00098 
00099 //----------------------------------------------------------------------------
00100 //------------------------- public setViewVectors() --------------------------
00101 //----------------------------------------------------------------------------
00102 
00103 void vu1112111::setViewVectors(const vuVector& view,const vuVector& up,const vuVector& right)
00104 {
00105     m_View = view;
00106     m_Shift1 = right*3.2f;
00107     m_Shift2 = up*3.2f;
00108     m_Shift0 = (m_Shift1+m_Shift2)*(-0.5f);
00109 }
00110 
00111 //----------------------------------------------------------------------------
00112 //------------------------- public setFootprintSize() ------------------------
00113 //----------------------------------------------------------------------------
00114 
00115 void vu1112111::setFootprintSize(dword size)
00116 {
00117     m_FPSize = size;
00118 }
00119 
00120 //----------------------------------------------------------------------------
00121 //------------------------- public getFootprintSize() ------------------------
00122 //----------------------------------------------------------------------------
00123 
00124 dword vu1112111::getFootprintSize() const
00125 {
00126     return m_FPSize;
00127 }
00128 
00129 //----------------------------------------------------------------------------
00130 //------------------------- public read() ------------------------------------
00131 //----------------------------------------------------------------------------
00132 
00133 bool vu1112111::read()
00134 {
00135     bool success = vu111211::read();
00136     if (!success) return false;
00137 
00138     //Allocate memory for the normals.
00139     if (m_Normals != 0) delete [] m_Normals;
00140 #if defined(QUANTIZE_NORMALS)
00141 
00142     m_Normals = new byte[m_DataSize];
00143 #else
00144     m_Normals = new float[m_DataSize*3];
00145 #endif
00146     preprocess();
00147     return true;
00148 }
00149 
00150 //----------------------------------------------------------------------------
00151 //------------------------- public readRaw() ---------------------------------
00152 //----------------------------------------------------------------------------
00153 
00154 bool vu1112111::readRaw(void)
00155 {
00156     dword len;
00157     ifstream in;
00158 
00159 #ifdef IS_NOCREATE_NEEDED
00160     in.open(m_FileName, ios::in|ios::binary|ios::nocreate);
00161 #else
00162         // The nocreate is not available on the IRIX boxes that we were compiling
00163         // this code on, so we had to remove this part from
00164     in.open(m_FileName, ios::in|ios::binary);
00165 #endif
00166     if (!in.is_open()) return false;
00167 
00168     in.seekg(0, ios::end);
00169     len = in.tellg();
00170     in.seekg(0, ios::beg);
00171 
00172     in >> m_Dim1Size >> m_Dim2Size >> m_Dim3Size;
00173     if (in.fail()) return false;
00174     m_DataSize = m_Dim1Size*m_Dim2Size*m_Dim3Size;
00175 
00176     m_Data = new byte[m_DataSize];
00177     in.read((char *) (m_Data), int (m_DataSize));
00178     if (in.fail()) return false;
00179 
00180     in.close();
00181 
00182     //Allocate memory for the normals.
00183     if (m_Normals != 0) delete [] m_Normals;
00184 #if defined(QUANTIZE_NORMALS)
00185     m_Normals = new byte[m_DataSize];
00186 #else
00187     m_Normals = new float[m_DataSize*3];
00188 #endif
00189     preprocess();
00190 
00191     return true;
00192 }
00193 
00194 //----------------------------------------------------------------------------
00195 //------------------------- private preprocess() -----------------------------
00196 //----------------------------------------------------------------------------
00197 
00198 void vu1112111::preprocess(void)
00199 {
00200     float norm[3];
00201     float len;
00202     dword w, wh;
00203     dword i, j, k, index;
00204 
00205     w = m_Dim1Size;
00206     wh = m_Dim1Size*m_Dim2Size;
00207 
00208     //
00209     // Compute all of the normals and create a quantization
00210     // table with 256 entries.
00211     //
00212     index = 0;
00213 #if defined(QUANTIZE_NORMALS)
00214     m_NTable.initCollection(m_DataSize);
00215 #endif
00216     for(k=0;k<m_Dim3Size;++k)
00217     {
00218         for(j=0;j<m_Dim2Size;++j)
00219         {
00220             for(i=0;i<m_Dim1Size;++i)
00221             {
00222                 if (i == 0)
00223                     norm[0] = m_Data[index+1]-m_Data[index];
00224                 else if (i == m_Dim1Size-1)
00225                     norm[0] = m_Data[index]-m_Data[index-1];
00226                 else
00227                     norm[0] = (m_Data[index+1]-m_Data[index-1])*0.5;
00228 
00229                 if (j == 0)
00230                     norm[1] = m_Data[index+w]-m_Data[index];
00231                 else if (j == m_Dim2Size-1)
00232                     norm[1] = m_Data[index]-m_Data[index-w];
00233                 else
00234                     norm[1] = (m_Data[index+w]-m_Data[index-w])*0.5;
00235 
00236                 if (k == 0)
00237                     norm[2] = m_Data[index+wh]-m_Data[index];
00238                 else if (k == m_Dim3Size-1)
00239                     norm[2] = m_Data[index]-m_Data[index-wh];
00240                 else
00241                     norm[2] = (m_Data[index+wh]-m_Data[index-wh])*0.5;
00242 
00243                 len = (float)sqrt((double)((norm[0]*norm[0])+
00244                                            (norm[1]*norm[1])+
00245                                            (norm[2]*norm[2])));
00246                 if (len > 0.0f)
00247                 {
00248                     norm[0] /= len;
00249                     norm[1] /= len;
00250                     norm[2] /= len;
00251                 }
00252 #if defined(QUANTIZE_NORMALS)
00253                 m_NTable.addToCollection(norm);
00254 #else
00255                 m_Normals[index*3] = norm[0];
00256                 m_Normals[index*3+1] = norm[1];
00257                 m_Normals[index*3+2] = norm[2];
00258 #endif
00259                 ++index;
00260             }
00261         }
00262     }
00263 
00264 #if defined(QUANTIZE_NORMALS)
00265     m_NTable.computeTable();
00266 
00267     //
00268     // Create a map from each voxel into the table
00269     // of quantized normals.
00270     //
00271     index = 0;
00272     for(k=0;k<m_Dim3Size;++k)
00273     {
00274         for(j=0;j<m_Dim2Size;++j)
00275         {
00276             for(i=0;i<m_Dim1Size;++i)
00277             {
00278                 if (i == 0)
00279                     norm[0] = m_Data[index+1]-m_Data[index];
00280                 else if (i == m_Dim1Size-1)
00281                     norm[0] = m_Data[index]-m_Data[index-1];
00282                 else
00283                     norm[0] = (m_Data[index+1]-m_Data[index-1])*0.5;
00284 
00285                 if (j == 0)
00286                     norm[1] = m_Data[index+w]-m_Data[index];
00287                 else if (j == m_Dim2Size-1)
00288                     norm[1] = m_Data[index]-m_Data[index-w];
00289                 else
00290                     norm[1] = (m_Data[index+w]-m_Data[index-w])*0.5;
00291 
00292                 if (k == 0)
00293                     norm[2] = m_Data[index+wh]-m_Data[index];
00294                 else if (k == m_Dim3Size-1)
00295                     norm[2] = m_Data[index]-m_Data[index-wh];
00296                 else
00297                     norm[2] = (m_Data[index+wh]-m_Data[index-wh])*0.5;
00298 
00299                 len = (float)sqrt((double)((norm[0]*norm[0])+
00300                                            (norm[1]*norm[1])+
00301                                            (norm[2]*norm[2])));
00302                 if (len > 0.0f)
00303                 {
00304                     norm[0] /= len;
00305                     norm[1] /= len;
00306                     norm[2] /= len;
00307                 }
00308                 m_Normals[index] = (byte)m_NTable.findNearest(norm);
00309 
00310                 ++index;
00311             }
00312         }
00313     }
00314 #endif
00315 }
00316 
00317 //----------------------------------------------------------------------------
00318 //------------------------- public render() ----------------------------------
00319 //----------------------------------------------------------------------------
00320 
00321 void vu1112111::render(void)
00322 
00323 {
00324   if (IsReRendering ())
00325 
00326   {
00327 
00328 //    glDrawBuffer (GL_FRONT);
00329     int S_index, S_step, S_size;
00330     int M_index, M_step, M_size;
00331     int F_index, F_step, F_size;
00332     float dp[3];
00333     float vals[3];
00334     float *F, *M, *S;
00335     float dF, dM, dS;
00336     float rF, rM;
00337     float *n;
00338     int   index;
00339     dword density;
00340 
00341     dp[0] = (m_View[0] > 0.0f)?m_View[0]:m_View[0]*-1.0f;
00342     dp[1] = (m_View[1] > 0.0f)?m_View[1]:m_View[1]*-1.0f;
00343     dp[2] = (m_View[2] > 0.0f)?m_View[2]:m_View[2]*-1.0f;
00344 
00345     //
00346     // Compute indices, ranges, and values so that the rendering
00347     // loop can be as efficient as possible.
00348     //
00349     if (dp[0] > dp[1])
00350     {
00351         if (dp[0] > dp[2])
00352         {
00353             if (dp[1] > dp[2])
00354             {
00355                 // 2, 1, 0  (i.e. z=fast, y=medium, x=slow)
00356                 S = &vals[0];
00357                 M = &vals[1];
00358                 F = &vals[2];
00359 
00360                 S_size = m_Dim1Size;
00361                 if (m_View[0] >= 0.0f){
00362                     S_step  = 1;
00363                     *S = 0.0f;
00364                     dS = 1.0f;
00365                     index = 0;
00366                 }else{
00367                     S_step  = -1;
00368                     *S = (float)m_Dim1Size-1.0f;
00369                     dS = -1.0f;
00370                     index = m_Dim1Size-1;
00371                 }
00372 
00373                 M_size = m_Dim2Size;
00374                 if (m_View[1] >= 0.0f){
00375                     M_step  = m_Dim1Size;
00376                     *M = 0.0f;
00377                     dM = 1.0f;
00378                     rM = -1.0f * (float)m_Dim2Size;
00379                 }else{
00380                     M_step  = -1*m_Dim1Size;
00381                     *M = (float)m_Dim2Size-1.0f;
00382                     dM = -1.0f;
00383                     rM = (float)m_Dim2Size;
00384                     index += (1-m_Dim2Size)*M_step;
00385                 }
00386 
00387                 F_size = m_Dim3Size;
00388                 if (m_View[2] >= 0.0f){
00389                     F_step  = m_Dim1Size*m_Dim2Size;
00390                     *F = 0.0f;
00391                     dF = 1.0f;
00392                     rF = -1.0f * (float)m_Dim3Size;
00393                 }else{
00394                     F_step  = -1*m_Dim1Size*m_Dim2Size;
00395                     *F = (float)m_Dim3Size-1.0f;
00396                     dF = -1.0f;
00397                     rF = (float)m_Dim3Size;
00398                     index += (1-m_Dim3Size)*F_step;
00399                 }
00400             }
00401             else
00402             {
00403                 // 1, 2, 0  (i.e. y=fast, z=medium, x=slow)
00404                 S = &vals[0];
00405                 F = &vals[1];
00406                 M = &vals[2];
00407 
00408                 S_size = m_Dim1Size;
00409                 if (m_View[0] >= 0.0f){
00410                     S_step  = 1;
00411                     *S = 0.0f;
00412                     dS = 1.0f;
00413                     index = 0;
00414                 }else{
00415                     S_step  = -1;
00416                     *S = (float)m_Dim1Size-1.0f;
00417                     dS = -1.0f;
00418                     index = m_Dim1Size-1;
00419                 }
00420 
00421                 F_size = m_Dim2Size;
00422                 if (m_View[1] >= 0.0f){
00423                     F_step  = m_Dim1Size;
00424                     *F = 0.0f;
00425                     dF = 1.0f;
00426                     rF = -1.0f * (float)m_Dim2Size;
00427                 }else{
00428                     F_step  = -1*m_Dim1Size;
00429                     *F = (float)m_Dim2Size-1.0f;
00430                     dF = -1.0f;
00431                     rF = (float)m_Dim2Size;
00432                     index += (1-m_Dim2Size)*F_step;
00433                 }
00434 
00435                 M_size = m_Dim3Size;
00436                 if (m_View[2] >= 0.0f){
00437                     M_step  = m_Dim1Size*m_Dim2Size;
00438                     *M = 0.0f;
00439                     dM = 1.0f;
00440                     rM = -1.0f * (float)m_Dim3Size;
00441                 }else{
00442                     M_step  = -1*m_Dim1Size*m_Dim2Size;
00443                     *M = (float)m_Dim3Size-1.0f;
00444                     dM = -1.0f;
00445                     rM = (float)m_Dim3Size;
00446                     index += (1-m_Dim3Size)*M_step;
00447                 }
00448             }
00449         }
00450         else
00451         {
00452             // 1, 0, 2  (i.e. y=fast, x=medium, z=slow)
00453             M = &vals[0];
00454             F = &vals[1];
00455             S = &vals[2];
00456 
00457             M_size = m_Dim1Size;
00458             if (m_View[0] >= 0.0f){
00459                 M_step  = 1;
00460                 *M = 0.0f;
00461                 dM = 1.0f;
00462                 rM = -1.0f* (float)m_Dim1Size;
00463                 index = 0;
00464             }else{
00465                 M_step  = -1;
00466                 *M = (float)m_Dim1Size-1.0f;
00467                 dM = -1.0f;
00468                 rM = (float)m_Dim1Size;
00469                 index = m_Dim1Size-1;
00470             }
00471 
00472             F_size = m_Dim2Size;
00473             if (m_View[1] >= 0.0f){
00474                 F_step  = m_Dim1Size;
00475                 *F = 0.0f;
00476                 dF = 1.0f;
00477                 rF = -1.0f * (float)m_Dim2Size;
00478             }else{
00479                 F_step  = -1*m_Dim1Size;
00480                 *F = (float)m_Dim2Size-1.0f;
00481                 dF = -1.0f;
00482                 rF = (float)m_Dim2Size;
00483                 index += (1-m_Dim2Size)*F_step;
00484             }
00485 
00486             S_size = m_Dim3Size;
00487             if (m_View[2] >= 0.0f){
00488                 S_step  = m_Dim1Size*m_Dim2Size;
00489                 *S = 0.0f;
00490                 dS = 1.0f;
00491             }else{
00492                 S_step  = -1*m_Dim1Size*m_Dim2Size;
00493                 *S = (float)m_Dim3Size-1.0f;
00494                 dS = -1.0f;
00495                 index += (1-m_Dim3Size)*S_step;
00496             }
00497         }
00498     }
00499     else
00500     {
00501         if (dp[1] > dp[2])
00502         {
00503             if (dp[0] > dp[2])
00504             {
00505                 // 2, 0, 1  (i.e. z=fast, x=medium, y=slow)
00506                 M = &vals[0];
00507                 S = &vals[1];
00508                 F = &vals[2];
00509 
00510                 M_size = m_Dim1Size;
00511                 if (m_View[0] >= 0.0f){
00512                     M_step  = 1;
00513                     *M = 0.0f;
00514                     dM = 1.0f;
00515                     rM = -1.0f* (float)m_Dim1Size;
00516                     index = 0;
00517                 }else{
00518                     M_step  = -1;
00519                     *M = (float)m_Dim1Size-1.0f;
00520                     dM = -1.0f;
00521                     rM = (float)m_Dim1Size;
00522                     index = m_Dim1Size-1;
00523                 }
00524 
00525                 S_size = m_Dim2Size;
00526                 if (m_View[1] >= 0.0f){
00527                     S_step  = m_Dim1Size;
00528                     *S = 0.0f;
00529                     dS = 1.0f;
00530                 }else{
00531                     S_step  = -1*m_Dim1Size;
00532                     *S = (float)m_Dim2Size-1.0f;
00533                     dS = -1.0f;
00534                     index += (1-m_Dim2Size)*S_step;
00535                 }
00536 
00537                 F_size = m_Dim3Size;
00538                 if (m_View[2] >= 0.0f){
00539                     F_step  = m_Dim1Size*m_Dim2Size;
00540                     *F = 0.0f;
00541                     dF = 1.0f;
00542                     rF = -1.0f * (float)m_Dim3Size;
00543                 }else{
00544                     F_step  = -1*m_Dim1Size*m_Dim2Size;
00545                     *F = (float)m_Dim3Size-1.0f;
00546                     dF = -1.0f;
00547                     rF = (float)m_Dim3Size;
00548                     index += (1-m_Dim3Size)*F_step;
00549                 }
00550             }
00551             else
00552             {
00553                 // 0, 2, 1  (i.e. x=fast, z=medium, y=slow)
00554                 F = &vals[0];
00555                 S = &vals[1];
00556                 M = &vals[2];
00557 
00558                 F_size = m_Dim1Size;
00559                 if (m_View[0] >= 0.0f){
00560                     F_step  = 1;
00561                     *F = 0.0f;
00562                     dF = 1.0f;
00563                     rF = -1.0f* (float)m_Dim1Size;
00564                     index = 0;
00565                 }else{
00566                     F_step  = -1;
00567                     *F = (float)m_Dim1Size-1.0f;
00568                     dF = -1.0f;
00569                     rF = (float)m_Dim1Size;
00570                     index = m_Dim1Size-1;
00571                 }
00572 
00573                 S_size = m_Dim2Size;
00574                 if (m_View[1] >= 0.0f){
00575                     S_step  = m_Dim1Size;
00576                     *S = 0.0f;
00577                     dS = 1.0f;
00578                 }else{
00579                     S_step  = -1*m_Dim1Size;
00580                     *S = (float)m_Dim2Size-1.0f;
00581                     dS = -1.0f;
00582                     index += (1-m_Dim2Size)*S_step;
00583                 }
00584 
00585                 M_size = m_Dim3Size;
00586                 if (m_View[2] >= 0.0f){
00587                     M_step  = m_Dim1Size*m_Dim2Size;
00588                     *M = 0.0f;
00589                     dM = 1.0f;
00590                     rM = -1.0f * (float)m_Dim3Size;
00591                 }else{
00592                     M_step  = -1*m_Dim1Size*m_Dim2Size;
00593                     *M = (float)m_Dim3Size-1.0f;
00594                     dM = -1.0f;
00595                     rM = (float)m_Dim3Size;
00596                     index += (1-m_Dim3Size)*M_step;
00597                 }
00598             }
00599         }
00600         else
00601         {
00602             // 0, 1, 2  (i.e. x=fast, y=medium, z=slow)
00603             F = &vals[0];
00604             M = &vals[1];
00605             S = &vals[2];
00606 
00607             F_size = m_Dim1Size;
00608             if (m_View[0] >= 0.0f){
00609                 F_step  = 1;
00610                 *F = 0.0f;
00611                 dF = 1.0f;
00612                 rF = -1.0f* (float)m_Dim1Size;
00613                 index = 0;
00614             }else{
00615                 F_step  = -1;
00616                 *F = (float)m_Dim1Size-1.0f;
00617                 dF = -1.0f;
00618                 rF = (float)m_Dim1Size;
00619                 index = m_Dim1Size-1;
00620             }
00621 
00622             M_size = m_Dim2Size;
00623             if (m_View[1] >= 0.0f){
00624                 M_step  = m_Dim1Size;
00625                 *M = 0.0f;
00626                 dM = 1.0f;
00627                 rM = -1.0f * (float)m_Dim2Size;
00628             }else{
00629                 M_step  = -1*m_Dim1Size;
00630                 *M = (float)m_Dim2Size-1.0f;
00631                 dM = -1.0f;
00632                 rM = (float)m_Dim2Size;
00633                 index += (1-m_Dim2Size)*M_step;;
00634             }
00635 
00636             S_size = m_Dim3Size;
00637             if (m_View[2] >= 0.0f){
00638                 S_step  = m_Dim1Size*m_Dim2Size;
00639                 *S = 0.0f;
00640                 dS = 1.0f;
00641             }else{
00642                 S_step  = -1*m_Dim1Size*m_Dim2Size;
00643                 *S = (float)m_Dim3Size-1.0f;
00644                 dS = -1.0f;
00645                 index += (1-m_Dim3Size)*S_step;
00646             }
00647         }
00648     }
00649 
00650     S_step -= M_step*M_size;
00651     M_step -= F_step*F_size;
00652 
00653     //
00654     // The following loop is highly optimized for speed, given
00655     // the values and indices computed in the above conditionals.
00656     //
00657     glBegin(GL_QUADS);
00658     for(S_index=0; S_index<S_size; ++S_index)
00659     {
00660         for(M_index=0; M_index<M_size; ++M_index)
00661         {
00662             for(F_index=0; F_index<F_size; ++F_index)
00663             {
00664                 density = m_Data[index];
00665                 if (m_TFunc[density][3] > 0.0f)
00666                 {
00667                     glColor4fv(m_TFunc[density]);
00668 #if defined(QUANTIZE_NORMALS)
00669                     n = m_NTable[m_Normals[index]];
00670 #else
00671                     n = &m_Normals[index*3];
00672 #endif
00673 
00674 #if defined(ONE_SIDED_LIGHTING)
00675                     if (n[0]*m_View[0] + n[1]*m_View[1] + n[2]*m_View[2] > 0.0f)
00676                     {
00677                         n[0] *= -1.0f;
00678                         n[1] *= -1.0f;
00679                         n[2] *= -1.0f;
00680                     }
00681 #endif
00682                     glNormal3fv(n);
00683 
00684                     drawSplatOrtho(vals);
00685                 }
00686 
00687                 index += F_step;
00688                 *F += dF;
00689             }
00690             *F += rF;
00691             *M += dM;
00692             index += M_step;
00693         }
00694         *M += rM;
00695         *S += dS;
00696         index += S_step;
00697     }
00698 
00699     glEnd();
00700   }
00701 
00702 //    glFlush ();
00703 
00704 /* 
00705 commented out by Steven Bergner:
00706 do this only if there is a read buffer is requested in any way:
00707 we basically need a concept for reading (and writing?) the image buffer
00708 of a renderer from outside
00709 
00710     int retval [4];
00711 
00712     glGetIntegerv (GL_VIEWPORT, retval);
00713 
00714     m_ImgBuffer.init (retval [2] + 1, retval [3] + 1);
00715 
00716     glReadBuffer (GL_FRONT);
00717 
00718     glReadPixels (0, 0, m_ImgBuffer.getWidth () - 1, m_ImgBuffer.getHeight () - 1, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *) (m_ImgBuffer.get_rgb ()));
00719 
00720     //cout << "dim1:" << retval [2] << "dim2:" << retval [3] << endl;
00721 
00722     //cout << endl;
00723 */
00724 }
00725 
00726 void vu1112111::drawPic ()
00727 
00728 {
00729 //      glBegin (GL_QUADS);
00730         glDrawBuffer (GL_FRONT);
00731 //      glDrawBuffer (GL_BACK);
00732 
00733 //      cout << "drawPic ()" << endl;
00734 
00735         glFinish ();
00736 
00737 //      glColor4f (0, 0, 0, 1.0);
00738 
00739         glDisable (GL_BLEND);
00740 
00741         glDrawPixels (m_ImgBuffer.getWidth () - 1, m_ImgBuffer.getHeight () - 1, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *) (m_ImgBuffer.get_rgb ()));
00742         glDrawBuffer (GL_BACK);
00743         glDrawPixels (m_ImgBuffer.getWidth () - 1, m_ImgBuffer.getHeight () - 1, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *) (m_ImgBuffer.get_rgb ()));
00744 
00745         glFinish ();
00746 //      glDrawBuffer (GL_FRONT);
00747         glDrawBuffer (GL_BACK);
00748 
00749         glEnable (GL_BLEND);
00750 //      glXSwapBuffers (
00751 
00752 //      glFlush ();
00753 //      glEnd ();
00754 }
00755 
00756 vuImage* vu1112111::getBuffer ()
00757 
00758 {
00759         return &m_ImgBuffer;
00760 }
00761 
00762 //----------------------------------------------------------------------------
00763 //------------------------- private computeSplat() ---------------------------
00764 //----------------------------------------------------------------------------
00765 
00766 void vu1112111::computeSplat(void)
00767 {
00768     dword index;
00769     dword i;
00770     dword j;
00771     double x;
00772     double y;
00773     double d;
00774 
00775     if (m_Footprint)
00776     {
00777         delete [] m_Footprint;
00778         glDeleteTextures(1, &m_GLSplat);
00779     }
00780 #if defined(COMBINERS)
00781     m_Footprint = new GLubyte[m_FPSize*m_FPSize];
00782 #else
00783     m_Footprint = new GLubyte[m_FPSize*m_FPSize*2];
00784 #endif
00785 
00786     index = 0;
00787     for(j=0;j<m_FPSize;++j)
00788     {
00789         for(i=0;i<m_FPSize;++i)
00790         {
00791             x = 0.5 - (double)i/(double)(m_FPSize-1);
00792             y = 0.5 - (double)j/(double)(m_FPSize-1);
00793             d = sqrt(x*x+y*y);
00794 #if !defined(COMBINERS)
00795             m_Footprint[index++] = 255;
00796 #endif
00797             m_Footprint[index++] = (GLubyte)(255.0*nelsonSplat(1.6*d));
00798         }
00799     }
00800 }
00801 
00802 //----------------------------------------------------------------------------
00803 //------------------------- private nelsonSplat() ----------------------------
00804 //----------------------------------------------------------------------------
00805 
00806 double vu1112111::nelsonSplat(double r)
00807 {
00808     double s = 0.8893919243498159;
00809     double t = 1.556227804798694;
00810     double a = 0.5575267703530060;
00811     double b = -1.157744128784905;
00812     double c = 0.6710333014812285;
00813     double d = 0.067598983313541278;
00814     double e = 0.2824741750452964;
00815     double f = t*t*(d+e*t);
00816     double g = -t*(2*d+3*e*t);
00817     double h = d+3*e*t;
00818     double v, u, rs, y, z, p, q;
00819 
00820     if(r == 0)
00821     {
00822         v = s*((a-f) + s*((-g)/2.0 + s*((b-h)/3.0 + s*(c+e)/4.0)))
00823           + t*(f + t*(g/2.0 + t*(h/3.0 + t*(-e)/4.0)));
00824     }
00825     else if(r < s)
00826     {
00827         rs = r*r;
00828         y = sqrt(s*s-rs);
00829         z = sqrt(t*t-rs);
00830         p = log(y+s);
00831         q = log(z+t);
00832         u = log(r);
00833         v = a*y + b*y*y*y/3.0 + b*y*rs + 0.5*c*rs*(y*s+rs*(p-u))
00834           + c*(y*s*s*s/4.0 - rs*0.125*(y*s+rs*(p-u)))
00835           + f*(z-y) + 0.5*(g-e*rs)*(z*t-y*s+rs*(q-p))
00836           + h*rs*(z-y) + (h/3.0)*(z*z*z-y*y*y)
00837           - e*(0.25*(z*t*t*t-y*s*s*s) - rs*0.125*(z*t-y*s+rs*(q-p)));
00838     }
00839     else if(r < t)
00840     {
00841         rs = r*r;
00842         z = sqrt(t*t-rs);
00843         q = log(z+t);
00844         u = log(r);
00845         v = f*z + 0.5*(g-e*rs)*(z*t+rs*(q-u)) + h*rs*z + (h/3.0)*z*z*z
00846           - e*(0.25*z*t*t*t-rs*0.125*(z*t+rs*(q-u)));
00847     }
00848     else
00849     {
00850         v = 0.0;
00851     }
00852 
00853     return 2.0*v;
00854 }
00855 
00856 //----------------------------------------------------------------------------
00857 //------------------------- public initOpenGL() ------------------------------
00858 //----------------------------------------------------------------------------
00859 //#define ONE_SIDED_LIGHTING
00860 
00861 void vu1112111::initOpenGL(void)
00862 {
00863     GLfloat shininess = 50.0f;
00864     GLfloat specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
00865 
00866 #if defined(ONE_SIDED_LIGHTING)
00867     glMaterialf(GL_FRONT, GL_SHININESS, shininess);
00868     glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
00869     glEnable(GL_COLOR_MATERIAL);
00870     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
00871 
00872     glPolygonMode(GL_FRONT, GL_FILL);
00873 #else
00874     glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
00875     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
00876     glEnable(GL_COLOR_MATERIAL);
00877     glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
00878 
00879     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
00880 #endif
00881 
00882     glShadeModel(GL_SMOOTH);
00883     glDisable(GL_DEPTH_TEST);
00884     glDisable(GL_ALPHA_TEST);
00885     glDisable(GL_CULL_FACE);
00886 
00887     glGenTextures(1, &m_GLSplat);
00888     glBindTexture(GL_TEXTURE_2D, m_GLSplat);
00889     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
00890     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
00891     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00892     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
00893     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
00894 
00895 #if defined(COMBINERS)
00896 
00897     gluBuild2DMipmaps(GL_TEXTURE_2D, 1, m_FPSize, m_FPSize,
00898                       GL_LUMINANCE, GL_UNSIGNED_BYTE,
00899                       (void*)m_Footprint);
00900     glEnable(GL_TEXTURE_2D);
00901 
00902         if (!glh_init_extensions("GL_NV_register_combiners "))
00903         cout << "Could not initialize extensions.\n" << flush;
00904 
00905     glEnable(GL_REGISTER_COMBINERS_NV);
00906         glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 1);
00907 
00908     // Setup combiner 0 - RGB
00909     glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV,   GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00910     glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO,               GL_UNSIGNED_INVERT_NV,   GL_RGB);
00911     glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00912     glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,               GL_UNSIGNED_INVERT_NV,   GL_RGB);
00913     glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
00914 
00915     // Setup combiner 0 - alpha
00916     glCombinerInputNV(GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
00917     glCombinerInputNV(GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_TEXTURE0_ARB,     GL_UNSIGNED_IDENTITY_NV, GL_BLUE);
00918     glCombinerOutputNV(GL_COMBINER0_NV, GL_ALPHA, GL_SPARE0_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
00919 
00920     // Setup final combiner - rgb
00921     glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_ZERO,      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00922     glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_ZERO,      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00923     glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO,      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00924     glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00925     glFinalCombinerInputNV(GL_VARIABLE_E_NV, GL_ZERO,      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00926     glFinalCombinerInputNV(GL_VARIABLE_F_NV, GL_ZERO,      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
00927 
00928     glEnable(GL_BLEND);
00929     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00930 
00931 #else
00932 
00933     gluBuild2DMipmaps(GL_TEXTURE_2D, 2, m_FPSize, m_FPSize,
00934                       GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
00935                       (void*)m_Footprint);
00936     glEnable(GL_TEXTURE_2D);
00937 
00938     glEnable(GL_BLEND);
00939     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
00940     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00941 #endif
00942 }
00943 
00944 //----------------------------------------------------------------------------
00945 //------------------------- private drawSplatOrtho() -------------------------
00946 //----------------------------------------------------------------------------
00947 
00948 void vu1112111::drawSplatOrtho(float* v)
00949 {
00950     vuVector pos(v[0], v[1], v[2]);
00951 
00952     pos += m_Shift0;
00953     glTexCoord2fv(texcoord0);
00954     glVertex3fv(pos.getData());
00955 
00956     pos += m_Shift1;
00957     glTexCoord2fv(texcoord1);
00958     glVertex3fv(pos.getData());
00959 
00960     pos += m_Shift2;
00961     glTexCoord2fv(texcoord2);
00962     glVertex3fv(pos.getData());
00963 
00964     pos -= m_Shift1;
00965     glTexCoord2fv(texcoord3);
00966     glVertex3fv(pos.getData());
00967 }
00968 
00969 //----------------------------------------------------------------------------
00970 //------------------------- private drawSplatPerspective() -------------------
00971 //----------------------------------------------------------------------------
00972 
00973 void vu1112111::drawSplatPerspective(float* v)
00974 {
00975 
00976 }

Generated on Wed Dec 15 21:20:32 2004 for vuVolume by  doxygen 1.3.9.1