TrafficObject.h

Go to the documentation of this file.

#ifndef GlobeEngine_TrafficObject_h
#define GlobeEngine_TrafficObject_h

#include <vector>
#include "OpenGL_Includes.h"
#include "PolyLine.h"
#include "LineFeatureObject.h"
#include "SceneBluePrint.h"
#include "ReferenceSystem.h"
#include "PointCloud.h"
#include "BSpline.h"
#include "ReducableUndirectedGraph.h"
#include "ColorisationTable.h"
#include "Timer.h"

#undef min
#undef max
using std::min;
using std::max;

#ifndef Q_MOC_RUN
#include <pcl/point_cloud.h>
#include <pcl/search/kdtree.h>

// Boost includes
#include <boost/config.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/graph_traits.hpp>
#endif // Q_MOC_RUN

namespace geGIS {
    
    class ModelLayer;
    
    typedef boost::adjacency_list_traits<boost::vecS, boost::vecS, boost::undirectedS>::vertex_descriptor GraphVertex;
    typedef boost::property < boost::edge_weight_t, double > EdgeWeight;
    
    typedef boost::adjacency_list<
    boost::listS,
    boost::vecS,
    boost::undirectedS,
    boost::property<boost::vertex_distance_t, double,
    boost::property<boost::vertex_predecessor_t, GraphVertex> >,                 // Vertex properties
    EdgeWeight//boost::property<boost::edge_weight_t, double> // Edge properties
    > SimpleUndirectedGraph;
    
    struct NearestNeighborSearchResult
    {
        std::vector<int> pointIndices;
        std::vector<float> pointSquaredDistances;
        NearestNeighborSearchResult() {}
        NearestNeighborSearchResult(int _K): pointIndices(_K), pointSquaredDistances(_K) {}
    };
    
    struct FinishedEdgeInfo
    {
        unsigned int idx;
        float weight;
        std::vector<int> finalPoints;
        
        FinishedEdgeInfo() {}
        FinishedEdgeInfo(unsigned int _idx, float _weight , std::vector<int> _finalPoints): idx(_idx), weight(_weight), finalPoints(_finalPoints){}
    };
    
    class TrafficObject : public LineFeatureObject
    {
        
    public:
        TrafficObject();
        ~TrafficObject();
        void clear();
        void create(ModelLayer* _modelLayerref, std::shared_ptr<TrafficBlueprint> _blueprint, std::shared_ptr<ReferenceSystem> _referenceSystem);
        void update();

        void loadData(std::string filename);
        void reduceGraphData();
        void buildKDtree();
        
        NearestNeighborSearchResult* findNearestNeighbor(pcl::PointXYZ _point, int _K);
        
        int createPointCloud(std::vector<ge::VBOVertex3d> _vertices, vmml::Vector3f _color, std::string _name);
        int createPointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr _cloud, vmml::Vector3f _color, std::string _name);
        void createMultiLineGraph(vmml::Vector3f _color, std::string _name);
        
        void createPolyLine(std::vector<int> _indices, vmml::Vector3f _color, double _lineWeight, ge::VBOVertex3d _commuterPoint_1, ge::VBOVertex3d _commuterPoint_2, int _bundlingIdx);
        
        std::vector<int> getShortestPath(int _source, int _dest);
        pcl::PointXYZ getKdTreePoint(int _index);
        ge::VBOVertex3d getGraphNodeContent(int _nodeIdx);
        
        void printKDtree();
        void printKDtreeIndex(int _index);
        
        int getCrossingsID() const;
        int getEndPointsID() const;
        int getGraphCloudID() const;
        int getBasePointsID() const;
        void setVisibility(bool _in);
        unsigned int getNumberOfLineWithZeroLineCount() const {
            return numberOfLinesWithZeroLineCount;
        }
        
        void setGraphNetworkProperties(int _idx, vmml::Vector3f _color, vmml::Vector3f _pos, std::string _name);
        void updateMultiLineObjectColorInformation();
        void setupColorInformation(const std::shared_ptr<geData::ColorisationTable>& _table = NULL);
        
        bool checkIfReferenceNetwork();
        void enableAsReferenceNetwork();
        void disableAsReferenceNetwork();
        
        void createGraph();
        void createCloudData();
        void setMinMaxWeightInformationToGraphWeight();
        void createGeometry();
        
        int createPath(std::shared_ptr<geData::PolyLine> _path, std::string _name, bool _inLocalCoordinates);
        
        void exportGraphData(std::string _path);

    private:
        using ge::DrawableComponent::create; // implicitly hidden
        
        void setPointCloudProperties(int idx, vmml::Vector3f _color, std::string _name);
        void clearInitial();
        std::shared_ptr<TrafficBlueprint> blueprint;
        
        /*  ModelLayer Reference */
        ModelLayer* modelLayerRef;
        
        geGraph::ReducableWeightedUndirectedPolylineGraph3Dd trafficGraphNetwork;
        
        /* index to multilineobject */
        int graphMLOidx;
        
        /* Conversion map von kdtree zu edge info */
        std::map< int, int > kdtreeToEdgeMap;
        
        /* nearest neighbor cloud */
        std::vector<int> nearestNeigbors;
        
        /* Graph information*/
        SimpleUndirectedGraph trafficgraph;
        
        /* kdtree */
        pcl::search::KdTree<pcl::PointXYZ>* kdtree;
        
        /* Rendering structures */
        GLsizei* lineStripLenght;
        
        /* is this traffic network a reference graph */
        bool isReferenceNetwork;
        
        /* colorisation table */
        //const std::shared_ptr<geData::ColorisationTable> bundlingColorisation;
        std::shared_ptr<geData::ColorisationTable> bundlingColorisation;
        
        // Pointclouds
        int crossingsPCidx;
        int endPointsPCidx;
        int basePointsPCidx;
        int graphPCidx;

        unsigned int numberOfLinesWithZeroLineCount;

        // Debugtimer
        ge::Timer timer;
    };
}
#endif