u3d_triangled_abstract_surface.hpp

// u3d_triangled_abstract_surface.hpp
// $Id: u3d_triangled_abstract_surface.hpp,v 1.3 2008/06/04 12:22:37 sad Exp $

#ifndef U3D_TRIANGLED_ABSTRACT_SURFACE_HPP_
#define U3D_TRIANGLED_ABSTRACT_SURFACE_HPP_

#include <mth/u3d_point.hpp>
#include <mth/u3d_triangle.hpp>
#include "mth/u3d_math_abstract_surface.hpp"
#include "mth/u3d_triangled_abstract_surface.hpp"

#include <list>
#include <map>
#include <stdexcept>
#include <set>



#define U3D_MIN_TRIANGLE_SIZE 50         //U3D_EPS_LENGTH * 10.;


enum U3D_COLOR {WHITE, BLACK};




//============================================================================
class U3dTriangledAbstractSurface
{
public:
  
  U3dTriangledAbstractSurface(U3dMathAbstractSurface *ms, U3dPoint zeroPoint);
  
  U3dTriangledAbstractSurface(const U3dTriangledAbstractSurface& other);
  
  virtual ~U3dTriangledAbstractSurface();

  virtual void addPoint(U3dPoint*) = 0;
  virtual bool removePoint(int pointId) = 0;
  virtual void movePoint(int pointId, double x, double y, double z) = 0;
  
  virtual class U3dBox getBox() const = 0;


#if 0
  U3dTriangle* getTriangle(int id) { return ((id < 0) || (id >= getTrianglesNum())) ? (NULL) : (m_triangles[id]); }
#else
  const U3dTriangle* getTriangle(int id) const throw(std::out_of_range) { return m_triangles.at(id); }
#endif
  


#if 0  
  bool getTriangle(int id, U3dTriangle *&triangle) 
  {
    if((id < 0) || (id >= getTrianglesNum())) return false;
    else { triangle = m_triangles[id]; return true; }
  }
#endif
  


  int getTrianglesNum() const { return m_triangles.size(); }

  void severance(U3dTriangledAbstractSurface* other, const U3D_COLOR&);

  void severance_old(const U3dTriangledAbstractSurface* other, const U3D_COLOR&);
  
  void setWhitePoint(const U3dPoint& p) { m_white_point = p; }
  
  U3dPoint getWhitePoint() const { return m_white_point; }

  
#if 0
  bool getPoint(int id, U3dPoint &point)
  {
    if (id < 0 || id >= getPointsNum()) return false; 
    else { point = U3dPoint(*m_tps[id]); return true; } 
  }
#else
  const U3dPoint* getPoint(int id) const throw(std::out_of_range) { return m_tps.at(id); }
  U3dPoint*       getPoint(int id) throw(std::out_of_range)       { return m_tps.at(id); }
#endif
  
  bool getPoint(int id, double &x, double &y, double &z)
  {
    if (id < 0 || id >= getPointsNum()) return false; 
    else {
      x = m_tps[id]->getX(); 
      y = m_tps[id]->getY(); 
      z = m_tps[id]->getZ();
      return true;
    } 
  }
  
  int getPointsNum() { return m_tps.size(); }

  void getPoints(U3dPointsAr &ps)
  { ps = m_tps; }
    


  void getInitialPoints(U3dPointsAr &ps) {
    ps = m_initPoints;
  }
  
  const U3dPointsAr& getInitialPoints() const {
    return m_initPoints;
  }


  virtual bool getSideColor(const U3dPoint& p, U3D_COLOR& u3dcolor) const;

  virtual void getIntersections(U3dPoint p0, U3dPoint p1, std::vector<int> &int_trIds, U3dPointsAr &int_points);
  
  bool isTriangulated() { return m_is_triangulated; }


  const std::set<int>& getActTrNums() { return m_actTrNums; }
  
  U3dMathAbstractSurface* getMathSurf() { return m_math_surf; }
  
protected:
  
  //  virtual void triangulate() { assert(); };
  virtual void calculateTrPlanes();
  
  U3dMathAbstractSurface* m_math_surf;
  
  U3dPointsAr    m_tps;
  U3dTrianglesAr m_triangles;

  U3dPointsAr    m_initPoints;

  std::set<int> m_actTrNums;

  
  bool m_is_triangulated;

  // Point for white/black side determination
  U3dPoint m_white_point;
  


 // Class for triangulation of set of points in one plane. 
  // (Used only in U3dTriangledAbstractSurface::severance()).
  class Delone2DTriangulator {

  private:
    void triangulate(); 

    class My2DPoint {
    public:
      My2DPoint() {};
      My2DPoint(double ix, double iy) : x(ix), y(iy) {};
      double distance(const My2DPoint& other) const;
      double getX() const { return x; };
      double getY() const { return y; };
    private:
      double x, y;
    };
    
    class MyHVector {
    public:
      MyHVector() {};
      MyHVector(double aa, double bb, My2DPoint point) : a(aa), b(bb), p(point) {};
      My2DPoint intersect(const MyHVector& v) const throw(std::overflow_error);
      double getA() const { return a; };
      double getB() const { return b; };
      double getX() const { return p.getX(); };
      double getY() const { return p.getY(); };
      const My2DPoint& getP() const { return p; };
    private:
      double a, b;
      My2DPoint p;
    };
    
        
    class Edge {
    public:
      Edge(My2DPoint* s, My2DPoint* d);
      //      Edge(const Edge&);
      bool isPointOnRight(const My2DPoint& p) const;
      const MyHVector& getPerpendicular() const { return hvec; };
      bool operator==(const Edge& other) const;    
      My2DPoint* source() const { return sorc; };
      My2DPoint* dest()   const { return dst; };    
      double getLength() { return sorc->distance(*dst); };
    private:
      My2DPoint *sorc, *dst;
      MyHVector hvec;
      double a1, b1;
    };
    
    
    double vectOP[3], vectOQ[3];
    double lengthOP, lengthOQ;
    double pzero[3]; // begining of 2d cartezians coordinates
    typedef std::map< My2DPoint*, unsigned> T_2d_3d_Assigns;    
    T_2d_3d_Assigns assigns;
    std::vector<U3dTriangle*> my_triangles;
    
    typedef std::list<Edge> Front;
    Front front;
    
    void addNewEdge(const Edge& edge);  
    const Edge* getNextEdge();
    Front::iterator itrNextEdge;

    My2DPoint* vertexes[3];

    void init(const U3dPoint& p0, const U3dPoint& p1, double A, double B, double C);

    bool checkVertexes;

  public:
    Delone2DTriangulator(double A, double B, double C, int ind0, const U3dPoint* p0, int ind1, const U3dPoint* p1, int ind2, const U3dPoint* p2);
    Delone2DTriangulator(const U3dPoint& p0, const U3dPoint& p1, double A, double B, double C);
    My2DPoint* add3DPoint(unsigned index, const U3dPoint* p);
    const std::vector<U3dTriangle*>& generateU3dTriangles() { triangulate(); return my_triangles; }  
    ~Delone2DTriangulator();  
  };
  


private:
  // Special struct for getSideColor(). Keeping information about intersection.
  friend class Intersect;
  class Intersect {
  public:
    Intersect(const U3dTriangledAbstractSurface* ps, 
          const int& tr_num /*Index of triangle*/, 
          const double& mx, const double& my, const double& mz);

    /* Include information about intersection with other triangle if point is the same. */
    bool incIfEqual(Intersect& other);
    const std::vector<int>& triangles() const { return m_triangs; };
    const double& getX() const { return x; };
    const double& getY() const { return y; };
    const double& getZ() const { return z; };    
    const int& ind1()    const { return index1; };
    const int& ind2()    const { return ind2vec.front(); };
    const int& ind3()    const { return ind3vec.front(); };    
    /* Returns other vertex from given (but not vertex with intersection) */
    bool find(const double& xin, const double& yin, const double& zin,
          double& xother, double& yother, double& zother);
  private:
    double x, y, z;  // Coordinates of intersection
    int index1;   // Index of vertex (For cases, when we shot in vertex of triangle)
    const U3dTriangledAbstractSurface* surf;
    std::list<int> ind2vec, ind3vec; // indexes of 2 and 3 other vertexes.
    std::vector<int> m_triangs;  // Indexes of all triangles of this intersections
  };




  // Struct for keeping number of segment that was checked already
  // Placed here because of using in set<>
  struct SegmentChecked { 
    int ind1, ind2; // indexes of points 
    bool operator< (const SegmentChecked& other) const { 
      if (ind1 < other.ind1) return true;
      if (ind1 > other.ind1) return false;
      return ind2 < other.ind2;
    };

    mutable U3dPoint* point;
  };
  


  
  /* If point [x,y,z] is near to one of trianlge's vertexes, 
     this function gives index of this vertex in global points array and 
     returns number of this point in triangle (1, 2 or 3).
     If [x,y,z] is not near to any vertex, index sets to -1, and function returns 0*/
  int getTrPointIndex(const int& trnum, const double& x, const double& y, 
              const double& z, int& index) const;


};





#endif // U3D_TRIANGLED_ABSTRACT_SURFACE_HPP_