surface.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_MATHS_SURFACE_H
#define BALL_MATHS_SURFACE_H

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

namespace BALL 
{

  template <typename T>
  class TSurface
  {
    public:

    BALL_CREATE(TSurface)

    

    class Triangle
    {
      public:
        Index v1;
        Index v2;
        Index v3;

        bool operator == (const Triangle& triangle) const 
        {
          return (v1 == triangle.v1) && (v2 == triangle.v2) && (v3 == triangle.v3);
        }


        bool operator != (const Triangle& triangle) const 
        {
          return !(v1 == triangle.v1) && (v2 == triangle.v2) && (v3 == triangle.v3);
        }
    };
      
    typedef TVector3<T> Vertex;

    typedef TVector3<T> Normal;


    TSurface();

    TSurface(const TSurface& surface);

    virtual ~TSurface();


    void set(const TSurface& surface);

    TSurface& operator = (const TSurface& surface);

    void get(TSurface& surface) const;

    void clear();

    void readMSMSFile(const String& vert_filename, const String& face_filename);


    float getArea() const;

    Size getNumberOfTriangles() const;
    
    Size getNumberOfVertices() const;

    Size getNumberOfNormals() const;

    Triangle& getTriangle(Position index);

    const Triangle& getTriangle(Position index) const;
      
    void clearTriangles();

    void resizeTriangles(Size size);

    void pushBackTriangle(const Triangle& triangle);

    Vertex& getVertex(Position index);

    const Vertex& getVertex(Position index) const;

    void clearVertices();

    void resizeVertices(Size size);

    void pushBackVertex(const Vertex& vertex);

    Normal& getNormal(Position index);

    const Normal& getNormal(Position index) const;

    void clearNormals();

    void resizeNormals(Size size);

    void pushBackNormal(const Normal& n);



    bool operator == (const TSurface& surface) const;

    bool operator != (const TSurface& surface) const;


    vector<Vertex>    vertex;

    vector<Normal>    normal;

    vector<Triangle>  triangle;
  };

#ifdef BALL_COMPILER_MSVC
  template class BALL_EXPORT TSurface<float>;
#endif

  template <typename T>
  TSurface<T>::TSurface()
  {
  }

  template <typename T>
  TSurface<T>::TSurface(const TSurface<T>& surface)
    : vertex(surface.vertex),
      normal(surface.normal),
      triangle(surface.triangle)
  {
  }

  template <typename T>
  TSurface<T>::~TSurface()
  {
  }

  template <typename T>
  void TSurface<T>::clear()
  {
    vertex.clear();
    normal.clear();
    triangle.clear();
  }
  
  template <typename T>
  void TSurface<T>::set(const TSurface<T>& surface)
  {
    vertex = surface.vertex;
    normal = surface.normal;
    triangle = surface.triangle;
  }

  template <typename T>
  TSurface<T>& TSurface<T>::operator = (const TSurface<T>& surface)
  {
    vertex = surface.vertex;
    normal = surface.normal;
    triangle = surface.triangle;
    return *this;
  }
  
  template <typename T>
  void TSurface<T>::get(TSurface<T>& surface) const
  {
    surface.vertex = vertex;
    surface.normal = normal;
    surface.triangle = triangle;
  }
  
  template <typename T>
  void TSurface<T>::readMSMSFile(const String& vert_filename, const String& face_filename)
  {
    // delete old contents
    normal.clear();
    vertex.clear();
    triangle.clear();

    std::ifstream file(vert_filename.c_str());
    if (!file)
    {
      throw Exception::FileNotFound(__FILE__, __LINE__, vert_filename);
    }

    // there are two formats: one with three lines of 
    // header and one without
    String line;
    while ((line.countFields() != 9) && file)
    {
      line.getline(file);
    }
    
    String s[6];
    while (file && (line.countFields() == 9))
    {
      // read the vertex coordinates and the normal vector 
      line.split(s, 6);
      vertex.push_back(Vertex(s[0].toFloat(), s[1].toFloat(), s[2].toFloat()));
      normal.push_back(Normal(s[3].toFloat(), s[4].toFloat(), s[5].toFloat()));
      
      // read the next line
      line.getline(file);
    }
    file.close();
    // workaround for trouble in File
    file.clear();

    // now read the faces file:
    file.open(face_filename.c_str());
    if (!file)
    {
      throw Exception::FileNotFound(__FILE__, __LINE__, face_filename);
    }

    // there are two formats: one with three lines of 
    // header and one without
    while ((line.countFields() != 5) && file)
    {
      line.getline(file);
    }
    
    Triangle t;
    Size number_of_vertices = (Size)vertex.size();
    while (file && (line.countFields() == 5))
    {
      // read the vertex indices
      line.split(s, 5);
      t.v1 = (Index)s[0].toInt() - 1;
      t.v2 = (Index)s[1].toInt() - 1;
      t.v3 = (Index)s[2].toInt() - 1;

      // if all three vertex indices are valid, insert the triangle
      if ((t.v1 < (Index)number_of_vertices) && (t.v1 >= 0)
          && (t.v1 < (Index)number_of_vertices) && (t.v1 >= 0)
          && (t.v1 < (Index)number_of_vertices) && (t.v1 >= 0))
      {
        triangle.push_back(t);
      }
      
      // read the next line
      line.getline(file);
    }
    file.close();
  }

  template <typename T>
  float TSurface<T>::getArea() const
  {
    // add the areas of all triangles
    double area = 0;
    for (Size i = 0; i < triangle.size(); i++)
    {
      // add the length of the vector products of two sides of each triangle
      // this is equivalent to the surface area of the parallelogram, and thus to twice the triangle area
      area += ((vertex[triangle[i].v2] - vertex[triangle[i].v1]) % (vertex[triangle[i].v3] - vertex[triangle[i].v1])).getLength();
    }
    
    // A = 1/2 \sum |r1 x r2|
    return (float)( area * 0.5 );
  }

  template <typename T>
  bool TSurface<T>::operator == (const TSurface<T>& surface) const
  {
    return ((surface.vertex == vertex) 
            && (surface.normal == normal) 
            && (surface.triangle == triangle));
  }

  template <typename T>
  BALL_INLINE
  Size TSurface<T>::getNumberOfTriangles() const
  {
    return (Size)triangle.size();
  }
    
  template <typename T>
  BALL_INLINE
  Size TSurface<T>::getNumberOfVertices() const
  {
    return (Size)vertex.size();
  }

  template <typename T>
  BALL_INLINE
  Size TSurface<T>::getNumberOfNormals() const
  {
    return (Size)normal.size();
  }
  
  template <typename T>
  BALL_INLINE
  typename TSurface<T>::Triangle& TSurface<T>::getTriangle(Position index)
  {
    return triangle[index];
  }

  template <typename T>
  BALL_INLINE
  const typename TSurface<T>::Triangle& TSurface<T>::getTriangle(Position index) const
  {
    return triangle[index];
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::clearTriangles()
  {
    triangle.clear();
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::resizeTriangles(Size size)
  {
    triangle.resize(size);
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::pushBackTriangle(const Triangle& t)
  {
    triangle.push_back(t);
  }

  
  template <typename T>
  BALL_INLINE
  typename TSurface<T>::Vertex& TSurface<T>::getVertex(Position index)
  {
    return vertex[index];
  }

  template <typename T>
  BALL_INLINE
  const typename TSurface<T>::Vertex& TSurface<T>::getVertex(Position index) const
  {
    return vertex[index];
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::clearVertices()
  {
    vertex.clear();
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::resizeVertices(Size size)
  {
    vertex.resize(size);
  }

  
  template <typename T>
  BALL_INLINE
  void TSurface<T>::pushBackVertex(const typename TSurface<T>::Vertex& position)
  {
    vertex.push_back(position);
  }

  template <typename T>
  BALL_INLINE
  typename TSurface<T>::Normal& TSurface<T>::getNormal(Position index)
  {
    return normal[index];
  }

  template <typename T>
  BALL_INLINE
  const typename TSurface<T>::Normal& TSurface<T>::getNormal(Position index) const
  {
    return normal[index];
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::clearNormals()
  {
    normal.clear();
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::resizeNormals(Size size)
  {
    normal.resize(size);
  }

  template <typename T>
  BALL_INLINE
  void TSurface<T>::pushBackNormal(const typename TSurface<T>::Normal& n)
  {
    normal.push_back(n);
  }

  template <typename T>
  bool TSurface<T>::operator != (const TSurface<T>& surface) const
  {
    return !(*this == surface);
  }

  typedef TSurface<float> Surface;

} // namespace BALL

#endif // BALL_MATHS_SURFACE_H