AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

DeformableOctreeNode.cpp

Go to the documentation of this file.

/***************************************************************************
                          deformableOctreeNode.cpp  -  description
                             -------------------
    begin                : Tue Mar 23 2004
    copyright            : (C) 2004 by Mathieu Coquerelle
    email                : mathieu.coquerelle@imag.fr
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#include "DeformableOctreeNode.h"
#include "OctreeODEEngine.h"

#include <X3DTK/kernel.h>
#include <X3DTK/private/X3D_Coordinate.h>

#include <GL/glut.h>
#include "ConstrainedVertex.h"
#include "SFVec3fCellConstrained.h"

#include "assertions.h"
#include <animal/X3DTK/Qt/mainControllerGUI/MainController.h>

#include "DeformableOctreeShapeNode.h"

#include "ManipulatedMeshVertex.h"

#include <X3DTK/private/SFVec3f.h>
#include <animal/picking.h>
#include <animal/X3DTK/linearX3DTK.h>

#include <iostream>
using std::cerr;
using std::endl;





namespace X3DTK
{

  namespace X3D
  {

    void drawLeaf( Cell *cell );
    void drawCell( Cell *cell );


    DeformableOctreeNode::DeformableOctreeNode() :
        _dosn(NULL)
    {
      // Defines the tag of the node. This string must be the same than the one
      // entered for the creation function, otherwise the node won't be loaded.
      // Node
      define(Recorder<DeformableOctreeNode>::getTypeName("DeformableOctreeNode"));
      // Attributes
      define(Recorder<DeformableOctreeNode, SFString>::getAttribute("engine", &DeformableOctreeNode::_engineType, SFString()));

      _octree = NULL;
      _selectedCell = NULL;
      _selectedVertexId = 0;
      _selectionId = 0;

      initOptions();

    }

    DeformableOctreeNode::~DeformableOctreeNode()
    {
      //removeParentFromChild(this, _coordinate);
      delete _octree;
    }

    void DeformableOctreeNode::declareOutputs( X3D_X3DNodeList& )
    {}

    void DeformableOctreeNode::animate( float dt )
    {
      //assert( _octree );
      if( animal::octree::OctreeEngine* engine = dynamic_cast<animal::octree::OctreeEngine*>(_octree) )
      {
        engine->move(dt);
      }
    }

    void DeformableOctreeNode::postAnimate( float dt )
    {
      if( animal::octree::OctreeEngine* engine = dynamic_cast<animal::octree::OctreeEngine*>(_octree) )
      {
        engine->postMove(dt);
      }
    }

    void DeformableOctreeNode::setDeformableOctreeShapeNode( DeformableOctreeShapeNode *dosn)
    {
      _dosn = dosn;
      createOctree();
      if( _octree )
      {
        _dosn->setOctree( _octree );
      }
    }

    void DeformableOctreeNode::getBoundingBox( float & minX, float & minY, float & minZ, float & maxX, float & maxY, float & maxZ)
    {
      if( _octree != NULL )
      {
        Cell *cell = _octree->root();
        Vec3d min = cell->vertex(0)->getPosition();
        Vec3d max = min;
        for( unsigned short i=1 ; i<8 ; ++i )
        {
          Vec3d pos = cell->vertex(i)->getPosition();

          if( pos[0] < min[0] )
            min[0] = pos[0];
          if( pos[0] > max[0] )
            max[0] = pos[0];

          if( pos[1] < min[1] )
            min[1] = pos[1];
          if( pos[1] > max[1] )
            max[1] = pos[1];

          if( pos[2] < min[2] )
            min[2] = pos[2];
          if( pos[2] > max[2] )
            max[2] = pos[2];
        }
        minX = min[0];
        minY = min[1];
        minZ = min[2];
        maxX = max[0];
        maxY = max[1];
        maxZ = max[2];
      }

    }

    void DeformableOctreeNode::updateBoundingBox()
    {
      float xmin, ymin, zmin, xmax, ymax, zmax;
      getBoundingBox(xmin, ymin, zmin, xmax, ymax, zmax);
      setBBoxCenter( SFVec3f( (xmin+xmax)/2, (ymin+ymax)/2, (zmin+zmax)/2 ) );
      setBBoxSize( SFVec3f( (xmax-xmin), (ymax-ymin), (zmax-zmin) ) );
    }








    void DeformableOctreeNode::createOctree()
    {
      std::cerr << "DeformableOctreeNode::createOctree()\n";

      X3D::Coordinate * coord = _dosn->getCoordinate();

      // get the coordinates
      /*
      std::cerr << "My shape " << _x3dshape->getTypeName() << "\n";
      MFNode childList = _x3dshape->getChildList();
      for( MFNode::iterator it=childList.begin() ; it != childList.end() ; ++it )
      {
        std::cerr << "My child is " << (*it)->getTypeName() << "\n";
        if( dynamic_cast<Coordinate *>(*it) != 0 )
        {
            // Should be a class Coordinate
            coord = static_cast<Coordinate*> (*it);
        }
      }
      */

      if (!coord)
      {
        std::cerr<< "Warning: impossible to init the octree. In the file .x3d, there is no Coordinate child of the ShapeNode."<< std::endl;
        return;
      }
      if ( coord->getPoint().size() == 0)
      {
        std::cerr << "Warning: no vertex in the mesh !\n";
        return;
      }



      //std::cerr << "createOctree() : there are " << coord->getPoint().size() << " vertices in the mesh\n";
      // Get the points
      const MFVec3f * pointsTmp = &(coord->getPoint());
      MFVec3f * points = const_cast<MFVec3f *>(pointsTmp);

      Vec3d minVec, maxVec;
      minVec.x = (*points)[0].x;
      maxVec.x = (*points)[0].x;
      minVec.y = (*points)[0].y;
      maxVec.y = (*points)[0].y;
      minVec.z = (*points)[0].z;
      maxVec.z = (*points)[0].z;

      for( unsigned int i=0 ; i< points->size() ; ++i )
      {
        SFVec3f p = (*points)[i];

        if( p.x < minVec.x )
          minVec.x = p.x;
        if( p.y < minVec.y )
          minVec.y = p.y;
        if( p.z < minVec.z )
          minVec.z = p.z;

        if( p.x > maxVec.x )
          maxVec.x = p.x;
        if( p.y > maxVec.y )
          maxVec.y = p.y;
        if( p.z > maxVec.z )
          maxVec.z = p.z;
      }



      Vec3d sizeVec = maxVec - minVec;

      // Give the octree a little larger BBox so that every points are SURE to be inside
      minVec -= sizeVec/100.0;
      maxVec += sizeVec/100.0;

      minVec.z -= 0.5;
      maxVec.z += 1;

      sizeVec = maxVec - minVec;

      MFVec3f normals = _dosn->computeNormals();


    if( _engineType == string("engine") )
    {
        cerr<<"DeformableOctreeNode::createOctree create a basic engine octree"<<endl;
        _octree = new OctreeEngine( minVec, maxVec, points, normals, 10000 );
    }
//     else if( _engineType == string("physical") )
//     {
//         cerr<<"DeformableOctreeNode::createOctree create a physical octree"<<endl;
//         _octree = new OctreeODEEngine( minVec, maxVec, points, normals, 10000 );
//     }
    else
    {
        cerr<<"DeformableOctreeNode::createOctree create default octree"<<endl;
        _octree = new Octree( minVec, maxVec, points, normals, 10000 );
      }
      _selectedCell = _octree->root();
    }

    void DeformableOctreeNode::postInit()
    {
      // std::cerr << "DON::postInit\n";
      //glEnable( GL_COLOR_MATERIAL );
      //glColorMaterial( GL_FRONT_AND_BACK,  GL_SPECULAR );

      MFNode children = getChildList();

      for( MFNode::iterator it = children.begin() ; it != children.end() ; ++it )
      {
        std::cerr << "\tGot one child : " << (*it)->getName() << "\n";

        if( DeformableOctreeShapeNode *tmpNode =dynamic_cast<DeformableOctreeShapeNode *>(*it) )
        {
          Require( !_dosn );

          // anciennes verifications
          /*
          if(_dosn)
            return false;
          */

          // Find a Coordinate Node if any
          if( !tmpNode->getCoordinate() )
          {
            std::cerr << "DON::init : can't get coordinates from DOSN\n";
          }

          setDeformableOctreeShapeNode( tmpNode );
        }
      }

      if( animal::octree::OctreeEngine* engine = dynamic_cast<animal::octree::OctreeEngine*>(_octree) )
      {
        engine->init();
      }



    }



    void DeformableOctreeNode::draw()
    {
      //std::cerr << "Drawing octree\n";

      if( _dosn )
      {
        _dosn->draw();

        glPushAttrib( GL_ALL_ATTRIB_BITS );

        glDisable( GL_LIGHTING );
        glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
        glEnable (GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);


        if( _drawOctree )
        {
          drawCells( _octree->root() );
          drawOctreeVertices();
        }


        if( _drawSelection )
        {
          drawSelection();
        }

        if( _drawFrames )
        {
          drawFrames( getSelectedCell() );
        }


        if( getOptionDrawSelectedCellsPoints() )
        {
          drawCellsPoints( getSelectedCell() );
        }

        if( getOptionDrawNeighbours() )
        {
          drawNeighbours( getSelectedCell() );
        }


        glPopAttrib();
      }

    }




    void DeformableOctreeNode::drawNeighbours( Cell *cell )
    {
      std::cerr << "void DeformableOctreeNode::drawNeighbours( Cell *" << *cell << " )\n";
      Require( cell );

      glColor4f( 0.0, 0.0, 1.0, 0.2 );
      for( unsigned int i=0 ; i<6 ; ++i )
      {
        if( cell->getNeighbour(i) )
        {
          std::cerr << "Drawing neighbour for " << i << "\n";
          drawLeaf( cell->getNeighbour(i) );
        }
      }
    }

    void DeformableOctreeNode::drawOctreeVertices()
    {
      Cell::vertex_iterator it( _octree->root() );

      ConstrainedVertex *cv;
      while( !it.empty() )
      {
        cv = ++it;
        if( cv->isFree() )
        {
          glColor4f( 0.0, 1.0, 0.0, 1.0 );
        }
        else
        {
          glColor4f( 1.0, 0.0, 0.0, 1.0 );
        }
        drawVertex( cv, this->getToolsSize(), 10 );
      }
    }

    void DeformableOctreeNode::drawVertex( OctreeVertex *vertex, float size, unsigned int details )
    {
      glPushMatrix();
      Vec3d v = vertex->getPosition();

      glTranslatef( v[0], v[1], v[2] );
      glutSolidSphere( size, details, details );

      glPopMatrix();
    }


    void DeformableOctreeNode::drawCells( Cell *cell )
    {
      for( Octree::dfs_iterator it( cell, isLeaf, NULL, drawCell ) ; !it.empty() ; ++it )
        ;
    }





    void DeformableOctreeNode::drawSelection()
    {
      //
      // Some fuzzy stuff
      //
      static float minColor = 0.0;
      static float maxColor = 0.5;
      static float curColor = 0.0;
      static float stepColor = 0.015;

      glLineWidth( 5 );
      glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
      glColor4f( 1.0 , 1.0, 1.0, curColor );
      drawLeaf( getSelectedCell() );

      glEnable( GL_CULL_FACE );
      glColor4f( 1.0, 1.0, 1.0, curColor+maxColor );
      drawVertex( getSelectedVertex(), getToolsSize(), 30 );
      glDisable( GL_CULL_FACE );

      if( curColor >= maxColor )
      {
        curColor = maxColor;
        stepColor *= -1;
        curColor += stepColor;
      }
      else if( curColor <= minColor )
      {
        curColor = minColor;
        stepColor *= -1;
        curColor += stepColor;
      }
      else
      {
        curColor += stepColor;
      }

      //CellInfluenceData cid = getSelectedCell()->getData()._influence;
      /*
      // Then draw the vertices influencing this vertex
      for( unsigned int i=0 ; i<cid.influenceMaps.size() ; ++i )
      {
        Vec3d w = cid.influenceMaps[i][getSelectedVertex()];
        Vec3d pos = cid.vertices[i]->getFrame().getOrigin();
        
        glPushMatrix();
        glTranslatef( pos.x, pos.y, pos.z );
        glColor4f( 1.0, 0.0, 0.0, 1.0 );
        //glScalef( w[0], w[1], w[2] );
        //glutSolidSphere( 1.0, 10, 10 );
        glutSolidSphere( (1.0-w[0])*(1.0-w[1])*(1.0-w[2])/3.0, 10, 10 );
        glPopMatrix();      
      }
      */
      /*
       // Show the vertices and influences depending on the current vertex
      for( TempOctree::dfs_iterator it( _octree->root() ) ; !it.empty() ;)
      {
        Cell * cell = ++it;
        
        if( cell->isLeaf() )
        {
            CellInfluenceData cid = cell->getData()._influence;

            int vertexId = -1;
            for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
            {
                if( cid.vertices[i] == getSelectedVertex() )
                {
                    vertexId = i;
                }
            }

            if( vertexId != -1 )
            {
                for( unsigned int i=0 ; i<8 ; ++i )
                {
                    //std::cerr << "\t++it";
                    ConstrainedVertex *cv = cell->vertex(i);

                    if( cid.influenceMaps[vertexId].find(cv) != cid.influenceMaps[vertexId].end() )
                    {
                        //std::cerr << " : ok got one";
                        Vec3d w = cid.influenceMaps[vertexId][cv];
                        Vec3d pos = cv->getPosition();

                        glEnable( GL_LIGHTING );
                        glPushMatrix();
                        glTranslatef( pos.x, pos.y, pos.z );
                        glColor4f( 0.0, 1.0, 0.0, 1.0 );
                        glScalef( 2.0-w[0], 2.0-w[1], 2.0-w[2] );
                        glutSolidSphere( 1.0/10.0, 20, 20 );
                        //glutSolidSphere( (1.0-w[0])*(1.0-w[1])*(1.0-w[2])/3.0, 10, 10 );
                        glPopMatrix();      
                    }
                    //std::cerr << "\n";

                }
        //std::cerr << "end\n";     
            }
        }
      }
      */

    }

    /*
    void DeformableOctreeNode::drawFrame( Cell *cell, unsigned int vId )
    {
        
        Frame f = cell->vertex(vId)->getFrame();
        Vec3d v = f.getOrigin();
                
        
        glColor4f( 0.0, 1.0, 1.0, 1.0 );
        drawVector(v,v+f.getVector(0));
     
        // y vectors
        glColor4f( 1.0, 0.0, 1.0, 1.0 );
        drawVector(v,v+f.getVector(1));
        
        // z vectors
        glColor4f( 1.0, 1.0, 0.0, 1.0 );
        drawVector(v,v+f.getVector(2));
    }
    */


    void DeformableOctreeNode::drawFrame( Frame f )
    {
      Vec3d v = f.getOrigin();

      glColor4f( 0.0, 1.0, 1.0, 1.0 );
      drawVector(v,v+f.getVector(0));

      // y vectors
      glColor4f( 1.0, 0.0, 1.0, 1.0 );
      drawVector(v,v+f.getVector(1));

      // z vectors
      glColor4f( 1.0, 1.0, 0.0, 1.0 );
      drawVector(v,v+f.getVector(2));
    }


    void DeformableOctreeNode::drawFrames( Cell *cell )
    {
      for( unsigned int i=0 ; i<8 ; ++i )
      {
        drawFrame( cell->vertex(i)->getFrame() );
      }
    }

    void DeformableOctreeNode::drawVector( Vec3d p1, Vec3d p2 )
    {
      glLineWidth(10);
      glBegin( GL_LINES );
      glVertex3fv( p1 );
      glVertex3fv( p2 );
      glEnd();
      glLineWidth(1);
    }





    void DeformableOctreeNode::drawCellsPoints( Cell *cell )
    {

      if( cell->isLeaf() )
      {
        //
        // This was used to shaw some debug information
        //
        if( (cell == getSelectedCell()) && cell->getData()._points.size() != 0 )
        {
          SFVec3fCellConstrained *point = cell->getData()._points[ _selectionId%(cell->getData()._points.size()) ];
          SFVec3f v = *(point->getSFVec3f());

          glPointSize( 10 );
          glColor4f( 1.0, 0.0, 0.0, 1.0 );

          glBegin( GL_POINTS );
          glVertex3f( v.x, v.y, v.z );
          glEnd();



          CellInfluenceData cid = cell->getData()._influence;


          for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
          {
            Vec3d pos = cid.vertices[i]->getFrame().computePosition( point->getRelativePosition(cid.vertices[i]) );

            glColor4f( (i+1)/(float)cid.vertices.size(), 1.0-(i+1)/(float)cid.vertices.size(), 1.0, 1.0 );
            glPushMatrix();
            glTranslatef( pos.x, pos.y, pos.z );
            glutSolidSphere( point->getRelativeWeight( cid.vertices[i] ), 10, 10 );
            glPopMatrix();

            drawVector( cid.vertices[i]->getPosition(), pos );
            drawFrame( cid.vertices[i]->getFrame() );
          }

          /*
          //std::cerr << "There are " << cid.vertices.size() << " vertices\n";
          FloatingPointType sumW = 0.0;
          for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
          {
            sumW += point->getRelativeWeight( cid.vertices[i] );
          }

          // Scaling factor...
          sumW *= 3;
                    
          for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
          {
            drawFrame( cid.vertices[i]->getFrame() );
            
            Vec3d pos = cid.vertices[i]->getFrame().computePosition( point->getRelativePosition(cid.vertices[i]) );
            
            glColor4f( 0.0, 1.0, 1.0, 1.0 );
            glBegin( GL_POINTS );
            glVertex3f( pos.x, pos.y, pos.z );
            glEnd();
            
            pos = cid.vertices[i]->getFrame().getOrigin();
            glPushMatrix();
            glTranslatef( pos.x, pos.y, pos.z );
            glColor4f( 0.0, 0.0, 1.0, 1.0 );
            glutSolidSphere( point->getRelativeWeight( cid.vertices[i] )/sumW, 10, 10 );
            glPopMatrix();
          } 

          Vec3d vRes;
          FloatingPointType wSum = 0.0;
          for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
          {
            //vRes += weights[i] * Ps[i];
            //wSum += weights[i];
            
            FloatingPointType w = getParameter( cid.vertices[i] );
            //std::cerr << "W is " << w << "\n";
            vRes += Ps[i] * w;
            wSum += w;
            
          }

          */
        }

        OctreeDataPoints *points = &(cell->getData()._points);

        glPointSize( 5 );
        glColor4f( 1.0, 0.0, 0.0, 1.0 );
        glBegin( GL_POINTS );
        for( OctreeDataPoints::iterator it = points->begin() ; it != points->end() ; ++it )
        {
          SFVec3f v = *(*it)->getSFVec3f();
          glVertex3f( v.x, v.y, v.z );
        }

        glEnd();
      }
      else
      {
        for( unsigned int i=0 ; i<8 ; ++i )
          drawCellsPoints( cell->child(i) );
      }
    }







    void testEnterCell(Cell* cell)
    {
      for( unsigned int i=0 ; i<cell->getData()._depth ; ++i )
      {
        fputc( '\t', stderr );
      }
      std::cerr << "entering cell : " << *cell << " (depth = " << cell->getData()._depth << ")\n";
    }

    void testLeaveCell(Cell* cell)
    {
      for( unsigned int i=0 ; i<cell->getData()._depth ; ++i )
      {
        fputc( '\t', stderr );
      }
      std::cerr << "leaving cell : " << *cell << " (depth = " << cell->getData()._depth << "\n";
    }



    void DeformableOctreeNode::slotButtonTest()
    {
      _selectionId++;
      /*
        
        std::cerr << "DeformableOctreeNode::slotButtonTest() : exiting\n";
        exit(0);
        std::cerr << "Test button\n";
        if( _octree->root()->isLeaf() )
        {
            std::cerr << "isLeaf()\n";
        }
        TempOctree::dfs_iterator it( _octree->root(), NULL, testEnterCell, testLeaveCell );
        while(!it.empty())
        {
            ++it;
        }
        std::cerr << "Test button end\n";
        */
    }





    void DeformableOctreeNode::slotSubdivide()
    {
      _octree->subdivideRecDeformed( getSelectedCell() );
      updateGL();
    }
    void DeformableOctreeNode::slotSimplify()
    {
      _octree->simplify(getSelectedCell());
      updateGL();
    }


    void DeformableOctreeNode::slotMoveXPlus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[0] += _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll( v, getSelectedCell()->getData()._depth );
      //getSelectedVertex()->moveIndependent( v );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }
    void DeformableOctreeNode::slotMoveXMinus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[0] -= _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll
      ( v, getSelectedCell()->getData()._depth );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }


    void DeformableOctreeNode::slotMoveYPlus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[1] += _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll
      ( v, getSelectedCell()->getData()._depth );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }
    void DeformableOctreeNode::slotMoveYMinus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[1] -= _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll
      ( v, getSelectedCell()->getData()._depth );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }
    void DeformableOctreeNode::slotMoveZPlus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[2] += _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll
      ( v, getSelectedCell()->getData()._depth );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }
    void DeformableOctreeNode::slotMoveZMinus()
    {
      Vec3d v = getSelectedVertex()->getPosition();
      v[2] -= _toolsSize;
      getSelectedVertex()->setPositionAndPropagateAll
      ( v, getSelectedCell()->getData()._depth );

      _octree->movedRecLeaves(_octree->root() );

      updateGL();
    }


    void DeformableOctreeNode::slotCycleCell()
    {
      if( !_selectedCell->isRoot() )
        // Has a father, not root cell
      {
        _selectedCell = _selectedCell->father()->child( (_selectedCell->fatherPos()+1)%8 );
        std::cerr << "This cell (" << *(getSelectedCell()) << ")  has " << getSelectedCell()->getData()._points.size() << " points\n";
        updateGL();
      }
    }

    void DeformableOctreeNode::slotCyclePoint()
    {
      _selectedVertexId = (_selectedVertexId+1)%8;
      std::cerr << "\tHaving vertex " << _selectedVertexId << "\n";
      updateGL();
    }

    void DeformableOctreeNode::slotGoFather()
    {
      if( !_selectedCell->isRoot() )
      {
        _selectedCell = _selectedCell->father();
        std::cerr << "This cell (" << *(getSelectedCell()) << ") has " << getSelectedCell()->getData()._points.size() << " points\n";
        updateGL();
      }
    }

    void DeformableOctreeNode::slotGoChild()
    {
      if( !_selectedCell->isLeaf() )
      {
        _selectedCell = _selectedCell->child(0);
        std::cerr << "This cell (" << *(getSelectedCell()) << ")  has " << getSelectedCell()->getData()._points.size() << " points\n";
        updateGL();
      }
    }

    void DeformableOctreeNode::updateGL()
    {
      //getMainController()->getViewer()->updateGL();
      //            getMainController()->display();
      //          this->draw();
      //          _coordinate->draw();
    }


    OctreeVertex* DeformableOctreeNode::getSelectedVertex()
    {
      return _selectedCell->vertex(_selectedVertexId);
    }
    Cell* DeformableOctreeNode::getSelectedCell()
    {
      return _selectedCell;
    }







    void DeformableOctreeNode::initOptions()
    {
      _drawEmptyCells = false;
      _drawOctree = false;
      _drawSelection = false;
      _drawSelectedCellsPoints = false;
      _drawFrames = false;
      _drawNeighbours = false;
    }

    // Options
    void DeformableOctreeNode::slotSetDrawEmptyCells(bool b)
    {
      _drawEmptyCells = b;
      updateGL();
    }
    bool DeformableOctreeNode::getOptionDrawEmptyCells()
    {
      return _drawEmptyCells;
    }

    void DeformableOctreeNode::slotSetDrawOctree(bool b)
    {
      _drawOctree = b;
      updateGL();
    }
    bool DeformableOctreeNode::getOptionDrawOctree()
    {
      return _drawOctree;
    }

    void DeformableOctreeNode::slotSetDrawSelection(bool b)
    {
      _drawSelection = b;
      updateGL();
    }
    bool DeformableOctreeNode::getOptionDrawSelection()
    {
      return _drawSelection;
    }

    void DeformableOctreeNode::slotSetNMaxPointsPerCell( unsigned int n )
    {
      _octree->setNMaxPointsPerCell(n);
      //_octree->structureChangedRecLeaves();
      updateGL();
    }
    unsigned int DeformableOctreeNode::getOptionNMaxPointsPerCell( )
    {
      return _octree->getNMaxPointsPerCell();
    }

    void DeformableOctreeNode::slotSetDrawSelectedCellsPoints(bool b)
    {
      _drawSelectedCellsPoints = b;
      updateGL();
    }
    bool DeformableOctreeNode::getOptionDrawSelectedCellsPoints()
    {
      return _drawSelectedCellsPoints;
    }

    void DeformableOctreeNode::slotSetInterpolationMethod( int index )
    {
      _octree->setPositionMethod( index );
      _octree->movedRecLeaves( _octree->root() );
      updateGL();
    }

    void DeformableOctreeNode::slotChangeToolsSize( int size )
    {
      _toolsSize = 10e-4 * pow(10,size/10) * ((size%10) + 1);
    }

    FloatingPointType DeformableOctreeNode::getToolsSize()
    {
      return _toolsSize;
    }


    void DeformableOctreeNode::slotSetDrawNeighbours(bool b)
    {
      _drawNeighbours = b;
      updateGL();
    }
    bool DeformableOctreeNode::getOptionDrawNeighbours() const
    {
      return _drawNeighbours;
    }










    void DeformableOctreeNode::slotButtonDirectManipulation( )
    {
      //exit(0);

      Cell *cell = getSelectedCell();

      SFVec3fCellConstrained *point = cell->getData()._points[ _selectionId%(cell->getData()._points.size()) ];
      SFVec3f *v = point->getSFVec3f();
      Vec3d pos(v->x,v->y,v->z);

      Vec3d delta( getToolsSize(), -getToolsSize(), 2*getToolsSize() );

      std::cerr << "DON : " << delta << "\n";

      _octree->directManipulation( point, pos + delta );
      _octree->movedRecLeaves(_octree->root() );
      updateGL();
    }



    animal::ConstrainedItem* DeformableOctreeNode::pickPoint( float* origin, float* direction, float threshold )
    {
      //std::cerr << "DeformableOctreeNode::pickPoint()\n";

      if( _dosn )
      {
        X3D::Coordinate* coord = _dosn->getCoordinate();

        int index;
        float distance;
        SFVec3f lineOrigin(origin[0], origin[1], origin[2]);
        SFVec3f lineDirection(direction[0],direction[1],direction[2]);
        //cout<<"ParticleSystemNode::pickPoint"<<endl;

        if( animal::findClosestPointToLine( index, distance, coord->getPoint(), lineOrigin, lineDirection, threshold ) )
        {
          ManipulatedMeshVertex* c = new ManipulatedMeshVertex( this, &coord->getPoint()[index]);
          return c;
        }
        else
        {
          return NULL;
        }
      }
      else
      {
        return NULL;
      }

    }





    void drawCell( Cell *cell )
    {
      Require( cell != NULL );

      if( cell->isLeaf() )
      {
        if( cell->getData()._points.size() != 0 )
        {
          glColor4f(0.0,0.0,1.0,1.0);
          drawLeaf( cell );
        }
        else
        {
          glColor4f(1.0,1.0,0.0,1.0);
          drawLeaf( cell );
        }
        /*
        else if( DeformableOctreeNode::_drawEmptyCells )
        {
            Require( cell->getData()._points.size()  == 0 );
            glColor4f(1.0,1.0,0.0,1.0);
            drawLeaf( cell );
        }
        */
      }
    }

    void drawLeaf( Cell *cell )
    {
      glBegin( GL_QUADS );
      for( unsigned short f=0 ; f<6 ; ++f )
      {
        for( unsigned short i=0 ; i<4 ; ++i )
        {
          glVertex3fv( (cell->vertex(X3DTK::X3D::Octree::faceVertices[f][i])->getPosition()) );
        }
      }
      glEnd();
    }



  }//X3D
}//X3DTK

---