Moka libraries: src/lib-spamod/main/k2-view.cc Source File

00001 /*
00002  * lib-spamod : Visualisation des objets en discret.
00003  * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
00004  *               http://www.sic.sp2mi.univ-poitiers.fr/
00005  * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
00006  *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
00007  *
00008  * This file is part of lib-spamod
00009  *
00010  * This program is free software: you can redistribute it and/or modify
00011  * it under the terms of the GNU Lesser General Public License as published by
00012  * the Free Software Foundation, either version 3 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public License
00021  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00022  */
00023 
00024 /******************************************************************************
00025  *  Fichier  : K2_View.cpp                                                    *
00026  *  Auteur   : DEXET Martine                                                  *
00027  *----------------------------------------------------------------------------*
00028  *  Ce fichier contient l'implémentation des méthodes de la classe K2_View.   *
00029  *                                                                            *
00030  *****************************************************************************/
00031 
00032 
00033 #include <GL/glut.h>
00034 #include "matrix.hh"
00035 #include "k2-view.hh"
00036 #include "user.hh"
00037 #include "matrix-att.hh"
00038 
00039 using namespace GMap3d;
00040 
00041 /******************************************************************************
00042  *                              Constructeur                                  *
00043  *****************************************************************************/
00044 
00045 K2_View::K2_View(CGMap * GM)
00046 {
00047   G = GM;
00048 }
00049 
00050 
00051 /******************************************************************************
00052  *  Fonction : void K2View::Calculate_Matrix()                               *
00053  *----------------------------------------------------------------------------*
00054  *  Cette fonction recherche pour chaque pointel les liaisons possibles avec  *
00055  * les autres pointels.                                                       *
00056  *                                                                            *
00057  *****************************************************************************/
00058 
00059 void K2_View::Calculate_Matrix()
00060 {
00061   CDart * d;
00062   int markVoxel = G->getNewMark();
00063 
00064   CDynamicCoverageAll Cgm(G);
00065   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00066     {
00067       d = *Cgm;
00068 
00069       // Si le brin n'est pas marqué.
00070       if (!G->isMarked(d, markVoxel))
00071         {
00072 
00073           // Récupération de la matrice principale.
00074           Matrix * mat = ((Matrix_Att *)G
00075             ->getAttribute(d, ORBIT_0123, MATRIX_ATTRIBUTE_ID))->Get_Data();
00076 
00077           // Parcours des cases de la matrice et mise à jour des bits qu'elles
00078           // contiennent.
00079 
00080           // Premier parcours suivant le plan (X,Y).
00081           for (int k = mat->Get_Z_Min(); k<mat->Get_Z_Max()+1; k++)
00082         
00083             for (int j = mat->Get_Y_Min(); j< mat->Get_Y_Max()+1; j++)
00084         
00085               for (int i = mat->Get_X_Min(); i< mat->Get_X_Max()+1; i++)
00086                 {
00087                   if (i!=mat->Get_X_Max())
00088                 
00089                     if (mat->Get_Color(i+1, j, k) != NO_COLOR)
00090                       mat->Set_Bit(i, j, k, 2);
00091                 
00092                     else
00093                       mat->Unset_Bit(i, j, k, 2);
00094                 
00095                   else
00096                     mat->Unset_Bit(i, j, k, 2);
00097                 
00098                   if (j!=mat->Get_Y_Max())
00099                 
00100                     if (mat->Get_Color(i, j+1, k) != NO_COLOR)
00101                       mat->Set_Bit(i, j, k, 3);
00102                 
00103                     else
00104                       mat->Unset_Bit(i, j, k, 3);
00105                 
00106                   else
00107                     mat->Unset_Bit(i, j, k, 3);
00108                 
00109                   if (i!=mat->Get_X_Max() && j!=mat->Get_Y_Max())
00110                 
00111                     if ((mat->Get_Color(i+1, j+1, k) != NO_COLOR) &&
00112                         (mat->Get_Color(i+1, j, k) != NO_COLOR) &&
00113                         (mat->Get_Color(i, j+1, k) != NO_COLOR))
00114                       mat->Set_Bit(i, j, k, 4);
00115                 
00116                     else
00117                       mat->Unset_Bit(i, j, k, 4);
00118                 
00119                   else
00120                     mat->Unset_Bit(i, j, k, 4);
00121                 }
00122         
00123           // Deuxième parcours suivant le plan (Z,Y).
00124           for (int i = mat->Get_X_Min(); i<mat->Get_X_Max()+1; i++)
00125         
00126             for (int j = mat->Get_Y_Min(); j< mat->Get_Y_Max()+1; j++)
00127         
00128               for (int k = mat->Get_Z_Min(); k< mat->Get_Z_Max()+1; k++)
00129                 {
00130                   if (k!=mat->Get_Z_Max())
00131                 
00132                     if (mat->Get_Color(i, j, k+1) != NO_COLOR)
00133                       mat->Set_Bit(i, j, k, 5);
00134                 
00135                     else
00136                       mat->Unset_Bit(i, j, k, 5);
00137                 
00138                   else
00139                     mat->Unset_Bit(i, j, k, 5);
00140                 
00141                   if (k!=mat->Get_Z_Max() && j!=mat->Get_Y_Max())
00142                 
00143                     if ((mat->Get_Color(i, j+1, k+1) != NO_COLOR) &&
00144                         (mat->Get_Color(i, j, k+1) != NO_COLOR) &&
00145                         (mat->Get_Color(i, j+1, k) != NO_COLOR))
00146                       mat->Set_Bit(i, j, k, 6);
00147                 
00148                     else
00149                       mat->Unset_Bit(i, j, k, 6);
00150                 
00151                   else
00152                     mat->Unset_Bit(i, j, k, 6);
00153                 }
00154         
00155           // Troisième parcours suivant le plan (X,Z).
00156           for (int j = mat->Get_Y_Min(); j<mat->Get_Y_Max()+1; j++)
00157         
00158             for (int k = mat->Get_Z_Min(); k< mat->Get_Z_Max()+1; k++)
00159         
00160               for (int i = mat->Get_X_Min(); i< mat->Get_X_Max()+1; i++)
00161                 {
00162                   if (k!=mat->Get_Z_Max() && i!=mat->Get_X_Max())
00163                 
00164                     if ((mat->Get_Color(i+1, j, k+1) != NO_COLOR) &&
00165                         (mat->Get_Color(i, j, k+1) != NO_COLOR) &&
00166                         (mat->Get_Color(i+1, j, k) != NO_COLOR))
00167                       mat->Set_Bit(i, j, k, 7);
00168 
00169                     else
00170                       mat->Unset_Bit(i, j, k, 7);
00171                 
00172                   else
00173                     mat->Unset_Bit(i, j, k, 7);
00174                 }
00175           CCoverage* DC = G->getDynamicCoverage(d, ORBIT_0123);
00176           for (DC->reinit(); DC->cont(); (*DC) ++)
00177             G->setMark(**DC, markVoxel);
00178           delete DC;
00179         }
00180     }
00181   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00182     G->unsetMark(*Cgm, markVoxel);
00183 
00184 
00185   G->freeMark(markVoxel);
00186 }
00187 
00188 
00189 /******************************************************************************
00190  *  Fonction : void K2View::Draw_Pointels()                                  *
00191  *----------------------------------------------------------------------------*
00192  *  Cette fonction affiche les pointels de la vue K2 d'un objet.              *
00193  *                                                                            *
00194  *****************************************************************************/
00195 
00196 void K2_View::Draw_Pointels()
00197 {
00198   CDart * d;
00199   int markVoxel = G->getNewMark();
00200 
00201   CDynamicCoverageAll Cgm(G);
00202   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00203     {
00204       d = *Cgm;
00205 
00206       // Si le brin n'est pas marqué.
00207       if (!G->isMarked(d, markVoxel))
00208         {
00209         
00210           // Récupération de la matrice principale.
00211           CAttribute *alpha = G->getAttribute(d, ORBIT_0123, MATRIX_ATTRIBUTE_ID);
00212           Matrix * mat = ((Matrix_Att*)alpha)->Get_Data();
00213         
00214           // Affichage des pointels.
00215           glPointSize(4.0);
00216           glBegin(GL_POINTS);
00217         
00218           for (int i=mat->Get_X_Min() ; i<=mat->Get_X_Max() ; i++)
00219             for (int j=mat->Get_Y_Min() ; j<=mat->Get_Y_Max() ; j++)
00220               for (int k=mat->Get_Z_Min() ; k<=mat->Get_Z_Max() ; k++)
00221                 
00222                 if (mat->Get_Color(i,j,k) != NO_COLOR)
00223                   glVertex3f(i, j, k);
00224           glEnd();
00225           glPointSize(1.0);
00226 
00227           CCoverage* DC = G->getDynamicCoverage(d, ORBIT_0123);
00228           for (DC->reinit(); DC->cont(); (*DC)++)
00229             G->setMark(**DC, markVoxel);
00230           delete DC;
00231         }
00232     }
00233   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00234     G->unsetMark(*Cgm, markVoxel);
00235 
00236 
00237   G->freeMark(markVoxel);
00238 }
00239 
00240 
00241 /******************************************************************************
00242  *  Fonction : void K2View::Draw_Lignels()                                   *
00243  *----------------------------------------------------------------------------*
00244  *  Cette fonction affiche les lignels de la vue K2 d'un objet.               *
00245  *                                                                            *
00246  *****************************************************************************/
00247 
00248 void K2_View::Draw_Lignels()
00249 {
00250   CDart * d;
00251   int markVoxel = G->getNewMark();
00252 
00253   CDynamicCoverageAll Cgm(G);
00254   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00255     {
00256       d = *Cgm;
00257 
00258       // Si le brin n'est pas marqué.
00259       if (!G->isMarked(d, markVoxel))
00260         {
00261 
00262           // Récupération de la matrice principale.
00263           CAttribute *alpha = G->getAttribute(d, ORBIT_0123, MATRIX_ATTRIBUTE_ID);
00264           Matrix * mat = ((Matrix_Att*)alpha)->Get_Data();
00265         
00266           // Affichage des lignels.
00267           glLineWidth(2.0);
00268           glBegin(GL_LINES);
00269 
00270           for (int i=mat->Get_X_Min() ; i<=mat->Get_X_Max() ; i++)
00271             for (int j=mat->Get_Y_Min() ; j<=mat->Get_Y_Max() ; j++)
00272               for (int k=mat->Get_Z_Min() ; k<=mat->Get_Z_Max() ; k++)
00273                 
00274                 if (mat->Get_Color(i,j,k) != NO_COLOR)
00275                   {
00276                     if (mat->Get_Bit(i, j, k, 2))
00277                       {
00278                         glVertex3f(i, j, k);
00279                         glVertex3f(i+1, j, k);
00280                       }
00281                 
00282                     if (mat->Get_Bit(i, j, k, 3))
00283                       {
00284                         glVertex3f(i, j, k);
00285                         glVertex3f(i, j+1, k);
00286                       }
00287                 
00288                     if (mat->Get_Bit(i, j, k, 5))
00289                       {
00290                         glVertex3f(i, j, k);
00291                         glVertex3f(i, j, k+1);
00292                       }
00293                   }
00294           glEnd();
00295           glLineWidth(1.0);
00296 
00297           CCoverage* DC = G->getDynamicCoverage(d, ORBIT_0123);
00298           for (DC->reinit(); DC->cont(); (*DC)++)
00299             G->setMark(**DC, markVoxel);
00300           delete DC;
00301         }
00302     }
00303   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00304     G->unsetMark(*Cgm, markVoxel);
00305 
00306 
00307   G->freeMark(markVoxel);
00308 }
00309 
00310 
00311 /******************************************************************************
00312  *  Fonction : void K2View::Draw_Surfels()                                   *
00313  *----------------------------------------------------------------------------*
00314  *  Cette fonction affiche les surfels de la vue K2 d'un objet.               *
00315  *                                                                            *
00316  *****************************************************************************/
00317 
00318 void K2_View::Draw_Surfels()
00319 {
00320   CDart * d;
00321   int markVoxel = G->getNewMark();
00322 
00323   // Activation de l'éclairage.
00324   glEnable(GL_LIGHTING);
00325   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
00326 
00327   CDynamicCoverageAll Cgm(G);
00328   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00329     {
00330       d = *Cgm;
00331 
00332       // Si le brin n'est pas marqué.
00333       if (!G->isMarked(d, markVoxel))
00334         {
00335 
00336           // Récupération de la matrice principale.
00337           CAttribute *alpha = G->getAttribute(d, ORBIT_0123, MATRIX_ATTRIBUTE_ID);
00338           Matrix * mat = ((Matrix_Att*)alpha)->Get_Data();
00339         
00340           // Affichage des surfels.
00341           glBegin(GL_QUADS);
00342         
00343           for (int i=mat->Get_X_Min() ; i<=mat->Get_X_Max() ; i++)
00344             for (int j=mat->Get_Y_Min() ; j<=mat->Get_Y_Max() ; j++)
00345               for (int k=mat->Get_Z_Min() ; k<=mat->Get_Z_Max() ; k++)
00346                 
00347                 if (mat->Get_Color(i,j,k) != NO_COLOR)
00348                   {
00349                     if (mat->Get_Bit(i, j, k, 4))
00350                       {
00351                         glNormal3f(0.0, 0.0, 1.0);
00352                         glVertex3f(i+0.2, j+0.2, k);
00353                         glVertex3f(i+0.8, j+0.2, k);
00354                         glVertex3f(i+0.8, j+0.8, k);
00355                         glVertex3f(i+0.2, j+0.8, k);
00356                       }
00357                     if (mat->Get_Bit(i, j, k, 6))
00358                       {
00359                         glNormal3f(1.0, 0.0, 0.0);
00360                         glVertex3f(i, j+0.2, k+0.2);
00361                         glVertex3f(i, j+0.8, k+0.2);
00362                         glVertex3f(i, j+0.8, k+0.8);
00363                         glVertex3f(i, j+0.2, k+0.8);
00364                       }
00365                     if (mat->Get_Bit(i, j, k, 7))
00366                       {
00367                         glNormal3f(0.0, 1.0, 0.0);
00368                         glVertex3f(i+0.2, j, k+0.2);
00369                         glVertex3f(i+0.2, j, k+0.8);
00370                         glVertex3f(i+0.8, j, k+0.8);
00371                         glVertex3f(i+0.8, j, k+0.2);
00372                       }
00373                   }
00374           glEnd();
00375           CCoverage* DC = G->getDynamicCoverage(d, ORBIT_0123);
00376           for (DC->reinit(); DC->cont(); (*DC)++)
00377             G->setMark(**DC, markVoxel);
00378           delete DC;
00379         }
00380     }
00381   for (Cgm.reinit(); Cgm.cont(); Cgm++)
00382     G->unsetMark(*Cgm, markVoxel);
00383 
00384 
00385   G->freeMark(markVoxel);
00386 
00387   // Désactivation de l'éclairage.
00388   glDisable(GL_LIGHTING);
00389   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
00390 }