DGtalInventor.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template <typename TSpace>
inline
DGtal::DGtalInventor<TSpace>::~DGtalInventor()
{
}

template <typename TSpace>
inline
DGtal::DGtalInventor<TSpace>::DGtalInventor()
  : myLattice()
{
  myLattice.init( Space::dimension, 3 );
}

template <typename TSpace>
inline
std::string
DGtal::DGtalInventor<TSpace>::getMode( const std::string & objectName ) const
{
  ModeMapping::const_iterator itm = myModes.find( objectName );
  return itm == myModes.end() ? "" : itm->second;
}

template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::setLattice( const Lattice<Space> & l )
{
  ASSERT( l.n() == Space::dimension );
  myLattice = l;
}


template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::clear()
{
  myCells[ 0 ].clear();
  myCells[ 1 ].clear();
  myCells[ 2 ].clear();
  myNormals.clear();
  myColors.clear();
}

template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::setDiffuseColor( const float* color )
{
  myDiffuseColor = Color( color );
}

template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::setDiffuseColor( const Color & color )
{
  myDiffuseColor = color;
}

template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::drawCell
( const Point & c, bool orient, const float* n )
{
  // while cells are "volumic", extracts their boundary.
  Dimension cdim = 0;
  for ( typename Point::ConstIterator it = c.begin(); it != c.end(); ++it )
    if ( *it & 0x1 ) ++cdim;
  if ( cdim > 2 )
    {
      Point p( c );
      for ( typename Point::Iterator it = p.begin(); it != p.end(); ++it )
  if ( *it & 0x1 )
    {
      --(*it);
      drawCell( p, false, n );
      *it += 2;
      drawCell( p, true, n );
      --(*it);
    }
    }
  else
    {
      myCells[ cdim ].insert( std::make_pair( c, orient ) );
      myColors[ c ] = myDiffuseColor;
      if ( n != 0 )  myNormals[ c ] = n;
    }
}

template <typename TSpace>
inline
void 
DGtal::DGtalInventor<TSpace>::drawPoint( const Point & c, const float* n )
{
  Point q;
  for ( Dimension i = 0; i < c.dimension; ++i )
    q[ i ] = 2*c[ i ] + 1;
  drawCell( q, n );
}

// Interface - public :

template <typename TSpace>
inline
void
DGtal::DGtalInventor<TSpace>::selfDisplay ( std::ostream & out ) const
{
  out << "[DGtalInventor]";
}

template <typename TSpace>
inline
bool
DGtal::DGtalInventor<TSpace>::isValid() const
{
    return true;
}


// Inventor methods


template <typename TSpace>
void
DGtal::DGtalInventor<TSpace>::generate( SoGroup* result ) const
{
  typedef float vec3[ 3 ];
  typedef DGtal::int32_t int32;
  typedef DGtal::uint32_t uint32;

  SoShapeHints *myShapeHints = new SoShapeHints;
  myShapeHints->vertexOrdering = SoShapeHints::UNKNOWN_ORDERING;//COUNTERCLOCKWISE; //UNKNOWN_ORDERING; //COUNTERCLOCKWISE;
  myShapeHints->shapeType = 
    false ? SoShapeHints::SOLID : SoShapeHints::UNKNOWN_SHAPE_TYPE;
  myShapeHints->faceType = SoShapeHints::CONVEX;
  myShapeHints->creaseAngle = 1.0;
  result->addChild( myShapeHints ); 

  // some initialization
  uint32 nb_vtx;  // number of vertices to display 
  uint32 nb_cells;  // number of cells
  vec3* coords; // array of vertex coordinates
  vec3* xyz;    // pointer to fill array [coords]
  SoCoordinate3 *myCoords; // structure to store coordinates
  typename CellSet::const_iterator ip;
  typename CellSet::const_iterator ip_end;
  int32* indices;// for each face, gives the number of vertices
  vec3* normals;// array of normal vectors
  vec3* colors; // array of color vectors
  typename ColorMapping::const_iterator itc;
  typename NormalMapping::const_iterator itn;
  int idx;
  
  // Taking care of 2-cells
  nb_cells = myCells[ 2 ].size();
  nb_vtx = 4 * nb_cells;
  if ( nb_vtx != 0 )
    {
      cout << "2-cells = " << nb_vtx << endl;
      SoGroup* node_squares = new SoGroup;
      myCoords = new SoCoordinate3;
      coords = new vec3[ nb_vtx ];
      ip = myCells[ 2 ].begin();
      ip_end = myCells[ 2 ].end();
      xyz = coords;
      indices = new int32[ nb_cells ];
      normals = new vec3[ nb_cells ];
      colors = new vec3[ nb_cells ];
      idx = 0;
      SbVec3f uv1;
      SbVec3f uv2;
      SbVec3f n;
      while ( ip != ip_end )
  {
    unsigned int d = 0;
    Point c = ip->first;
    bool orient = ip->second;
    Point e;
    Dimension dirs[ 2 ];
    for ( Dimension i = 0; i < c.dimension; ++i )
      {
        if ( c[ i ] & 0x1 ) 
    dirs[ d++ ] = i;
        e[ i ] = c[ i ] >> 1;
      }
    
    // creating face coordinates
    myLattice.immerse( e, *xyz );
    uv1.setValue( *xyz );
    uv2.setValue( *xyz );
    ++xyz;
    e[ dirs[ 0 ] ] ++;
    myLattice.immerse( e, *xyz );
    uv1 -= SbVec3f( *xyz );
    ++xyz;
    e[ dirs[ 1 ] ] ++;
    myLattice.immerse( e, *xyz );
    ++xyz;
    e[ dirs[ 0 ] ] --;
    myLattice.immerse( e, *xyz );
    uv2 -= SbVec3f( *xyz );
    ++xyz;
    indices[ idx ] = 4; 

    // retracts( xyz - 4, 4 );

    // Creating face normals
    itn = myNormals.find( c );
    n = uv1.cross( uv2 );
    if ( orient )
      {
        if ( n[ 0 ] < 0.0 ) n[ 0 ] = -n[ 0 ];
        if ( n[ 1 ] < 0.0 ) n[ 1 ] = -n[ 1 ];
        if ( n[ 2 ] < 0.0 ) n[ 2 ] = -n[ 2 ];
      }
    else
      {
        if ( n[ 0 ] > 0.0 ) n[ 0 ] = -n[ 0 ];
        if ( n[ 1 ] > 0.0 ) n[ 1 ] = -n[ 1 ];
        if ( n[ 2 ] > 0.0 ) n[ 2 ] = -n[ 2 ];
      }
    if ( itn != myNormals.end() )
      {
        n = itn->second;
        double dot = uv1[0]*n[0]+uv1[1]*n[1]+uv1[2]*n[2];
        if ( dot < 0.0 )
    {
      vec3* xyz1 = xyz - 3;
      vec3* xyz2 = xyz - 1;
      std::swap( (*xyz1)[0], (*xyz2)[0] );
      std::swap( (*xyz1)[1], (*xyz2)[1] );
      std::swap( (*xyz1)[2], (*xyz2)[2] );
    }
      }
    n.getValue( normals[ idx ][ 0 ], 
          normals[ idx ][ 1 ],
          normals[ idx ][ 2 ] );
    
    // Creating face colors
    itc = myColors.find( c );
    if ( itc != myColors.end() )
      n = itc->second;
    n.getValue( colors[ idx ][ 0 ], 
          colors[ idx ][ 1 ],
          colors[ idx ][ 2 ] );
    
    ++idx;
    ++ip;
  }
      // Coordinates
      myCoords->point.setValues( 0, nb_vtx, coords );
      node_squares->addChild( myCoords ); 

      // Normals
      SoNormal* iNormals = new SoNormal;
      iNormals->vector.setValues( 0, idx, normals );
      delete[] normals;
      node_squares->addChild( iNormals );
      SoNormalBinding *iNormalBinding = new SoNormalBinding;
      iNormalBinding->value = SoNormalBinding::PER_FACE; 
      // instead of SoNormalBinding::PER_VERTEX_INDEXED;
      node_squares->addChild( iNormalBinding );

      // Colors
      SoMaterial* iMaterials = new SoMaterial;
      iMaterials->diffuseColor.setValues( 0, idx, colors );
      delete[] colors;
      node_squares->addChild( iMaterials );
      SoMaterialBinding* iMaterialBinding = new SoMaterialBinding;
      iMaterialBinding->value = SoMaterialBinding::PER_FACE;
      node_squares->addChild( iMaterialBinding );

      // Faces
      SoFaceSet* face_set = new SoFaceSet;
      face_set->numVertices.setValues( 0, idx, indices );
      node_squares->addChild( face_set ); 
      result->addChild( node_squares );
      delete[] indices;
    }
}


// Implementation of inline functions                                        //

template <typename TSpace>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
      const DGtalInventor<TSpace> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //