u3d_curvature_triangled_surface.hpp

// u3d_curvature_triangled_surface.hpp
// $Id: u3d_curvature_triangled_surface.hpp,v 1.1 2008/05/13 12:06:26 sad Exp $

#ifndef U3D_CURVATURE_TRIANGLED_SURFACE_HPP_
#define U3D_CURVATURE_TRIANGLED_SURFACE_HPP_

#include "u3d_triangled_abstract_surface.hpp"
#include <mth/u3d_box.hpp>
#include <cassert>
#include <map>
#include <set>
#include <vector>
#include <exception>

#include <iostream>
#include <fstream>

using namespace std;


class badmathsurf_exception : public exception {};


class U3dCurvatureTriangledSurface : public U3dTriangledAbstractSurface
{
public:
  U3dCurvatureTriangledSurface(U3dBox modelBox,              
                   U3dMathAbstractSurface *ms,   
                   U3dPoint zeroPoint,           
                   double minTriangleSide        
                   )
    throw (badmathsurf_exception);

  // Copy constructor
  U3dCurvatureTriangledSurface(const U3dCurvatureTriangledSurface& other);


  virtual void addPoint(U3dPoint *p);
  virtual bool removePoint(int i);
  virtual void movePoint(int i, double d1, double d2, double d3);

  virtual U3dBox getBox() const { return m_box; };


  virtual ~U3dCurvatureTriangledSurface() {};

protected:

  friend class CurvaturePlate;
  class CurvaturePlate {
  public:
    CurvaturePlate(const CurvaturePlate& other, U3dCurvatureTriangledSurface* trSurface);
    CurvaturePlate(U3dCurvatureTriangledSurface* trSurface) : trSurf(trSurface) {};
    void calculate();
    bool checkCurvature(const double& dp, const double& dq, const double& up, const double& uq);
    ~CurvaturePlate() { for (unsigned i=0; i<n; ++i) delete[] curvatures[i]; delete[] curvatures; };
    double getMinCurv() { return minCurv; };
    double getMaxCurv() { return maxCurv; };
  private:
    CurvaturePlate(const CurvaturePlate&) {};
    void operator=(const CurvaturePlate&) {};
    float** curvatures;
    U3dCurvatureTriangledSurface* trSurf;
    size_t n, m;
    float step_p, step_q;
    double minCurv, maxCurv;
  };


  virtual void triangulate();  
    
  struct PQ_Point {
    PQ_Point(double p_, double q_) : p(p_), q(q_) {};  
    double p, q;    
  };
  
  
  friend class PointsKeeper;
  class PointsKeeper {    
    typedef vector<PQ_Point> pq_points_vector;
  public:
    PointsKeeper(const PointsKeeper& other, U3dCurvatureTriangledSurface* pucts);
    PointsKeeper(U3dCurvatureTriangledSurface* pucts);
    inline int add_point(const double& p, const double& q);
    inline double p(const int& num) { return pq_points[num].p; };
    inline double q(const int& num) { return pq_points[num].q; };
  private:
    PointsKeeper(const PointsKeeper&) {};
    U3dCurvatureTriangledSurface* trisurf;
    pq_points_vector pq_points;
  };
   
  
  

  struct QuadMapCoords {
    QuadMapCoords() : level(0), i(0), j(0) {};
    QuadMapCoords(int level_, int i_, int j_) : level(level_), i(i_), j(j_) {};
    inline bool operator() (const QuadMapCoords& c1, const QuadMapCoords& c2); // For comparator function
    int level;
    int i, j;
    QuadMapCoords& up()   { --level; i /= 2; j /= 2; return *this; };
    QuadMapCoords& down() { ++level; i *= 2; j *= 2; return *this; };
  };

  
  friend class Quad;
  class Quad {
  public:    

    enum Placement {UP, RIGHT, DOWN, LEFT};  // order is important!
      
    struct Point {
      Point(int number, Placement p) : ndx(number), placement(p) {};
      int ndx;  // number of point
      Placement placement;       
      inline bool operator==(const Point& other) const { return ndx == other.ndx && placement == other.placement; };
    };

    
    struct PointComparator {
      inline bool operator()(const Point& p1, const Point& p2);
    };

    typedef set<Point, PointComparator> QPoints;   

    Quad(int vul, int vur, int vdr, int vdl);

    void add_points(const QPoints& ps, const Placement& p);
    
    QPoints get_points(const Placement& p) const;

    const QPoints& points() const { return qpoints; };
    const vector<Point>& angles() const { return qangles; };
  private:
    QPoints qpoints;
    vector<Point> qangles;
  };


  struct TrigPointComparator {
    TrigPointComparator(PointsKeeper* p) : pKeeper(p) {};
    bool operator()(const Quad::Point&, const Quad::Point&);
  private:
    PointsKeeper* pKeeper;
  };  
  typedef set<Quad::Point, TrigPointComparator> QTrigPoints;


  typedef map<QuadMapCoords, Quad, QuadMapCoords> QuadMap;
  typedef vector<QuadMap>  QuadMapVector;



  bool checkUpCoord(QuadMapCoords cmc);


  QuadMapVector quadMapVector;



private:

  U3dBox modelBox;             
  double minTriangleSide;
  double curvature;
  double sqr_minTrSide;      // minTriangleSide^2

  U3dBox m_box;

  void make_quads(QuadMapCoords cmc, double dp, double dq, double up, double uq,
          int vul, int vur, int vdr, int vdl);

  
  Quad::QPoints get_neighbour_points(QuadMapCoords cmc, const Quad::Placement& p);
  inline int get_neighbour_point(QuadMapCoords cmc, const Quad::Placement& p);

  vector<int> max_coords;

  PointsKeeper pKeeper;

  CurvaturePlate curvPlate;

  int rgnlevel;
  int rmqlevel;

  double minX, minY, minZ;
  double maxX, maxY, maxZ;
  
};



#endif // U3D_CURVATURE_TRIANGLED_SURFACE_HPP_