MeshFromPoints.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

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

template <typename TPoint>
inline
DGtal::MeshFromPoints<TPoint>::MeshFromPoints(bool saveFaceColor)
{
  mySaveFaceColor=saveFaceColor;
  myDefaultColor = DGtal::Color::White;
}

template <typename TPoint>
inline
DGtal::MeshFromPoints<TPoint>::MeshFromPoints(const DGtal::Color &aColor)
{
  mySaveFaceColor=false;
  myDefaultColor = aColor;
}

template <typename TPoint>
inline
DGtal::MeshFromPoints<TPoint>::~MeshFromPoints()
{
}

// Interface - public :

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

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




// Implementation of inline functions                                        //

    





template<typename TPoint>
inline
DGtal::MeshFromPoints<TPoint>::MeshFromPoints(const vector<TPoint> &vertexSet)
{
  mySaveFaceColor=false;
  for(int i =0; i< vertexSet.size(); i++){
    myVertexList.push_back(vertexSet.at(i));
  }

}    



template<typename TPoint>
inline
void
DGtal::MeshFromPoints<TPoint>::addVertex(const TPoint &point)
{
  myVertexList.push_back(point);
}    



template<typename TPoint>
inline
void
DGtal::MeshFromPoints<TPoint>::addTriangularFace(unsigned int indexVertex1, unsigned int indexVertex2, 
                                                 unsigned int indexVertex3, const DGtal::Color &aColor)
{
  MeshFace aFace;
  aFace.push_back(indexVertex1);
  aFace.push_back(indexVertex2);
  aFace.push_back(indexVertex3);
  myFaceList.push_back(aFace);
  if(mySaveFaceColor){
    myFaceColorList.push_back(aColor);
  }
}    




template<typename TPoint>
inline
void
DGtal::MeshFromPoints<TPoint>::addQuadFace(unsigned int indexVertex1, unsigned int indexVertex2, 
                                           unsigned int indexVertex3, unsigned int indexVertex4, 
                                           const DGtal::Color &aColor)
{
  MeshFace aFace;
  aFace.push_back(indexVertex1);
  aFace.push_back(indexVertex2);
  aFace.push_back(indexVertex3);
  aFace.push_back(indexVertex4);
  myFaceList.push_back(aFace);
  if(mySaveFaceColor){
    myFaceColorList.push_back(aColor);
  }
}    



template<typename TPoint>
inline
void 
DGtal::MeshFromPoints<TPoint>::addFace(const MeshFace &aFace,  const DGtal::Color &aColor){
  myFaceList.push_back(aFace);
  if(mySaveFaceColor){
    myFaceColorList.push_back(aColor);
  }


}


template<typename TPoint>
inline
const TPoint &
DGtal::MeshFromPoints<TPoint>::getVertex(unsigned int i) const 
{
  return myVertexList.at(i);
}    



template<typename TPoint>
inline
const typename  DGtal::MeshFromPoints<TPoint>::MeshFace & 
DGtal::MeshFromPoints<TPoint>::getFace(unsigned int i) const
{
  return myFaceList.at(i);
}    


template<typename TPoint>
inline
unsigned int 
DGtal::MeshFromPoints<TPoint>::nbFaces() const
{
  return myFaceList.size();
}

template<typename TPoint>
inline
unsigned int 
DGtal::MeshFromPoints<TPoint>::nbVertex() const
{
  return myVertexList.size();
}

template<typename TPoint>
inline
const DGtal::Color & 
DGtal::MeshFromPoints<TPoint>::getFaceColor(unsigned int i) const{
  if(mySaveFaceColor){
    return myFaceColorList.at(i);
  }else{
    return myDefaultColor;
  }
}




template<typename TPoint> 
inline     
void 
DGtal::MeshFromPoints<TPoint>::invertVertexFaceOrder(){
  for(unsigned int i=0; i<myFaceList.size(); i++){
    vector<unsigned int> & aFace =  myFaceList.at(i);
    for(unsigned int j=0; j < aFace.size()/2; j++){
      unsigned int tmp=aFace.at(j);
      aFace.at(j)=aFace.at(aFace.size()-1-j);
      aFace.at(aFace.size()-1-j)=tmp;
    }
  }
}

    

//------------------------------------------------------------------------------
template<typename TPoint>
inline
std::string
DGtal::MeshFromPoints<TPoint>::className() const
{
  return "MeshFromPoints";
}





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

//                                                                           //