geometry/topology.hh

Go to the documentation of this file.

/* Topology.
 * how to subdivide
 */

#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