topology.hh

Go to the documentation of this file.

 
#ifndef topology_hh
#define topology_hh
 
#include <memory>
#include <map>
#include "basics/typedefs.hh"
#include "basics/Zm.hh"
#include "basics/debug.hh"
#include "toolbox/scannerConnectors.hh"
#include "connector.hh"
#include "quadsubdiv.hh"
#include "strategyChange.hh"
 
#define VertexConstr_D 0
 
namespace concepts {
 
  // ***************************************************************** match **
 
  int match(const Connector1& edg0, const Connector1& edg1, int idx[]);
 
 
  // **************************************************************** Vertex **
 
  class Vertex : public Connector0 {
  public:
    Vertex(const Attribute attrib = Attribute()) : Connector0(attrib) {
      DEBUGL(VertexConstr_D, key());
    }
 
    virtual ~Vertex();
 
    virtual Vertex* child(uint i, bool mode = 0) { return this; }
    virtual const Vertex* child(uint) const { return this; }
 
    inline Vertex* clone() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Vertex(const Attribute attrib, const Key& key) : Connector0(attrib, key) {}
  };
 
  Vertex* Vertex::clone() const {
    return new Vertex(attrib(), key());
  }
 
  // ****************************************************************** Edge **
 
  class Edge : public Connector1 {
 
  public:
    Edge(Vertex& vtx0, Vertex& vtx1, const Attribute attrib = Attribute());
    Edge(Edge& edg0, Edge& edg1);
    virtual ~Edge();
 
    virtual Edge* child(uint i, bool mode = 0);
    virtual const Edge* child(uint i) const;
 
    Vertex* vertex(uint i) const { return i < 2 ? vtx_[i] : 0; }
 
    inline Edge* clone(Vertex& vtx0, Vertex& vtx1) const;
  protected:
    Edge(Vertex& vtx0, Vertex& vtx1, const Attribute attrib, const Key& key);
 
    virtual std::ostream& info(std::ostream& os) const;
    Edge* lnk_;
 
    Edge* chld_;
 
    Vertex* vtx_[2];
 
    bool regular_;
  };
 
  Edge* Edge::clone(Vertex& vtx0, Vertex& vtx1) const {
    return new Edge(vtx0, vtx1, attrib(), key());
  }
 
  // ********************************************************** InfiniteEdge **
 
  class InfiniteEdge : public Connector1 {
 
  public:
    InfiniteEdge(Vertex& vtx, const Attribute attrib = Attribute());
    virtual ~InfiniteEdge();
 
    virtual Connector1* child(uint i, bool mode = 0);
    virtual const Connector1* child(uint i) const;
 
    Vertex* vertex(uint i = 0) const { return i < 1 ? vtx_ : 0; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    Edge* lnk_;
 
    InfiniteEdge* chld_;
 
    Vertex* vtx_;
  };
 
  // ************************************************************** Triangle **
 
  class Triangle : public Connector2 {
  public:
    Triangle(Edge& edg0, Edge& edg1, Edge& edg2, 
       const Attribute attrib = Attribute());
    virtual ~Triangle();
 
    virtual Triangle* child(uint i, bool mode = 0);
    virtual const Triangle* child(uint i) const;
 
    Edge* edge(uint i) const { return i < 3 ? edg_[i] : 0; }
    Vertex* vertex(uint i) const { return i<3 ? edg_[i]->vertex(rho_[i]) : 0; }
 
    Z2 rho(int i) const { return rho_[i]; }
 
    inline Triangle* clone(Edge& edg0, Edge& edg1, Edge& edg2) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Triangle(Edge& edg0, Edge& edg1, Edge& edg2,
       const Attribute attrib, const Key& key, const Z2 rho[]);
 
    Triangle* lnk_;
 
    Triangle* chld_;
 
    Edge* edg_[3];
 
    Z2 rho_[3];
  };
 
  Triangle* Triangle::clone(Edge& edg0, Edge& edg1, Edge& edg2) const {
    return new Triangle(edg0, edg1, edg2, attrib(), key(), rho_);
  }
 
  // ****************************************************************** Quad **
 
  class Quad : public Connector2 {
    friend class QuadSubdiv4;
    friend class QuadSubdiv2H;
    friend class QuadSubdiv2V;
  public:
    Quad(Edge& edg0, Edge& edg1, Edge& edg2, Edge& edg3, 
   const Attribute attrib = Attribute());
    Quad(const Quad& quad, uint i);
    virtual ~Quad();
 
    virtual Quad* child(uint i, bool mode = 0);
    virtual const Quad* child(uint i) const;
 
    Edge* edge(uint i) const { return i < 4 ? edg_[i] : 0; }
    Vertex* vertex(uint i) const { return i<4 ? edg_[i]->vertex(rho_[i]) : 0; }
 
    int numVertices() const {
      return 4;
    }
 
    int numEdges() const {
      return 4;
    }
 
    Z2 rho(int i) const { return rho_[i]; }
 
    bool regular() const { return regular_; }
 
    inline Quad* clone(Edge& edg0, Edge& edg1, Edge& edg2, Edge& edg3) const;
 
    void setStrategy(const QuadSubdivision* strategy = 0)
      throw(StrategyChange);
 
    const QuadSubdivision* getStrategy() const { return subdivStrategy_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
    Quad(Edge& edg0, Edge& edg1, Edge& edg2, Edge& edg3,
         const Attribute attrib, const Key& key, const Z2 rho[]);
 
    concepts::Joiner<Quad*, 1>* chld_;
 
    bool regular_;
 
    Edge* edg_[4];
 
    Z2 rho_[4];
 
    static std::map<Key, Z2> rhoTriv_;
 
    const QuadSubdivision* subdivStrategy_;
 
    inline Scan<Quad>* children_() const {
      return new concepts::PListScan<Quad>(*chld_);
    }
 
    void edgeAssertion_() const;
  };
 
  Quad* Quad::clone(Edge& edg0, Edge& edg1, Edge& edg2, Edge& edg3) const {
    return new Quad(edg0, edg1, edg2, edg3, attrib(), key(), rho_);
  }
 
 
  // ********************************************************** InfiniteQuad **
 
  class InfiniteQuad : public Connector2 {
    friend class InfQuadSubdiv2V;
  public:
    InfiniteQuad(InfiniteEdge& edg0, Edge& edg1, InfiniteEdge& edg2,
   const Attribute attrib = Attribute());
    virtual ~InfiniteQuad();
 
    virtual Connector2* child(uint i, bool mode = 0);
    virtual const Connector2* child(uint i) const;
 
    Connector1* edge(uint i) const;
    Vertex* vertex(uint i) const { return i<2 ? infEdg_[i]->vertex() : 0; }
 
    int numVertices() const {
      return 2;
    }
 
    int numEdges() const {
      return 3;
    }
 
    Z2 rho() const { return rho_; }
 
    inline InfiniteQuad* clone(InfiniteEdge& edg0, Edge& edg1,
                               InfiniteEdge& edg2) const;
 
    void setStrategy(const InfQuadSubdivision* strategy = 0)
      throw(StrategyChange);
 
    const InfQuadSubdivision* getStrategy() const { return subdivStrategy_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
    InfiniteQuad(InfiniteEdge& edg0, Edge& edg1, InfiniteEdge& edg2, 
                 const Attribute attrib, const Key& key, const Z2 rho);
 
    concepts::Joiner<Connector2*, 1>* chld_;
 
    Edge* edg_;
 
    InfiniteEdge* infEdg_[2];
 
    Z2 rho_;
 
    const InfQuadSubdivision* subdivStrategy_;
 
    inline Scan<Connector2>* children_() const {
      return new concepts::PListScan<Connector2>(*chld_);
    }
 
    void edgeAssertion_() const;
};
 
  InfiniteQuad* InfiniteQuad::clone(InfiniteEdge& edg0, Edge& edg1,
                                    InfiniteEdge& edg2) const {
    return new InfiniteQuad(edg0, edg1, edg2, attrib(), key(), rho_);
  }
 
} // namespace concepts
 
#endif