DouglasPeuckerDrawablePath.h

Go to the documentation of this file.

//
//  DrawablePolyline.h
//  GlobeEngine
//
//  Created by Mathias Thöny on 27.12.11.
//  Copyright (c) 2011 University of Zurich. All rights reserved.
//

#ifndef GlobeEngine_DouglasPeuckerDrawablePath_h
#define GlobeEngine_DouglasPeuckerDrawablePath_h

#include <queue>
#include "PolyLine.h"
#include "OpenGL_Includes.h"
#include "DrawableComponent.h"
#include "ArrayTreeNode.h"

namespace geData {
    class DouglasPeuckerPathNode : public ArrayBinTreeNode
    {
    public:
        DouglasPeuckerPathNode() {
            this->distance = -1.0f;
            this->splitHeight = -1.0;
            this->enabled = false;
        };
        ~DouglasPeuckerPathNode(){};
        
        void setDistance(double _in) {
            distance = _in;
        };
        double getDistance() const {
            return distance;
        }
        void setSplitHeight(double _in) {
            this->splitHeight = _in;
        };
        double getSplitHeight() const {
            return this->splitHeight;
        }
        
        void printValue() const {
            //ArrayBinTreeNode::printValue();
            std::cout << this << " ";
            std::cout << this->enabled << " ";
            std::cout << this->distance << " ";
            std::cout << this->splitHeight << " ";
        }
        
        void enable() {
            enabled = true;
        }
        
        void disable() {
            enabled = false;
        }
        
        bool IsEnabled(){
            return enabled;
        }
        
    private:
        double splitHeight;
        double distance;
        bool enabled;
        
    };
    
    class DouglasPeuckerDrawablePath : public ge::DrawableComponent, public PolyLine
    {
        
    public:
        /*  0 = line,
         1 = triangulated with overlaps,
         2 = triangulated as nice ribbon,
         3 = gputriangulated
         */
        enum GEOMETRYDRAWMODE { LINES=0,
            TRIANGLES_OVERLAPPING,
            RIBBON,
            TRIANGLE_OCCLUSION};
        DouglasPeuckerDrawablePath();
        ~DouglasPeuckerDrawablePath();
        void clear();
        void update();
        void create() {};
        void createVAO(GEOMETRYDRAWMODE _in);
        void createTriangleIndices();
        void createRibbonIndices();
        
        void setupGeometryBuffersWithLineStripInformation();
        void setupGeometryBuffersAsRibbons();
        
        
        /* 0=line, 1=lineWithThickness, 2=triangulated, 3=gputriangulated */
        enum GEOMETRYDRAWMODE getDrawMode() const {
            return this->drawMode;
        };
        
        // inherited
        void draw(std::shared_ptr<ge::Camera> _cam);
        void drawWithOcclusionQueries(DrawableComponent::RENDERSTATE _state, std::shared_ptr<ge::Camera> _cam);

        // protected methods
        void setLineThickness(double _thickness);
        
        // douglas peucker property
        void setDouglasPeuckerIndices();
        void setRefinementLevel(); //int _level);
        
        // protected
        void enableOcclusionQueries(bool _in);
        void printDPTree(int _idx);
        void printAllDPTrees();
        void printPoints();
        
        unsigned int connectTree(unsigned int _min, unsigned int _max,
                                 unsigned int _parent, short _childIdx, unsigned int _treeIdx);
        void inOrderTraversal(unsigned int _id, unsigned int _treeIdx, unsigned int _activePointIdx);
        void inOrderHeightTraversal(unsigned int _id, unsigned int _treeIdx, unsigned int _activePointIdx);
        bool nodeAccessPossible(unsigned int _id, unsigned int _treeIdx);
        
        unsigned int inOrderUpdateTraversal(unsigned int _id, unsigned int _treeIdx, unsigned int _alloverID);
        unsigned int inOrderHeightUpdateTraversal(unsigned int _id, unsigned int _treeIdx, unsigned int _alloverID);
        
        bool enableNeighborRecursive(short _child, unsigned int _id, unsigned int _treeIdx);
        bool enableHeightNeighborRecursive(short _child, unsigned int _id, unsigned int _treeIdx);
        
        void setRefined(bool _in);
        bool IsRefined();
        bool IsOcclusionQueriesEnabled(){
            return occlusionQueriesEnabled;
        }
        
        void updateSingleScanning();
        void updateInitialScanning();
        
        void enableInitialScan();
        void disableInitialScan();
        bool isInitialScanningOn();
        
    private:
        void genenerateOcclusionQueries();
        void beginOcclusionQueries(int idx);
        void endOcclusionQueries();
        void readOcclusionQueryResult(GLuint* _ids, GLuint* _results);
        
        void clearInitial();
        void allocateOcclusionMemory();
        void deleteOcclusionMemory();
        void generateControlPointArray();
        void removeSlopesAtStartAndEnd();
        void evaluateLineQuery();
        
        
        GEOMETRYDRAWMODE drawMode;
        DrawableComponent::RENDERSTATE renderState;
        // Spline property
        //bool needsRefinement;
        
        int pointSum;
        /* indexed douglas peucker information */
        DouglasPeuckerPathNode** dptrees;
        unsigned int* dptreeSize;
        int* dptreeRoots;
        unsigned int visibleSegmentCount;
        /* Hardware occlusion queries
         *  0 = no query requested
         *  1 = query requested
         *  2 = glBeginQuery called
         *  3 = wait for result
         *  4 = result ready, query deleted
         */
        GLuint* occlusionQueryIDs;
        GLuint* occlusionQueryGTIDs;
        // occlusion queries
        // 0=not set 1=requested 2=finished
        // pixels showed the ground truth
        GLuint* occlusionGroundTruths;
        GLuint* renderPixelInLastFrames;
        GLuint checkForOcclusionResult;
        
        GLuint* indices;
        // temp arrays
        std::vector<unsigned int> ids;
        std::queue<unsigned int> uids;
        
        char refinementStep;
        bool occlusionQueriesEnabled;
        bool isRefined;
        bool initialScanningOn;
    };
}
#endif