src/lib-spamod/main/topologic-view.cc

Go to the documentation of this file.

/*
 * lib-spamod : Visualisation des objets en discret.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-spamod
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/******************************************************************************
 *  Fichier  : Topologic_View.h                                               *
 *  Auteur   : DEXET Martine                                                  *
 *----------------------------------------------------------------------------*
 *  Ce fichier contient l'implémentation des méthodes de la classe            *
 * Topologic_View.                                                            *
 *                                                                            *
 *****************************************************************************/


#include <GL/glut.h>
#include "user.hh"
#include "topologic-view.hh"
#include "vertex.hh"
#include "vector3d.hh"
#include "attribute-vertex.hh"

using namespace GMap3d;

/******************************************************************************
 *                                 Constructeur                               *
 *****************************************************************************/

Topologic_View::Topologic_View(CGMap * GM)
{
  G = GM;
}



/******************************************************************************
 *  Fonction : void TopologicView::Create_Face_Darts_View(CDart * dgm,        *
 *                                                         int markDart)     *
 *----------------------------------------------------------------------------*
 *  Cette fonction calcule les coordonnées des points représentant les brins  *
 * de la G-carte afin que les liaisons alpha0, alpha1 et alpha2 soient        *
 * visibles.                                                                  *
 *                                                                            *
 *****************************************************************************/

void Topologic_View::Create_Face_Darts_View(CDart * dgm, int markDart)
{
  CAttribute * alpha;
  CDart * de;
  CVertex * p1, * p2, p3, p4;
  Vector3D v;
  int nbPoints = 0;
  CVertex center(0.0,0.0,0.0);

  // Création d'une marque.
  int markCenter = G->getNewMark();


  // Parcourt des brins de l'arête ou de la face.
  CCoverage* DCe = G->getDynamicCoverage(dgm, ORBIT_01);
  for (DCe->reinit(); DCe->cont(); (*DCe)++)
    {
      de = **DCe;

      if (!G->isMarked(de, markCenter))
        {
          // Coordonnées du sommet.
          alpha = G->getAttribute(de,ORBIT_123,VERTEX_ATTRIBUTE_ID);
          p2 = (CAttributeVertex*)alpha;
        
          // Recherche du barycentre de l'arête ou de la face.
          center.setX(center.getX() + p2->getX());
          center.setY(center.getY() + p2->getY());
          center.setZ(center.getZ() + p2->getZ());
                        
          nbPoints++;

          // Marquage des brins appartenants au même sommet avec
          // la marque markCenter.
          G->setMark(de, markCenter);
          if (!G->isFree1(de))
            G->setMark(G->alpha1(de), markCenter);
        }
    }

  // Calcul des coordonées du barycentre de l'arête ou de la face.
  center.setX(center.getX()/(float)nbPoints);
  center.setY(center.getY()/(float)nbPoints);
  center.setZ(center.getZ()/(float)nbPoints);

                
  // Parcourt des brins de l'arête ou de la face.
  for (DCe->reinit();
       DCe->cont();
       (*DCe)++)
    {
      de = **DCe;

      // Démarquage du brin pour la marque markCenter.
      G->unsetMark(de, markCenter);

      if (!G->isMarked(de, markDart))
        {
          // Coordonnées du sommet correspondant au brin "de".
          alpha = G->getAttribute(de, ORBIT_123, VERTEX_ATTRIBUTE_ID);
          p1 = (CAttributeVertex*)alpha;
        
          // Coordonnées du sommet correspondant à l'image du
          // brin "de" par la relation alpha0.
          alpha = G->getAttribute(G->alpha0(de),ORBIT_123,VERTEX_ATTRIBUTE_ID);
          p2 = (CAttributeVertex*)alpha;
                        
          // Calcul des coordonnées des sommets qui seront
          // utilisés pour l'affichage.
          v.setXYZ(p2->getX()-p1->getX(),
                    p2->getY()-p1->getY(),
                    p2->getZ()-p1->getZ());
        
          // Cas où le brin n'est pas relié à autre brin par
          // alpha1.
          if (G->isFree1(de))
            p3 = *p1;
        
          // Cas où le brin est relié à un autre brin par alpha1.
          else
            {
              p3.setXYZ(p1->getX() + v.getX()/10.0,
                         p1->getY() + v.getY()/10.0,
                         p1->getZ() + v.getZ()/10.0);
            }
        
          // Cas où l'image du brin par alpha0 n'est pas reliée
          // à autre brin par alpha1.
          if (G->isFree1(G->alpha0(de)))
            p4 = *p2;
        
          // Cas où l'image du brin par alpha0 est reliée à un
          // autre brin par alpha1.
          else
            {
              p4.setXYZ(p2->getX() - v.getX()/10.0,
                         p2->getY() - v.getY()/10.0,
                         p2->getZ() - v.getZ()/10.0);
            }
        
          // Cas où le brin est relié à un autre brin par la
          // relation alpha2.
          if (!G->isFree2(de))
            {
              // Calcul des coordonnées des sommets qui seront
              // utilisés pour l'affichage.
              v.setXYZ(center.getX()-p3.getX(),
                        center.getY()-p3.getY(),
                        center.getZ()-p3.getZ());
              p3.setXYZ(p3.getX() + v.getX()/5.0,
                         p3.getY() + v.getY()/5.0,
                         p3.getZ() + v.getZ()/5.0);
        
              v.setXYZ(center.getX()-p4.getX(),
                        center.getY()-p4.getY(),
                        center.getZ()-p4.getZ());
              p4.setXYZ(p4.getX() + v.getX()/5.0,
                         p4.getY() + v.getY()/5.0,
                         p4.getZ() + v.getZ()/5.0);
            }
        
          // Affectation de l'attribut à l'orbite Orbit_SELF.
          G->addAttribute(de,ORBIT_SELF,new CAttributeVertex(p3));
                
          // Marquage du brin "de" avec la marque markDart.
          G->setMark(de, markDart);
        
        
          // Affectation de l'attribut à l'orbite Orbit_SELF.
          G->addAttribute(G->alpha0(de),ORBIT_SELF,
                           new CAttributeVertex(p4));
        
          // Marquage de l'image du brin "de" par la relation
          // alpha0 avec la marque markDart.
          G->setMark(G->alpha0(de), markDart);  
        }               
    }
  delete DCe;

  // Libération de la marque.
  G->freeMark(markCenter);
}



/******************************************************************************
 *  Fonction : void TopologicView::Create_Volume_Darts_View(CDart * dgm,      *
 *                                                           int markVolume) *
 *----------------------------------------------------------------------------*
 *  Cette fonction calcule les coordonnées des points représentant les brins  *
 * de la G-carte afin que les liaisons alpha3 soient visibles.                *
 *                                                                            *
 *****************************************************************************/

void Topologic_View::Create_Volume_Darts_View(CDart * dgm, int markVolume)
{
  CAttribute * alpha;
  CDart * de;
  CVertex * p1;
  Vector3D v;
  int nbPoints = 0;
  CVertex center(0.0,0.0,0.0);

  // Création d'une marque.
  int markCenter = G->getNewMark();


  // Parcourt des brins de la G-carte.
  CDynamicCoverageAll Cgm(G);
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    {
      dgm = *Cgm;

      if (!G->isMarked(dgm, markVolume))
        {
          // Cas où le brin est relié par alpha3 à un autre brin.
          if (!G->isFree3(dgm))
            {   
              // Parcourt des brins du volume.
              CCoverage* DCe = G->getDynamicCoverage(dgm, ORBIT_012);
              for (DCe->reinit();
                   DCe->cont();
                   (*DCe)++)
                {
                  de = **DCe;
        
                  if (!G->isMarked(de, markCenter))
                    {
                      // Coordonnées du sommet.
                      alpha = G->getAttribute(de,ORBIT_123,VERTEX_ATTRIBUTE_ID);
                      p1 = (CAttributeVertex*)alpha;

                      // Recherche du barycentre du volume.
                      center.setX(center.getX() + p1->getX());
                      center.setY(center.getY() + p1->getY());
                      center.setZ(center.getZ() + p1->getZ());
                
                      nbPoints++;
                
                      // Marquage des brins appartenants au même sommet avec
                      // la marque markCenter.
                      G->setMark(de, markCenter);
                      if (!G->isFree1(de))
                        G->setMark(G->alpha1(de), markCenter);
                    }           
                }
        
              // Calcul du barycentre du volume.
              center.setX(center.getX()/(float)nbPoints);
              center.setY(center.getY()/(float)nbPoints);
              center.setZ(center.getZ()/(float)nbPoints);
        

              // Parcourt des brins du volume.
              for (DCe->reinit();
                   DCe->cont();
                   (*DCe)++)
                {
                  de = **DCe;   

                  // Démarquage du brin pour la marque markCenter.
                  G->unsetMark(G->alpha0(de), markCenter);
                
                  if (!G->isMarked(de, markVolume))
                    {
                      // cas où le brin est relié à un autre brin par la
                      // liaison alpha3.
                      if (!G->isFree3(de))
                        {
                          // Coordonnées du sommet.
                          alpha = G->getAttribute(de, ORBIT_SELF,
                                             VERTEX_ATTRIBUTE_ID);
                          p1 = (CAttributeVertex*)alpha;

                          // Calcul des coordonnées des sommets qui seront
                          // utilisé pour l'affichage.
                          v.setXYZ(center.getX()-p1->getX(),
                                    center.getY()-p1->getY(),
                                    center.getZ()-p1->getZ());

                          p1->setXYZ(p1->getX() + v.getX()/5.0,
                                      p1->getY() + v.getY()/5.0,
                                      p1->getZ() + v.getZ()/5.0);
                        }
                
                      // Marquage du brin avec la marque markVolume.
                      G->setMark(de, markVolume);                       
                    }
                }
              delete DCe;
            }

          // Cas où le brin n'est pas relié par alpha3 à un autre brin.
          else
            G->setMark(dgm, markVolume);
        }
    }

  // Libération de la marque.
  G->freeMark(markCenter);
}



/******************************************************************************
 *  Fonction : void TopologicView::Create_Darts_View()                       *
 *----------------------------------------------------------------------------*
 *  Cette fonction parcourt la G-carte en calculant et en stockant, pour      *
 * chaque brin, les coordonnées du sommet qui sera utilisé pour l'affichage   *
 * topologique.                                                               *
 *                                                                            *
 *****************************************************************************/

void Topologic_View::Create_Darts_View()
{
  CDart * dgm = NULL;
  CAttribute * alpha;
  CVertex * p1;

  // Création de 2 marques.
  int markDart = G->getNewMark();
  int markVolume = G->getNewMark();


  // Parcourt des brins de la G-carte.
  CDynamicCoverageAll Cgm(G);
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    {
      dgm = *Cgm;

      if (!G->isMarked(dgm, markDart))
        {
          // Cas où le brin est seul.
          if (G->isFree0(dgm))
            {
              // Coordonnées du sommet.
              alpha = G->getAttribute(dgm, ORBIT_123, VERTEX_ATTRIBUTE_ID);
              p1 = (CAttributeVertex*)alpha;

              // Affectation de l'attribut à l'orbite Orbit_SELF.
              G->addAttribute(dgm, ORBIT_SELF, new CAttributeVertex(*p1));
                
        
              // Marquage du brin avec la marque markDart.
              G->setMark(dgm, markDart);
            }
        
          // Cas où le brin appartient à une arête ou à une face (ouverte ou
          // fermée).
          else
            // Calcul des coordonnées des points appartenants à une arête ou
            // une face.
            Create_Face_Darts_View(dgm, markDart);
        }
    }

  // Calcul des coordonnées des points appartenants à un volume.
  Create_Volume_Darts_View(dgm, markVolume);


  // Démarquage des brins et libération des 2 marques.
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    {
      G->unsetMark(*Cgm, markDart);     
      G->unsetMark(*Cgm, markVolume);
    }
  G->freeMark(markDart);
  G->freeMark(markVolume);


}



/******************************************************************************
 *  Fonction : void TopologicView::Darts_Draw()                              *
 *----------------------------------------------------------------------------*
 *  Cette fonction parcourt la G-carte en affichant les sommets correspondants*
 * aux différents brins.                                                      *
 *                                                                            *
 *****************************************************************************/

void Topologic_View::Darts_Draw()
{
  CDart * dgm;
  CAttribute * alpha;
  CVertex * p;

  // Parcourt des brins de la G-carte.
  CDynamicCoverageAll Cgm(G);
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    {
      dgm = *Cgm;

      // Coordonnées du sommet à visualiser.
      alpha = G->getAttribute(dgm, ORBIT_SELF, VERTEX_ATTRIBUTE_ID);
      p =(CAttributeVertex*)alpha;

      // Affichage du sommet.
      glBegin(GL_POINTS);
      //glColor3f(1.0, 1.0, 0.0);
      glVertex3f(p->getX(), p->getY(), p->getZ());
      glEnd();
    }

}



/******************************************************************************
 *  Fonction : void TopologicView::Alpha_Draw(int i)                         *
 *----------------------------------------------------------------------------*
 *  Cette fonction parcourt la G-carte en affichant les liaisons alpha i      *
 * existantes entre les différents brins.                                     *
 *                                                                            *
 *****************************************************************************/

void Topologic_View::Alpha_Draw(int i)
{
  CDart * dgm;
  CAttribute * alpha;
  CVertex * p,* p1;

  // Création d'une marque.
  int markDart = G->getNewMark();

  // Parcourt des brins de la G-carte.
  CDynamicCoverageAll Cgm(G);
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    {
      dgm = *Cgm;

      if (!G->isMarked(dgm, markDart))
        {
          // Cas où le brin est relié à un autre brin par la relation alpha0
          // et où cet autre brin n'alpha pas déjà été traité.
          if (!G->isFree(dgm,i) &&
              !G->isMarked(G->alpha(dgm,i), markDart))
            {
              // Coordonnées du sommet correspondant au brin "dgm".
              alpha = G->getAttribute(dgm, ORBIT_SELF, VERTEX_ATTRIBUTE_ID);
              p =(CAttributeVertex*)alpha;
        
              // Coordonnées du sommet correspondant à l'autre brin.
              alpha = G->getAttribute(G->alpha(dgm,i), ORBIT_SELF,
                                   VERTEX_ATTRIBUTE_ID);
              p1 = (CAttributeVertex*)alpha;
        
              // Affichage de la liaison alpha0.
              //glColor3f(1.0, 0.0, 0.0);
              glBegin(GL_LINES);
              glVertex3f(p->getX(), p->getY(), p->getZ());
              glVertex3f(p1->getX(), p1->getY(), p1->getZ());
              glEnd();

              // Marquage du brin avec la marque markDart.
              G->setMark(G->alpha(dgm,i), markDart);
            }

          // Marquage du brin avec la marque markDart.
          G->setMark(dgm, markDart);
        }
    }

  // Démarquage des brins et libération de la marque.
  for (Cgm.reinit(); Cgm.cont(); Cgm++)
    G->unsetMark(*Cgm, markDart);
  G->freeMark(markDart);

}

---