FDEBCommand.h

Go to the documentation of this file.

#ifndef GlobeEngine_FDEBCommand_h
#define GlobeEngine_FDEBCommand_h

#include <vector>
#include <vmmlib/vmmlib.hpp>
#include "OpenGL_Includes.h"
#include "GPUProgramFactory.h"
#include "VBOVertex.h"
#include "BundlingCommand.h"
#include "PolyLine.h"
#include "Timer.h"
#include "FDEBCompatibilityMeasure.h"
#include <memory>

namespace geGIS {
    
    class CommuterObject;
    
    struct FDEBCommandProperties
    {
        int iterations;
        int subdivisions;
        double stiffness;
        double threshold;
        double move_factor;
        
    };
    
    class FDEBCommand : public BundlingCommand
    {
        /*struct CompatibilityMeasure
        {
            double* ca; // angle
            double* cs; // scale
            double* cp; // position
            double* cv; // visibility
            double* ce; // all together
            double* l_avg; // all together
            CompatibilityMeasure(int _edgeCount) {
                this->ca = new double[_edgeCount];
                this->cs = new double[_edgeCount];
                this->cp = new double[_edgeCount];
                this->cv = new double[_edgeCount];
                this->ce = new double[_edgeCount];
                this->l_avg = new double[_edgeCount];
            }

            ~CompatibilityMeasure() {
                if (this->ca != NULL)   {
                    delete [] this->ca;
                    this->ca = NULL;
                }
                if (this->cs != NULL)   {
                    delete [] this->cs;
                    this->cs = NULL;
                }
                if (this->cp != NULL)   {
                    delete [] this->cp;
                    this->cp = NULL;
                }
                if (this->cv != NULL)   {
                    delete [] this->cv;
                    this->cv = NULL;
                }
                if (this->ce != NULL)   {
                    delete [] this->ce;
                    this->ce = NULL;
                }
                if (this->l_avg != NULL)    {
                    delete [] this->l_avg;
                    this->l_avg = NULL;
                }
            }
            
        };*/
        
    public:
        FDEBCommand();
        ~FDEBCommand();
        void clear();
        void create(CommuterObject* _refInformation, const FDEBCommandProperties* _properties);
        void processing(ge::GPUProgram* _program=NULL, ge::GPUProgramFactory* _manager=NULL);
        
        
        void processingGPU();
        void calculateForcesGPU();
        
        
        void createSubdivisionsCPU();
        //void doBasicLineSetup();
        void calculateMeasures();
        void calculateForcesCPU();
        void setGPUMode(bool _input);
        bool isGPUModeOn() { return this->gpumode; };
        bool isOnlyUpdate() { return this->onlyUpdate; };
        
        void setInitialValues();
        void setSubdivisions(int _input);
        int getSubdivisions() const;
        void setStiffness(double _input);
        void setThreshold(double _input);
        void setIterations(int _input);
        void setMoveFactor(double _input);
        
        vmml::Vector2d rotation(vmml::Vector2d _point, double _alpha);
        void calculateMeasureCA(int _idx_1, int _idx_2);
        void calculateMeasureCS(int _idx_1, int _idx_2);
        void calculateMeasureCP(int _idx_1, int _idx_2);
        
        const std::vector<vmml::Vector3d> getBundlingResult()const;
        std::shared_ptr<geData::PolyLine> getResultLine(int _idx) const;
        
        int getPointsPerLine() const;
        int getSegementsPerLine() const;
        
        void printMeasures();
        
        int getMultiObjectReferenceID() const;
        void setMultiObjectReferenceID(int _idx);
        
    private:
        using geGIS::BundlingCommand::create; // implicitly hidden
        using geGIS::BundlingCommand::processing; // implicitly hidden
        
        void clearLineData();
        vmml::Vector3d leftTilt(vmml::Vector3d _in);
        vmml::Vector3d rightTilt(vmml::Vector3d _in);
        double getDistToIm(vmml::Vector3d _Qmid, vmml::Vector3d _Q0Q1,vmml::Vector3d _P0, vmml::Vector3d _P0P1);
        double getDistToImTest(vmml::Vector3d _Qmid, vmml::Vector3d _normQ0Q1,vmml::Vector3d _P0, vmml::Vector3d _P0P1, double s);
        double getDistanceWheighting(vmml::Vector3d _Pm, vmml::Vector3d _Im, vmml::Vector3d _I0, vmml::Vector3d _I1);
        double calculateCVMeasure(int _idx1, int _idx2);
        
        std::vector<vmml::Vector3d> midpoints;
        std::vector<vmml::Vector3d> lineDirections;
        std::vector<vmml::Vector3d> lineStrips;
        std::vector<double> lengths;
        //std::vector<CompatibilityMeasure*> measures;
        std::vector< std::shared_ptr<FDEBCompatibilityMeasure> > measures;

        bool gpumode; // Calcuation mode on GPU or not (CPU)
        bool onlyUpdate;
        //int segments_per_line;
        int points_per_line;
        
        int measure_arrayssize;
        double* result_ca;
        
        double* entities_0;
        double* entities_1;
        double* resultSubDivLines;
        
        //vmml::Vector3d* linestrips;
        //std::vector<PolyLine*> resPolyLines;
        std::vector< std::shared_ptr<geData::PolyLine> > resPolyLines;
        // GPU processing pointers
        ge::GPUProgram* program;
        ge::GPUProgramFactory* manager;
        
        FDEBCommandProperties properties;
                
        ge::Timer timer;
        
        // Reference to multiobject id
        int multiObjectRefID;
    };
}
#endif