TileMapService.hpp

Go to the documentation of this file.

//
//  TileMapService.hpp
//  GlobeEngine
//
//  Created by Alireza Amiraghdam on 15/05/16.
//
//

#ifndef TileMapService_hpp
#define TileMapService_hpp

#include <stdio.h>
#include <string>
#include "TMSXml.hpp"
#include "GlobeEngineGeoTiff.h"
#include "TileManager.hpp"
#include <vmmlib/vmmlib.hpp>
#include "SpatialKey.h"
#include "NormalCommand.h"

namespace geTerrainPreprocess{

    struct TMSTileSetting{
        int tileSize;
        int bitPerSample = -1;
        int samplePerPixel = -1;
        int sampleFormat = -1;//1=UINT,2=INT,3=FLOAT
        /* colorSpace:
         * -1= from input;
         * 0 = WhiteIsZero. For bilevel and grayscale images: 0 is imaged as white.
         * 1 = BlackIsZero. For bilevel and grayscale images: 0 is imaged as black.
         * 2 = RGB. RGB value of (0,0,0) represents black, and (255,255,255) represents white, assuming 8-bit components.
         */
        int colorSpace = -1;
        std::string endFileName;
        std::string extension;
    };

    class TileMapService
    {
    private:
        std::string location;
        int maxLod;
        TMSTileSetting tmsTileSetting;
        TMSXml tmsXml;
        std::vector<vmml::Vector2d> pixelScalings;
        TileManager tileManager;
        std::function<void(int const&)> callbackProgress = nullptr;
        std::function<void(std::string const&)> callbackLog = nullptr;
        NormalCommand *normalCommand;
        bool maxminZero = false;
        std::string normalExtension;
        std::string normalEndOfFileName;
        unsigned short overlapping = 1;
        int compression = 1;
    public:
        TileMapService();
        void initTiles(TMSTileSetting _tmsTileSetting){ tmsTileSetting = _tmsTileSetting; calculatePixelScaling(); };
        void load();
        void loadNormal();
        void generateXml();
        void importTiff(std::string _fileName, double _scale);
        void produceNormal();
        void readTileSetting();
        void calculatePixelScaling();
        std::shared_ptr<vmml::Vector4i> tileOfCoordinate(int _lod, vmml::Vector4f _coor);
        vmml::Vector4d getPCSBoundaryOfTile(geSpatial::SpatialKey2ui _key);
        vmml::Vector4d getPCSBoundaryOfPoint(geSpatial::SpatialKey2ui _key);
        void removeEmptyDirectories();
        void removeZeroTiles();
        void checkAndCreateDirectory(geSpatial::SpatialKey2ui _key);
        void readExistingMaxLod();
        vmml::Vector4i readBoundingAtLod(int _lod);
        void removeZeronNormals();

    public:
        void setLocation(std::string _location){ location = _location[_location.size() - 1] == '/' ? _location.substr(0, _location.size() - 1) : _location; };
        std::string getLocaiton(){ return location; };
        void setMaxLod(int _maxLod){ maxLod = _maxLod; };
        int getMaxLod(){ return maxLod; };
        int getTileSize(){ return tmsTileSetting.tileSize; };
        vmml::Vector2i getUVforTilesAtLod(int _Lod);
        double getPixelScaleX(short _lod){ return pixelScalings[_lod].x(); };
        double getPixelScaleY(short _lod){ return pixelScalings[_lod].y(); };
        void setBitPerSample(int _bitPerSample){ tmsTileSetting.bitPerSample = _bitPerSample; };
        void setSampleFormat(int _sampleFormat){ tmsTileSetting.sampleFormat = _sampleFormat; };
        int getBitPerSample(){ return tmsTileSetting.bitPerSample; };
        int getSampleFormat(){ return tmsTileSetting.sampleFormat; };
        int getSamplePerPixel(){ return tmsTileSetting.samplePerPixel; };
        int getColorSpace(){ return tmsTileSetting.colorSpace; };
        void setSamplePerPixel(int _SamplePerPixel){ tmsTileSetting.samplePerPixel = _SamplePerPixel; };
        void setColorSpace(int _ColorSpace){ tmsTileSetting.colorSpace = _ColorSpace; };
        void setCallbackProgress(std::function<void(int const&)> const& _callbackProgress){ callbackProgress = _callbackProgress; };
        void setCallbackLog(std::function<void(std::string const&)> const& _callbackLog){ callbackLog = _callbackLog; };
        std::function<void(int const&)> getCallbackProgress(){ return callbackProgress; };
        TileManager getTileManager(){ return tileManager; };
        void setExtension(std::string _extension){ tmsTileSetting.extension = _extension; };
        std::string getExtension(){ return tmsTileSetting.extension; };
        void setEndFileName(std::string _endFileName){ tmsTileSetting.endFileName = _endFileName; };
        std::string getEndFileName(){ return tmsTileSetting.endFileName; };
        void setNormalCommand(NormalCommand *_nc){ normalCommand = _nc; };
        NormalCommand *getNormalCommand(){ return normalCommand; };
        void setMaxMinZero(){ maxminZero = true; };
        void unsetMaxMinZero(){ maxminZero = false; };
        void setNormalExtension(std::string _normalExtension){ normalExtension = _normalExtension; };
        std::string getNormalExtension(){ return normalExtension; };
        void setNormalEndOfFileName(std::string _normalEndOfFileName){ normalEndOfFileName = _normalEndOfFileName; };
        std::string getNormalEndOfFileName(){ return normalEndOfFileName; };
        void setOverlapping(int _overlapping){ overlapping = _overlapping; };
        unsigned short getoverlapping(){ return overlapping; };
        void setCompression(int _compression){ compression = _compression; };
        int getCompression(){ return compression; };
    private:
        void createTilesInLodFromImage(int _lod, geoTiffIo::GlobeEngineGeoTiff _gTiff, double _scale);
        void mergeUp(int _fromLod, int _toLod);
        geoTiffIo::ScanLineBufferPtr ComputeNormalBuffer(geoTiffIo::ScanLineBufferPtr _bufin1, geoTiffIo::ScanLineBufferPtr _bufin2, geoTiffIo::ScanLineBufferPtr _bufin3);
    };
}

#endif /* TileMapService_hpp */