LVRChunkedMeshBridge.hpp

Go to the documentation of this file.

#ifndef LVR2_CHUNKED_MESH_BRIDGE_HPP_
#define LVR2_CHUNKED_MESH_BRIDGE_HPP_
 
#include <QObject>
//extern "C" {
//#include <GL/glx.h>
//}
 
#undef Success
 
#include <vtkSmartPointer.h>
#include <vtkActor.h>
#include <vtkActorCollection.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
 
#include "lvr2/algorithm/ChunkManager.hpp"
#include "lvr2/geometry/BoundingBox.hpp"
#include "lvr2/display/MeshOctree.hpp"
 
#include <string>
 
//#include "MeshChunkActor.hpp"
 
#include <mutex>
#include <thread>
#include <condition_variable>
 
#include <vtkWeakPointer.h>
 
 
 
//class XContext;
//class XVisualInfo;
//class Window;
//struct XID;
 
//struct XVisualInfo;
//typedef struct XVisualInfo XVisualInfo;
 
//struct XVisualInfo;
//typedef unsigned long XID;
//typedef XID Window;
//struct _XDisplay;
//typedef struct _XDisplay Display;
 
typedef std::unordered_map<size_t, vtkSmartPointer<vtkActor> > actorMap;
Q_DECLARE_METATYPE(actorMap)
 
//#include <GL/glx.h>
namespace lvr2 {
 
template <typename T>
class CompareDistancePair
{
 
    public:
        bool operator()(std::pair<float,T> p1, std::pair<float,T> p2)
        {
            return p1.first > p2.first;
        }
};
 
 
    class LVRChunkedMeshBridge : public QObject
    {
        Q_OBJECT
        public:
            LVRChunkedMeshBridge(std::string file, vtkSmartPointer<vtkRenderer> renderer,
                                 std::vector<std::string> layers, size_t cache_size = 1000);
            void getActors(double planes[24],
                    std::vector<BaseVector<float> >& centroids, 
                    std::vector<size_t >& indices);
        
            std::mutex mw_mutex;
            std::condition_variable mw_cond;
            bool release = false;
 
            std::unordered_map<size_t, vtkSmartPointer<vtkActor>> getHighResActors() { return m_highResActors; }
            std::unordered_map<size_t, vtkSmartPointer<vtkActor>> getLowResActors()  { return m_chunkActors;   }
                    //std::unordered_map<size_t, vtkSmartPointer<vtkActor> >& actors);
            void addInitialActors(vtkSmartPointer<vtkRenderer> renderer);
 
            void fetchHighRes(BoundingBox<BaseVector<float > > bb,
                              std::vector<size_t> indices,
                              std::vector<BaseVector<float>> centroids);
 
            double getHighResDistance() {return m_highResDistance; }
 
        Q_SIGNALS:
            void updateHighRes(actorMap lowRes, actorMap highRes);
                    
 
        protected:
            void computeMeshActors();
            inline vtkSmartPointer<vtkActor> computeMeshActor(size_t& id, MeshBufferPtr& chunk);
 
        private:
            vtkSmartPointer<vtkRenderer> m_renderer;
 
            std::thread worker;
            std::mutex mutex;
            std::condition_variable cond_;
            double m_highResDistance;
            bool getNew_;
            bool running_;
            BoundingBox<BaseVector<float> > m_region;
            BoundingBox<BaseVector<float> > m_lastRegion;
            // Maybe use 2 maps.
            std::vector<size_t> m_highResIndices;
            std::vector<BaseVector<float> > m_highResCentroids;
            std::vector<size_t > m_lastIndices;
            std::vector<BaseVector<float> > m_lastCentroids;
 
            std::vector<std::string> m_layers;
            size_t m_cacheSize;
            void highResWorker();
            lvr2::ChunkManager m_chunkManager;
            std::unordered_map<size_t, MeshBufferPtr> m_chunks;
            std::unordered_map<size_t, MeshBufferPtr> m_highRes;
            std::unordered_map<size_t, vtkSmartPointer<vtkActor> > m_chunkActors;
            std::unordered_map<size_t, vtkSmartPointer<vtkActor> > m_highResActors;
 
            std::unique_ptr<MeshOctree<BaseVector<float> > > m_oct;
    };
    typedef boost::shared_ptr<LVRChunkedMeshBridge> ChunkedMeshBridgePtr;
 
} // namespace lvr2
 
#endif