GrowingCellStructure.hpp

Go to the documentation of this file.

//
// Created by patrick on 10.02.19.
//

#ifndef LAS_VEGAS_GROWINGCELLSTRUCTURE_HPP
#define LAS_VEGAS_GROWINGCELLSTRUCTURE_HPP

#include "lvr2/attrmaps/HashMap.hpp"
#include "lvr2/config/BaseOption.hpp"
#include "lvr2/geometry/HalfEdgeMesh.hpp"
#include "lvr2/reconstruction/PointsetSurface.hpp"
#include "lvr2/reconstruction/gs2/DynamicKDTree.hpp"
#include "lvr2/reconstruction/gs2/TumbleTree.hpp"

namespace lvr2
{

template <typename BaseVecT, typename NormalT>
class GrowingCellStructure
{
  public:
    GrowingCellStructure(PointsetSurfacePtr<BaseVecT>& surface);

    void getMesh(HalfEdgeMesh<BaseVecT>& mesh);

    int getRuntime() const { return m_runtime; }

    int getBasicSteps() const { return m_basicSteps; }

    int getNumSplits() const { return m_numSplits; }

    float getBoxFactor() const { return m_boxFactor; }

    bool isWithCollapse() const { return m_withCollapse; }

    float getLearningRate() const { return m_learningRate; }

    float getNeighborLearningRate() const { return m_neighborLearningRate; }

    float getDecreaseFactor() const { return m_decreaseFactor; }

    int getAllowMiss() const { return m_allowMiss; }

    float getCollapseThreshold() const { return m_collapseThreshold; }

    bool isFilterChain() const { return m_filterChain; }

    int getDeleteLongEdgesFactor() const { return m_deleteLongEdgesFactor; }

    bool isInterior() const { return m_interior; }

    void setRuntime(int m_runtime) { GrowingCellStructure::m_runtime = m_runtime; }

    void setBasicSteps(int m_basicSteps) { GrowingCellStructure::m_basicSteps = m_basicSteps; }

    void setNumSplits(int m_numSplits) { GrowingCellStructure::m_numSplits = m_numSplits; }

    void setBoxFactor(float m_boxFactor) { GrowingCellStructure::m_boxFactor = m_boxFactor; }

    void setWithCollapse(bool m_withCollapse)
    {
        GrowingCellStructure::m_withCollapse = m_withCollapse;
    }

    void setLearningRate(float m_learningRate)
    {
        GrowingCellStructure::m_learningRate = m_learningRate;
    }

    void setNeighborLearningRate(float m_neighborLearningRate)
    {
        GrowingCellStructure::m_neighborLearningRate = m_neighborLearningRate;
    }

    void setDecreaseFactor(float m_decreaseFactor)
    {
        GrowingCellStructure::m_decreaseFactor = m_decreaseFactor;
    }

    void setAllowMiss(int m_allowMiss) { GrowingCellStructure::m_allowMiss = m_allowMiss; }

    void setCollapseThreshold(float m_collapseThreshold)
    {
        GrowingCellStructure::m_collapseThreshold = m_collapseThreshold;
    }

    void setFilterChain(bool m_filterChain) { GrowingCellStructure::m_filterChain = m_filterChain; }

    void setDeleteLongEdgesFactor(int m_deleteLongEdgesFactor)
    {
        GrowingCellStructure::m_deleteLongEdgesFactor = m_deleteLongEdgesFactor;
    }

    void setInterior(bool m_interior) { GrowingCellStructure::m_interior = m_interior; }

    void setNumBalances(int m_balances) { GrowingCellStructure::m_balances = m_balances; }

  private:
    PointsetSurfacePtr<BaseVecT>* m_surface; // helper-surface
    HalfEdgeMesh<BaseVecT>* m_mesh;

    // SHARED members
    int m_runtime;        // how many steps?
    int m_basicSteps;     // how many steps until collapse?
    int m_numSplits;      // how many splits
    float m_boxFactor;    // for initial mesh
    bool m_withCollapse;  // should we collapse?
    float m_learningRate; // learning rate of the algorithm
    float m_neighborLearningRate;
    bool m_filterChain; // should a filter chain be applied?
    bool m_interior;    // should the interior be reconstructed or the exterior?
    int m_balances;
    float m_avgSignalCounter = 0;

    // "GCS" related members
    TumbleTree* tumble_tree;
    DynamicKDTree<BaseVecT>* kd_tree;
    std::vector<Cell*> cellArr; // TODO: OUTSOURCE IT INTO THE TUMBLETREE CLASS, NEW PARAMETER FOR
                                // THE TUMBLE TREE CONSTRUCTOR
                                // CONTAINING THE MAXMIMUM SIZE OF THE MESH
    float m_decreaseFactor; // for sc calc
    int m_allowMiss;
    float m_collapseThreshold; // threshold for the collapse - when does it make sense
    int m_deleteLongEdgesFactor;
    int notFoundCounter = 0;
    int flipCounter = 0;

    // "GSS" related members
    bool m_useGSS = false;
    HashMap<FaceHandle, std::pair<float, float>>
        faceAgeErrorMap; // hashmap for mapping a FaceHandle to <age, error>
    float m_avgFaceSize = 0;
    float m_avgEdgeLength = 0;

    float m_limSkip;
    float m_limSingle;
    float m_maxAge;
    bool m_withRemove;

    // SHARED MEMBER FUNCTIONS

    void executeBasicStep(PacmanProgressBar& progress_bar);

    void executeVertexSplit();

    void executeEdgeCollapse();

    void getInitialMesh();

    BaseVecT getRandomPointFromPointcloud();

    VertexHandle getClosestPointInMesh(BaseVecT point, PacmanProgressBar& progress_bar);

    void initTestMesh(); // test

    // GCS MEMBER FUNCTIONS

    void performLaplacianSmoothing(VertexHandle vertexH, BaseVecT random, float factor = 0.01);

    void aggressiveCutOut(VertexHandle vH);

    double avgDistanceBetweenPointsInPointcloud();

    int numVertexValences(int minValence);

    std::pair<double, double> equilaterality();

    double avgValence();

    // void coalescing();

    // ADDITIONAL FUNCTIONS

    void removeWrongFaces();

    int cellVecSize();

    // TODO: add gss related functions
};
} // namespace lvr2

#include "lvr2/reconstruction/gs2/GrowingCellStructure.tcc"

#endif // LAS_VEGAS_GROWINGCELLSTRUCTURE_HPP