VectorFieldTopology.h

Go to the documentation of this file.

//
//  VectorFieldTopology.hpp
//  GlobeEngine
//
//  Created by Alireza Amiraghdam on 19/01/17.
//
//

#ifndef GlobeEngine_VectorFieldTopology_h
#define GlobeEngine_VectorFieldTopology_h

#include <stdio.h>
#include "DrawableComponent.h"
#include "Sphere.h"
#include "MultiLineWithBoundaries.h"
#include <pcl/kdtree/kdtree_flann.h>
#include "CriticalPoint.h"
#include "CriticalEdge.h"
#include "CriticalRegion.h"
#include "SeedLine.h"

namespace geClimateViewer {
    class VectorField;
    class VectorFieldTopology : public ge::DrawableComponent
    {
    public:
        VectorFieldTopology(VectorField *_vectorField);
        ~VectorFieldTopology();
        void clear();
        void clearRegions();
        void create();
        void draw(std::shared_ptr<ge::Camera> _cam);
        void update();
        void createVAOtopo();
        void createVAOperp();
        void createVAOstream();
        void setdt(float _dt){dt=_dt;};
        float getdt(){return dt;};
        void calculateCriticalPoints();
        void setProgramForSpheres(std::shared_ptr<ge::Shader> _programForSpheres){programForSpheres=_programForSpheres;};
        void setProgramForLines(std::shared_ptr<ge::Shader> _programForLines){programForLines=_programForLines;};
        void calculateEdges();
        void setPosition(vmml::Vector3f _p){position=_p;};
        vmml::Vector3f getPosition(){return position;};
        void setActivePointIndex(int _inx){activePointIndex=_inx;};
        void calculateRegionsAndPerps();
        VectorField * getVectorField(){return vectorField;};
        std::shared_ptr<ge::Shader> getProgramForLines(){return programForLines;};
        void streamLinesStepForward();
        void resetStreamlines();
        //const std::vector<CriticalRegionptr>& getRegions() const {
        //    return regions;
        //};
       // void setDebuggedPoint(SeedLinePointptr _d){debuggedPoint=_d;};
        void highlightStreamline(int _region, int _line);
        void setPerpVisible(bool _v){perpVisible=_v;};

        shpio::SHPFileExportContainer* getRegionsAsSHPContainer();
        shpio::SHPFileExportContainer* getStreamlinesAsSHPContainer();
        shpio::SHPFileExportContainer* getTopologyAsSHPContainer();

        void exportToSHPFile(std::string _path, enum shpio::SHPFileExportContainer::EXPORT_TYPE _type, shpio::SHPFileExportContainer* _content);
        void simplifyEdges(double _epsilon);
        void setSphereSize(float _ss){sphereSize=_ss;};
        float getTotalLength();
        void removeEdge(CriticalEdgeptr _edge);
        void closestCriticalPoint(vmml::Vector3f _key, CriticalPointptr &_result,float &_distance );
        void setCallbackProgress(std::function<void(int const&)> const& _callbackProgress){ callbackProgress = _callbackProgress; };
        void calculateRegions();
        void createStreamlinesForEachRegion();
        


    private:
        float dt=0.003;
        VectorField *vectorField;
        std::vector<CriticalPointptr> criticalPoints;
        void calculateCriticalPointsOnEdges();
        pcl::KdTreeFLANN<pcl::PointXYZ> kdtree;
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud;
        std::vector<std::shared_ptr< ge::Sphere>> criticalPointsSpheres;
        std::shared_ptr<ge::Shader> programForSpheres;
        std::shared_ptr<ge::Shader> programForLines;
        CriticalEdgeptr findNeighbor(CriticalPointptr _cpoint, vmml::Vector3f direction, float movingDirection);
        std::vector<CriticalEdgeptr> edges;
        void addCriticalPoint(CriticalPointptr _cPoint);
        vmml::Vector3f position;
        void connectBoundaryPoints();
        int activePointIndex=-1;
        std::vector<CriticalRegionptr> regions;
     //   SeedLinePointptr debuggedPoint;
        bool perpVisible=true;
        float sphereSize;
        std::function<void(int const&)> callbackProgress=nullptr;
        float progressedReal;
        int progressed;
        bool topoVAOcreated=false;
        bool perpVAOcreated=false;
        bool streamVAOcreated=false;

    };
    typedef std::shared_ptr<VectorFieldTopology> VectorFieldTopologyptr;
}
#endif /* VectorFieldTopology_hpp */