Add TileProviderByLevel and use for Earth

data/scene/lodglobes/lodearth/lodearth.mod

@@ -57,8 +57,18 @@ return {
             Layers = {
                 ColorLayers = {
                     {
-                        Name = "ESRI Imagery World 2D",
-                        FilePath = "map_service_configs/ESRI/ESRI_Imagery_World_2D.wms",
+                        Name = "ESRI VIIRS Combo",
+                        Type = "ByLevel",
+                        LevelTileProviders = {
+                            {
+                                MaxLevel = 7, 
+                                TileProvider = { FilePath = "map_service_configs/GIBS/VIIRS_SNPP_CorrectedReflectance_TrueColor.xml", }, 
+                            },
+                            {
+                                MaxLevel = 22, 
+                                TileProvider = { FilePath = "map_service_configs/ESRI/ESRI_Imagery_World_2D.wms" },
+                            },
+                        },
                         Enabled = true,
                     },
                     {
@@ -71,15 +81,10 @@ return {
                         Name = "Temporal_GHRSST_L4_MUR_Sea_Surface_Temperature",
                         FilePath = "map_service_configs/GIBS/Temporal_GHRSST_L4_MUR_Sea_Surface_Temperature.xml",
                     },
-                    {
-                        Name = "VIIRS_SNPP_CorrectedReflectance_TrueColor",
-                        FilePath = "map_service_configs/GIBS/VIIRS_SNPP_CorrectedReflectance_TrueColor.xml",
-                        Enabled = true,
-                    },
                     {
                         Type = "SingleImage",
                         Name = "Debug Tiles",
-                        FilePath = "textures/test_tile.png",
+                        FilePath = "../../debugglobe/textures/test_tile.png",
                     },
                 },
                 GrayScaleLayers = { },
@@ -111,12 +116,30 @@ return {
                         Name = "Reference_Labels",
                         FilePath = "map_service_configs/GIBS/Reference_Labels.xml",
                     },
+                    {
+                        Type = "TileIndex",
+                        Name = "Tile Indices",
+                    },
                     {
                         Type = "SizeReference",
                         Name = "Size Reference",
                         Radii = earthEllipsoid,
                         BackgroundImagePath = "../../debugglobe/textures/arrows.png",
                     },
+                    --[[{
+                        Name = "Test",
+                        Type = "LevelSpecific",
+                        LevelTileProviders = {
+                            {
+                                MaxLevel = 5,
+                                TileProvider = { Type = "TileIndex" },
+                            },
+                            {
+                                MaxLevel = 7,
+                                TileProvider = { Type = "SingleImage", FilePath = "../../debugglobe/textures/test_tile.png",},
+                            },
+                        },
+                    },]]
                 },
                 HeightLayers = {
                     {

modules/globebrowsing/CMakeLists.txt

@@ -47,6 +47,7 @@ set(HEADER_FILES
 
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/tileprovider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/singleimageprovider.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/tileproviderbylevel.h
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/texttileprovider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/cachingtileprovider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/temporaltileprovider.h
@@ -99,6 +100,7 @@ set(SOURCE_FILES
 
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/tileprovider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/singleimageprovider.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/tileproviderbylevel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/texttileprovider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/cachingtileprovider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovider/temporaltileprovider.cpp

modules/globebrowsing/globebrowsingmodule.cpp

@@ -36,6 +36,7 @@
 #include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
 #include <modules/globebrowsing/tile/tileprovider/cachingtileprovider.h>
 #include <modules/globebrowsing/tile/tileprovider/singleimageprovider.h>
+#include <modules/globebrowsing/tile/tileprovider/tileproviderbylevel.h>
 #include <modules/globebrowsing/tile/tileprovider/temporaltileprovider.h>
 #include <modules/globebrowsing/tile/tileprovider/texttileprovider.h>
 
@@ -65,6 +66,7 @@ void GlobeBrowsingModule::internalInitialize() {
     fTileProvider->registerClass<globebrowsing::TemporalTileProvider>("Temporal");
     fTileProvider->registerClass<globebrowsing::TileIndexTileProvider>("TileIndex");
     fTileProvider->registerClass<globebrowsing::SizeReferenceTileProvider>("SizeReference");
+    fTileProvider->registerClass<globebrowsing::TileProviderByLevel>("ByLevel");
 }
 
 } // namespace openspace

modules/globebrowsing/tile/tileprovider/tileproviderbylevel.cpp

@@ -0,0 +1,129 @@
+/*****************************************************************************************
+*                                                                                       *
+* OpenSpace                                                                             *
+*                                                                                       *
+* Copyright (c) 2014-2016                                                               *
+*                                                                                       *
+* Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+* software and associated documentation files (the "Software"), to deal in the Software *
+* without restriction, including without limitation the rights to use, copy, modify,    *
+* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+* permit persons to whom the Software is furnished to do so, subject to the following   *
+* conditions:                                                                           *
+*                                                                                       *
+* The above copyright notice and this permission notice shall be included in all copies *
+* or substantial portions of the Software.                                              *
+*                                                                                       *
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+****************************************************************************************/
+
+#include <modules/globebrowsing/geometry/geodetic2.h>
+#include <modules/globebrowsing/tile/tileprovider/tileproviderbylevel.h>
+#include <modules/globebrowsing/tile/tileindex.h>
+
+#include <ghoul/io/texture/texturereader.h>
+#include <ghoul/filesystem/filesystem.h>
+#include <ghoul/logging/logmanager.h>
+
+#include <openspace/engine/openspaceengine.h>
+
+namespace {
+    const std::string _loggerCat = "TileProviderByLevel";
+
+    const std::string KeyProviders = "LevelTileProviders";
+    const std::string KeyMaxLevel = "MaxLevel";
+    const std::string KeyTileProvider = "TileProvider";
+}
+
+namespace openspace {
+namespace globebrowsing {
+
+    TileProviderByLevel::TileProviderByLevel(const ghoul::Dictionary& dictionary) {
+        
+        ghoul::Dictionary levelProvidersDict = dictionary.value<ghoul::Dictionary>(KeyProviders);
+        for (size_t i = 0; i < levelProvidersDict.size(); i++) {
+            std::string dictKey = std::to_string(i + 1);
+            ghoul::Dictionary levelProviderDict = levelProvidersDict.value<ghoul::Dictionary>(dictKey);
+            double floatMaxLevel;
+            int maxLevel = 0;
+            if (!levelProviderDict.getValue<double>(KeyMaxLevel, floatMaxLevel)) {
+                throw std::runtime_error("Must define key '" + KeyMaxLevel + "'");
+            }
+            maxLevel = std::round(floatMaxLevel);
+            
+            ghoul::Dictionary providerDict;
+            if (!levelProviderDict.getValue<ghoul::Dictionary>(KeyTileProvider, providerDict)) {
+                throw std::runtime_error("Must define key '" + KeyTileProvider + "'");
+            }
+            
+            TileProvider* tileProvider = TileProvider::createFromDictionary(providerDict);
+            _levelTileProviders.push_back(std::shared_ptr<TileProvider>(tileProvider));
+            
+            // Ensure we can represent the max level
+            if(_providerIndices.size() < maxLevel){
+                _providerIndices.resize(maxLevel+1, -1);
+            }
+            
+            // map this level to the tile provider index
+            _providerIndices[maxLevel] = _levelTileProviders.size() - 1;
+        }
+        
+        // Fill in the gaps (value -1) in provider indices, from back to end
+        for(int i = _providerIndices.size() - 2; i>=0; --i){
+            if(_providerIndices[i] == -1){
+                _providerIndices[i] = _providerIndices[i+1];
+            }
+        }
+    }
+
+    Tile TileProviderByLevel::getTile(const TileIndex& tileIndex) {
+        return levelProvider(tileIndex.level)->getTile(tileIndex);
+    }
+
+    Tile TileProviderByLevel::getDefaultTile() {
+        return levelProvider(0)->getDefaultTile();
+    }
+
+    Tile::Status TileProviderByLevel::getTileStatus(const TileIndex& index) {
+        return levelProvider(index.level)->getTileStatus(index);
+    }
+
+    TileDepthTransform TileProviderByLevel::depthTransform() {
+        TileDepthTransform transform;
+        transform.depthOffset = 0.0f;
+        transform.depthScale = 1.0f;
+        return transform;
+    }
+
+    void TileProviderByLevel::update() {
+        for(auto provider : _levelTileProviders){
+            provider->update();
+        }
+    }
+
+    void TileProviderByLevel::reset() {
+        for(auto provider : _levelTileProviders){
+            provider->reset();
+        }
+    }
+
+    int TileProviderByLevel::maxLevel() {
+        return _providerIndices.size()-1;
+    }
+
+    int TileProviderByLevel::providerIndex(int level) const {
+        int clampedLevel = std::max(0, std::min(level, (int)_providerIndices.size()-1));
+        return _providerIndices[clampedLevel];
+    }
+
+    TileProvider* TileProviderByLevel::levelProvider(int level) const{
+        return _levelTileProviders[providerIndex(level)].get();
+    }
+
+} // namespace globebrowsing
+} // namespace openspace

modules/globebrowsing/tile/tileprovider/tileproviderbylevel.h

@@ -0,0 +1,74 @@
+/*****************************************************************************************
+*                                                                                       *
+* OpenSpace                                                                             *
+*                                                                                       *
+* Copyright (c) 2014-2016                                                               *
+*                                                                                       *
+* Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+* software and associated documentation files (the "Software"), to deal in the Software *
+* without restriction, including without limitation the rights to use, copy, modify,    *
+* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+* permit persons to whom the Software is furnished to do so, subject to the following   *
+* conditions:                                                                           *
+*                                                                                       *
+* The above copyright notice and this permission notice shall be included in all copies *
+* or substantial portions of the Software.                                              *
+*                                                                                       *
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+****************************************************************************************/
+
+#ifndef __TILE_PROVIDER_BY_LEVEL__
+#define __TILE_PROVIDER_BY_LEVEL__
+
+#include <modules/globebrowsing/geometry/geodetic2.h>
+#include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
+#include <modules/globebrowsing/tile/asynctilereader.h>
+
+#include <gdal_priv.h>
+
+#include <openspace/engine/downloadmanager.h>
+
+#include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/filesystem.h> // absPath
+#include <ghoul/opengl/texture.h>
+#include <ghoul/io/texture/texturereader.h>
+#include <ghoul/font/fontrenderer.h>
+
+#include <set>
+
+namespace openspace {
+namespace globebrowsing {
+
+    using namespace ghoul::opengl;    
+
+    class TileProviderByLevel : public TileProvider {
+    public:
+        
+        TileProviderByLevel(const ghoul::Dictionary& dictionary);
+        TileProviderByLevel(const std::string& imagePath);
+        virtual ~TileProviderByLevel() { }
+
+        virtual Tile getTile(const TileIndex& tileIndex);
+        virtual Tile getDefaultTile();
+        virtual Tile::Status getTileStatus(const TileIndex& index);
+        virtual TileDepthTransform depthTransform();
+        virtual void update();
+        virtual void reset();
+        virtual int maxLevel();
+    private:
+        inline int providerIndex(int level) const;
+        inline TileProvider* levelProvider(int level) const;
+
+        std::vector<int> _providerIndices;
+        std::vector<std::shared_ptr<TileProvider>> _levelTileProviders;
+    };
+
+} // namespace globebrowsing
+} // namespace openspace
+
+#endif  // __TILE_PROVIDER_BY_LEVEL__