MySources/trianglepatterngeometry.hpp

#ifndef FLATPATTERNGEOMETRY_HPP
#define FLATPATTERNGEOMETRY_HPP
#include "edgemesh.hpp"
#include <string>
#include <unordered_map>
#include <unordered_set>
#include "vcgtrimesh.hpp"
#include "polymesh.hpp"

class PatternGeometry : public VCGEdgeMesh {
private:
  size_t
  computeTiledValence(const size_t &nodeIndex,
                      const std::vector<size_t> &numberOfNodesPerSlot) const;
  size_t getNodeValence(const size_t &nodeIndex) const;
  size_t getNodeSlot(const size_t &nodeIndex) const;

  void addNormals();
  void deleteDanglingEdges();
  void removeDuplicateVertices();
  double baseTriangleHeight;
  double computeBaseTriangleHeight() const;

  const size_t fanSize{6};
  std::vector<VCGEdgeMesh::CoordType> vertices;
  const double triangleEdgeSize{1}; // radius edge
  std::unordered_map<size_t, size_t> nodeSlot;
  std::unordered_map<size_t, size_t> correspondingNode;
  std::unordered_map<size_t, size_t> nodeTiledValence;

  void
  constructCorresponginNodeMap(const std::vector<size_t> &numberOfNodesPerSlot);

  void constructNodeToTiledValenceMap(
      const std::vector<size_t> &numberOfNodesPerSlot);

public:
  PatternGeometry();
  /*The following function should be a copy constructor with
   * a const argument but this is impossible due to the
   * vcglib interface.
   * */
  PatternGeometry(PatternGeometry &other);
  bool savePly(const std::string plyFilename);
  void add(const std::vector<vcg::Point3d> &vertices);
  void add(const std::vector<vcg::Point2i> &edges);
  void add(const std::vector<vcg::Point3d> &vertices,
           const std::vector<vcg::Point2i> &edges);
  void add(const std::vector<size_t> &numberOfNodesPerSlot,
           const std::vector<vcg::Point2i> &edges);
  static std::vector<vcg::Point3d>
  constructVertexVector(const std::vector<size_t> &numberOfNodesPerSlot,
                        const size_t &fanSize, const double &triangleEdgeSize);
  bool hasDanglingEdges(const std::vector<size_t> &numberOfNodesPerSlot);
  std::vector<vcg::Point3d> getVertices() const;
  static PatternGeometry createFan(PatternGeometry &pattern);
  static PatternGeometry createTile(PatternGeometry &pattern);
  double getTriangleEdgeSize() const;
  bool hasUntiledDanglingEdges();
  std::unordered_map<size_t, std::unordered_set<size_t>>
  getIntersectingEdges(size_t &numberOfIntersectingEdgePairs) const;

  static size_t binomialCoefficient(size_t n, size_t m) {
    assert(n >= m);
    return tgamma(n + 1) / (tgamma(m + 1) * tgamma(n - m + 1));
  }
  bool isFullyConnectedWhenTiled();

  bool hasIntersectingEdges(
      const std::string &patternBinaryRepresentation,
      const std::unordered_map<size_t, std::unordered_set<size_t>>
          &intersectingEdges);
  bool isPatternValid();
  size_t getFanSize() const;
  void add(const std::vector<vcg::Point2d> &vertices,
           const std::vector<vcg::Point2i> &edges);

  PatternGeometry(const std::vector<size_t> &numberOfNodesPerSlot,
                  const std::vector<vcg::Point2i> &edges);
  PatternGeometry(const std::string &filename, bool addNormalsIfAbsent = true);

  bool createHoneycombAtom();
  void copy(PatternGeometry &copyFrom);

  void tilePattern(PatternGeometry &pattern, VCGTriMesh &tileInto);
  void tilePattern(VCGEdgeMesh &pattern, VCGPolyMesh &tileInto, const int &interfaceNodeIndex,
                   const bool &shouldDeleteDanglingEdges);

  void createFan(const size_t &fanSize = 6);

  void deleteDanglingVertices(
      vcg::tri::Allocator<PatternGeometry>::PointerUpdater<VertexPointer> &pu);
  void deleteDanglingVertices();
  void scale(const double &desiredBaseTriangleCentralEdgeSize);

  double getBaseTriangleHeight() const;

  PatternGeometry(const std::vector<vcg::Point2d> &vertices,
                  const std::vector<vcg::Point2i> &edges);

};
#endif // FLATPATTERNGEOMETRY_HPP