ModelLayer.h

Go to the documentation of this file.

#ifndef GlobeEngine_ModelLayer_h
#define GlobeEngine_ModelLayer_h

#include <string>
#include <vector>

#include "Shader.h"
#include "TextureBundle.h"
#include "BorderObject.h"
#include "NamesObject.h"
#include "GPUProgramFactory.h"
#include "SceneBluePrint.h"
#include "ReferenceSystem.h"
#include "GlobeEngine.h"
#include "CommuterObject.h"
#include "Heightfield.h"
#include "DrawablePolyLine.h"
#include "DouglasPeuckerDrawablePath.h"
#include "Mesh.h"
#include "BundlingObject.h"
#include "MultiLineObject.h"
#include "HousingObject.h"
#include "MessageQueue.h"
#include "TrafficInfoObject.h"
#include "ChartObject.h"
#include "GreatCircleObject.h"
#include "CoatOfArmsObject.h"
#include "GlobeRasterModule.h"
#include "ArrowField.h"
#include "WeatherData.h"

#ifndef Q_MOC_RUN
#include <pcl/point_types.h>
#endif // Q_MOC_RUN

// TMS Support
#include "TileMapService.h"

// AGR Support
#include "agrio.h"

namespace geGIS {
    class TrafficObject;
    
    struct ModelLayerCategories
    {
        enum MODELTYPE{ NONE=0,
                        ELEVATION=1,
                        COMMUTER,
                        TRAFFIC,
                        BORDER,
                        NAMES,
                        HOUSING=6,
                        LINES,
                        POLYGONS,
                        POINTS,
                        REFERENCESYSTEM,
                        BSPLINES,
                        PATHS,
                        CAMERA,
                        MESH,
                        ORTHO,
                        BUNDLING,
                        SINGLELINES,
                        CHARTS,
                        TRAFFICINFO,
                        POINTFEATURE,
                        GREATCIRCLE,
                        COATOFARMS,
                        POI,
                        CLIMATE,
                        ARROWFIELD,
                        ANIMATEDTEXTURE,
                        VOLUME,
        };
    };
    
    struct ModelLayerSelection
    {
        int index;
        enum ModelLayerCategories::MODELTYPE type;
        int entityindex;
    };
    
    struct ModelLayerObjectInformation
    {
        std::string name;
        int numberOfEntities;
        int numberOfPoints;
        int numberOfEdges;
        bool isVisible;
    };
    
    struct ModelLoadInformation
    {
        ModelLayerCategories::MODELTYPE type;
        std::shared_ptr<FeatureBlueprint> blueprint;
    };

    class ModelLayer
    {
    private:
        static const int CATEGORYCOUNT = 13;
    public:
        
        
    public:
        ModelLayer();
        ~ModelLayer();
        
        void clear();
        void clearInitial();
        void deleteShader();
        void create(std::shared_ptr<SceneBlueprint> _sceneBlueprint, GlobeEngine* _engine);
        // runs update loop in case of loading jobs
        void update();
        void loadModelByBlueprint(enum ModelLayerCategories::MODELTYPE _type, std::shared_ptr<FeatureBlueprint> _blueprint);
        void loadFromModelMap();
        
        std::shared_ptr<ge::Shader> loadShaderFromBlueprint(std::shared_ptr<ge::ShaderBlueprint> const& _blueprint);
              
        void updateModels(enum ModelLayerCategories::MODELTYPE _type);
        void updateNames(vmml::Vector3d _center);
        void bundleObject(ModelLayerSelection _selection,enum BundlingCategories::BUNDLINGTYPE _bundlingType=BundlingCategories::NONE, int _index2=0, enum ModelLayerCategories::MODELTYPE _type2=ModelLayerCategories::NONE);
        
        int addBundlingObject(vmml::Vector3f _pos);
        
        void doModelAnimationStep(ModelLayerSelection _selection);
        void setObjectExtrusionXZ(float _input, ModelLayerSelection _selection);
        void setObjectExtrusionY(float _input, ModelLayerSelection _selection);
        void setObjectVisibility(bool _value, ModelLayerSelection _selection);
        void setObjectVisualizationMode(int _value, enum ModelLayerCategories::MODELTYPE _type);
        
        void setObjectThickness(float _in, ModelLayerSelection _selection);
        vmml::Vector2d getObjectMinMax(ModelLayerSelection _selection);
        void updateCommuterObjectBundlingProperty(ModelLayerSelection _selection, BundlingPropertyUpdate _input);
        void updatePickingState(int _groupID, int _objID, int _entID, int _prev_groupID, int _prev_objID, int _prev_entID);
        void setModelLayerSelection(ModelLayerSelection _selection);
        void setHeightScaleForAllLayers(float _input);
        void setHeight(ModelLayerSelection _selection, double _input);
        void setObjectPosition(ModelLayerSelection _selection, vmml::Vector3d _in);
        
        std::shared_ptr<FeatureObject> getWritableFeature(ModelLayerSelection _selection);
        std::shared_ptr<LineFeatureObject> getWritableLineFeature(ModelLayerSelection _selection);
        std::shared_ptr<PointFeatureObject> getWritablePointFeature(ModelLayerSelection _selection);
        
        const std::shared_ptr<FeatureObject> getFeature(ModelLayerSelection _selection);
        const std::shared_ptr<LineFeatureObject> getLineFeature(ModelLayerSelection _selection);
        const std::shared_ptr<ge::DrawableComponent> getObject(ModelLayerSelection _selection);
        std::shared_ptr<ge::DrawableComponent> getWritableObject(ModelLayerSelection _selection);
        
        ModelLayerObjectInformation getObjectInfo(ModelLayerSelection _selection);
        
        unsigned int getObjectListSize(ModelLayerSelection _selection);
        void setObjectColor(ModelLayerSelection _selection, vmml::Vector3f _in);
        ge::DrawableComponent::RENDERSTATE drawModels(enum ModelLayerCategories::MODELTYPE _type, enum ge::DrawableComponent::RENDERSTATE _state, std::shared_ptr<ge::Camera> _cam);
        void setSplinesSegmentsDistance(ModelLayerSelection _selection, float _in);
        
        void switchColorisationEditor(){
            if(this->colorisationOnEditor){
                this->colorisationOnEditor = false;
            }else{
                this->colorisationOnEditor = true;
            }
        }
        
        void setObjectColorRamp(ModelLayerSelection _selection, const std::shared_ptr<geData::ColorisationTable>& _colorTable);
        void setColorEditorColorisation(ModelLayerSelection _selection, unsigned char* _transferFunctionData);

        
        void moveCameraToObject(ModelLayerSelection _selection);

        void addPath(geData::DouglasPeuckerDrawablePath* _pathLine, vmml::Vector3d _pos, int _bundlingIdx);
        
        int addPathObject(std::shared_ptr<geData::PolyLine> _path, std::string _name, bool inLocalCoordinates);

        int addMultiLineObject(std::shared_ptr<geData::MultiLineObject> _object);
        
        int addMultiLineObject();
        
        int addPointCloud(std::shared_ptr<geData::PointCloud> _pointCloud);
        
        
        
        int addPointCloud(int _size);
        
        std::shared_ptr<geGIS::GlobeRasterModule> getTerrainModule();
        
        void saveObject(ModelLayerSelection _selection, std::string _path, std::string _ext);
        void triangulateObject(ModelLayerSelection _selection);
        
        void setInitialScan(double _minHeight, double _maxHeight,  double _interval);
        void performScanStep(double _height);
        void updateInitialScanning();
        bool isInitialScanOn(){
            return initialScanOn;
        }
        
        std::shared_ptr<geData::PointCloud> getPointCloud(int _id);
        std::shared_ptr<geData::MultiLineObject> getMultiLineObject(int _id);

        double getScanHeight(){
            return scanHeight;
        }

        double getHeightScale(){
            return heightScale;
        }
        
        const std::shared_ptr<ReferenceSystem> getReferenceSystem();
        
        bool currentlyPicking();
        ModelLayerSelection getPickedSelection();

    private:
        // selected item
        ModelLayerSelection currentSelection;
        GlobeEngine* engine;
        std::shared_ptr<SceneBlueprint> sceneBlueprint;
        std::shared_ptr<ReferenceSystem> referenceSystem;
        
        std::vector< std::shared_ptr<CommuterObject> > commuterObjectList;
        std::vector< std::shared_ptr<BorderObject> > borderObjectList;
        std::vector< std::shared_ptr<GreatCircle> > greatcircleList;
        std::vector< std::shared_ptr<HousingObject> > housingObjectList;
        std::vector< std::shared_ptr<CoatOfArmsObject> > coaObjectList;
        std::vector< std::shared_ptr<NamesObject> > namesObjectList;
        std::vector< std::shared_ptr<ChartObject> > chartsObjectList;
        std::vector< std::shared_ptr<TrafficInfoObject> > trafficInfoObjectList;
        std::vector< std::shared_ptr<TrafficObject> > trafficObjectList;
        std::vector< std::shared_ptr<geData::Heightfield> > heightfieldlist;
        std::vector< std::shared_ptr<geData::PointCloud> > pointcloudlist;
        std::vector< std::shared_ptr<geData::Mesh> > meshlist;
        std::vector< std::shared_ptr<BundlingObject> > bundlingObjectList;
        std::vector< std::shared_ptr<geData::MultiLineObject> > multiLineObjectList;
        std::vector< std::shared_ptr<geData::DrawablePolyLine> > pathList;
        std::vector< std::shared_ptr<ge::PositionBlueprint> > pointOfInterestList;
        
        
        // Climate data objects
        std::vector< std::shared_ptr<geFlow::ArrowField> > climateArrowfields;
        std::vector<std::shared_ptr<ge::TextureBundle> > climateCloudfields;
        std::vector< std::shared_ptr<ge::Texture2Df> > climateClouds;
        std::vector< std::shared_ptr<ge::Plane> > climateCloudPlanes;
        std::shared_ptr<geFlow::WeatherData> weatherData;
        // object to animate the streamlines
        std::shared_ptr<ge::Animation> borderAnimation;

        // Standardshader
        //ge::ShaderMap shaderMap;
        std::string shaderPath;
        std::string genericShaderPath;

        
        // GPU Programs
        ge::GPUProgramFactory* gpuprogrammanager;
        ge::GPUProgram* vectorprogram;
        
        // Elevation Data
        float heightScale;
        std::shared_ptr<geGIS::GlobeRasterModule> terrainmodule;
        
        //std::shared_ptr<geData::ColorisationTable> heightColor;
        //std::shared_ptr<geData::ColorisationTable> editorColor;
        std::shared_ptr<ge::Texture1Drgba> transferFunctionTexture;
        
        bool colorisationOnEditor;
        
        // initial occlusion query scanning
        int steps; 
        double scanHeight;
        double minScanHeight;
        double scanStepSize;
        bool initialScanOn;
        
        geSpatial::MessageQueue* featureServiceProvider;

        bool objectIsCurrentlyPicked;
        ModelLayerSelection pickingSelection;

        ge::Timer timer;
    };
}
#endif