FeatureObject.h

Go to the documentation of this file.

#ifndef GlobeEngine_FeatureObject_h
#define GlobeEngine_FeatureObject_h

#include "SHPObject.h"
#include "DBFObject.h"
#include "OpenGL_Includes.h"
#include "DrawableComponent.h"
#include "GPUProgramFactory.h"
#include "VBOVertex.h"
#include "FeatureRange.h"
#include "TileFeatureService.h"
#include "StyleCollection.h"
#include <string>
#include <vector>
#include <memory>

namespace geGIS {
    class ReferenceSystem;

    class FeatureObject : public ge::DrawableComponent
    {
    public:
        //enum RENDERMODE { NORMAL_LINES, PATH_VOLUMES };
        /* 0 = line,
         1 = triangulated with overlaps,
         2 = triangulated as nice ribbon,
         3 = gputriangulated
         */
        enum GEOMETRYDRAWMODE { LINES=0,
            TRIANGLES_OVERLAPPING,
            EXTRUDED_GEOMETRY,
            RIBBON, TRIANGULATED, POINTS };
        
        enum FEATUREFORMAT { SHP=0, JSON, CSV, NONE};
        
        enum FEATURETYPE { NOTYPE=0, POINT, MULTIPOINT, LINE, MULTILINE, POLYGON, MULTIPOLYGON};
        
        FeatureObject();
        virtual ~FeatureObject();
        virtual void clear();
        virtual void create();
        virtual void update() = 0;
        virtual void draw(std::shared_ptr<ge::Camera> _cam) = 0;
        virtual void createVAO(enum GEOMETRYDRAWMODE _in) = 0;
        
        vmml::Vector4d getBounds2D() const;
        vmml::Vector3d getMinBounds() const;
        vmml::Vector3d getMaxBounds() const;
        vmml::Vector3d getEdgeLength() const;

        int getShapeType() const;
        

        enum GEOMETRYDRAWMODE getDrawMode() const{ return this->drawMode; };
        int getEntityCount() const;
        int getEdgeCount() const;
        int getLocationPointCount() const;

        void exportToSHPFile(std::string _path, enum shpio::SHPFileExportContainer::EXPORT_TYPE _type, shpio::SHPFileExportContainer* _content);
        void exportToCSVFile(std::string _path, enum shpio::SHPFileExportContainer::EXPORT_TYPE _type, shpio::SHPFileExportContainer* _content);
        void loadDatabaseFields();

        enum FEATUREFORMAT getFormatFromString(std::string _input);
        std::string getStringForFormat(enum FEATUREFORMAT _input);
        enum FEATUREFORMAT checkForFileWithStandardExtension(std::string _input);

        // access to datatable
        char getFieldType(int _fieldnumber);
        std::vector<std::string> getFieldNames();

        int* readIntegerFieldFromDBFtoArray(int _fieldnumber){
            return this->datatable.readIntegerFieldFromDBFtoArray(_fieldnumber);
        }

        template <typename T>
        std::vector<T> readStringField(int _fieldnumber) {
            return this->datatable.readStringFieldFromDBF<T>(_fieldnumber);
        }

        template <typename T>
        std::vector<T> readNumericField(int _fieldnumber) {
            return this->datatable.readFieldFromDBF<T>(_fieldnumber);
        }

        float getWheightMax() const;
        float getWheightMin() const;
        void saveFeature(std::string _path, std::string _ext);
        
        const tileService::TileFeatureService*  getTFSInfo(){
            return &this->tfsloader;
        }
        
        vmml::Vector3d getMidpointOfBounds();
        vmml::Vector2d getMidpointOfBoundsProj2D();

        void setTextColor(vmml::Vector3f _textcolor);
        vmml::Vector3f getTextColor() const;

        // get feature styling information
        std::shared_ptr<StyleCollection> getStyleCollection() const;

    protected:
        void deleteMemory();
        void setupInitialShapeData(std::string _filename, std::string _driver, geGIS::FeatureRange _entRange);
        void setupInitialTFSData(std::string _filename, int _minlod, int _maxlod);
        
        virtual shpio::SHPFileExportContainer* getExportContainer(std::shared_ptr<ReferenceSystem> _referenceSystem);

        void checkForBoundaries();
        void setEntityRanges(geGIS::FeatureRange _entRange);
        void print();
        
        void setFeatureType(std::string _type);
        
        void loadDataFromSHP(std::string filename);

    private:
        void loadDataFromJSON(std::string _filename);
        void loadDataFromTFS(std::string _repourl, int _minlod, int _maxlod);
        
        
        void convertWGS84toLocalCoordinates(std::shared_ptr<ReferenceSystem> _referenceSystem);
        void convertLocalToWGS84Coordinates(std::shared_ptr<ReferenceSystem> _referenceSystem);
        
    protected:
        GEOMETRYDRAWMODE drawMode;
        FEATURETYPE featureType;
        FEATUREFORMAT featureFormat;

        int shapetype;
        int numberOfEntities;
        int numberOfEdges;
        int numberOfLocations;
        geGIS::FeatureRange entityRange;

        double bounds[6];
        vmml::Vector3d midPoint;
        double edgelength[3];
        
        // Singleton object references
        std::shared_ptr<ReferenceSystem> referenceSystem;
        
        // feature file content
        std::vector< vmml::Vector3d > feature_vec;
        // index of feature vector to shp variables
        std::vector< int > shapeVecIdx;
        
        std::vector<SHPObject*> shape_vec;
        SHPHandle shapehandle;
        shpio::DBFDataContainer datatable;
        
        vmml::Vector3f textColor;

        float weightMax;
        float weightMin;
        
        // Blueprint information
        vmml::Vector3f blueprintColor;
        bool isRepository;
        
        tileService::TileFeatureService tfsloader;
        
        std::string fileUrl;

        // style information
        std::shared_ptr<StyleCollection> vectorStyling;

    private:
        int numberOfEntitiesInFile;
    };
}

#endif