merge

modules/globebrowsing/other/gdaldataconverter.h

@@ -81,7 +81,7 @@ namespace openspace {
         std::shared_ptr<UninitializedTextureTile> getUninitializedTextureTile(
             GDALDataset * dataSet,
             ChunkIndex chunkIndex,
-            int minNumPixelsRequired);
+            int tileLevelDifference);
 
         UninitializedTextureTile::TextureFormat getTextureFormat(
             int rasterCount,

modules/globebrowsing/other/gdaldataconverter.inl

@@ -47,7 +47,8 @@ namespace openspace {
     std::shared_ptr<UninitializedTextureTile> GdalDataConverter<T>::getUninitializedTextureTile(
         GDALDataset* dataSet,
         ChunkIndex chunkIndex,
-        int minNumPixelsRequired) 
+        int tileLevelDifference)
+
     {
         int nRasters = dataSet->GetRasterCount();
 
@@ -74,7 +75,8 @@ namespace openspace {
 
         // Calculate a suitable overview to choose from the GDAL dataset
         int minNumPixels0 = glm::min(numPixels0.x, numPixels0.y);
-        int ov = log2(minNumPixels0) - log2(minNumPixelsRequired + 1);
+        int sizeLevel0 = firstBand->GetOverview(numOverviews - 1)->GetXSize();
+        int ov = log2(minNumPixels0) - log2(sizeLevel0 + 1) - tileLevelDifference;
         ov = glm::clamp(ov, 0, numOverviews - 1);
 
         // Convert the interval [pixelStart0, pixelEnd0] to pixel space at 

modules/globebrowsing/other/tileprovider.cpp

@@ -51,7 +51,6 @@ namespace openspace {
         int minimumPixelSize)
     : _filePath(filePath)
     , _tileCache(tileCacheSize) // setting cache size
-    , _minimumPixelSize(minimumPixelSize)
     {
         // Set a temporary texture
         std::string fileName = "textures/earth_bluemarble.jpg";
@@ -81,13 +80,17 @@ namespace openspace {
             hasInitializedGDAL = true;
         }
 
-        
-
         std::string absFilePath = absPath(filePath);
         _gdalDataSet = (GDALDataset *)GDALOpen(absFilePath.c_str(), GA_ReadOnly);
         //auto desc = _gdalDataSet->GetDescription();
         
         ghoul_assert(_gdalDataSet != nullptr, "Failed to load dataset: " << filePath);
+
+        GDALRasterBand* firstBand = _gdalDataSet->GetRasterBand(1);
+        int numOverviews = firstBand->GetOverviewCount();
+        int sizeLevel0 = firstBand->GetOverview(numOverviews - 1)->GetXSize();
+
+        _tileLevelDifference = log2(minimumPixelSize) - log2(sizeLevel0);
     }
 
     TileProvider::~TileProvider(){
@@ -109,6 +112,31 @@ namespace openspace {
         std::shared_ptr<Texture> tex = nullptr;
         glm::vec2 uvOffset(0, 0);
         glm::vec2 uvScale(1, 1);
+        
+        // Check if we are trying to get a texture for a very small patch.
+        // In that case, use the biggest one defined for the dataset.
+        int maximumAllowedLevel =
+            _gdalDataSet->GetRasterBand(1)->GetOverviewCount() - 1;
+        int levelInDataset = chunkIndex.level + _tileLevelDifference;
+        int timesToStepUp = levelInDataset - maximumAllowedLevel;
+        for (int i = 0; i < timesToStepUp; i++)
+        {
+            uvScale *= 0.5;
+            uvOffset *= 0.5;
+
+            if (chunkIndex.isEastChild()) {
+                uvOffset.x += 0.5;
+            }
+
+            // In OpenGL, positive y direction is up
+            if (chunkIndex.isNorthChild()) {
+                uvOffset.y += 0.5;
+            }
+
+            chunkIndex = chunkIndex.parent();
+        }
+        
+        // We also need to check if the wanted texture is available. If not, go up a level
         while (true) {
             tex = getOrStartFetchingTile(chunkIndex);
 
@@ -180,43 +208,45 @@ namespace openspace {
             return _uByteConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
             break;
         case GDT_UInt16:
             return _uShortConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
             break;
         case GDT_Int16:
             return _shortConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
             break;
         case GDT_UInt32:
             return _uIntConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
             break;
         case GDT_Int32:
             return _intConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
             break;
         case GDT_Float32:
             return _floatConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
+
             break;
         case GDT_Float64:
             return _doubleConverter.getUninitializedTextureTile(
                 _gdalDataSet,
                 chunkIndex,
-                _minimumPixelSize);
+                _tileLevelDifference);
+
             break;
         default:
             LERROR("GDAL data type unknown to OpenGL: " << gdalType);

modules/globebrowsing/other/tileprovider.h

@@ -45,18 +45,17 @@
 
 namespace openspace {
     using namespace ghoul::opengl;
-
-
-
-
-    struct Tile {
-        std::shared_ptr<Texture> texture;
+    
+    struct TileTextureTransform
+    {
         glm::vec2 uvOffset;
         glm::vec2 uvScale;
     };
 
-
-    
+    struct Tile {
+        std::shared_ptr<Texture> texture;
+        TileTextureTransform transform;
+    };
 
     /**
         Provides tiles through GDAL datasets which can be defined with xml files
@@ -99,7 +98,7 @@ namespace openspace {
         GDALDataset* _gdalDataSet;
 
         // Converters are needed for all different data types since they are templated.
-        GdalDataConverter<GLubyte>   _uByteConverter;
+        GdalDataConverter<GLubyte>  _uByteConverter;
         GdalDataConverter<GLushort> _uShortConverter;
         GdalDataConverter<GLshort>  _shortConverter;
         GdalDataConverter<GLuint>   _uIntConverter;
@@ -110,7 +109,7 @@ namespace openspace {
         ConcurrentJobManager<UninitializedTextureTile> _tileLoadManager;
 
         std::shared_ptr<Texture> _defaultTexture;
-        int _minimumPixelSize;
+        int _tileLevelDifference;
     };
 
 }  // namespace openspace

modules/globebrowsing/rendering/patchrenderer.cpp

@@ -132,8 +132,9 @@ namespace openspace {
         texUnitHeight.activate();
         heightTile.texture->bind();
         _programObjectGlobalRendering->setUniform("textureSamplerHeight", texUnitHeight);
-        _programObjectGlobalRendering->setUniform("heightSamplingScale", heightTile.uvScale);
-        _programObjectGlobalRendering->setUniform("heightSamplingOffset", heightTile.uvOffset);
+
+        _programObjectGlobalRendering->setUniform("heightSamplingScale", heightTile.transform.uvScale);
+        _programObjectGlobalRendering->setUniform("heightSamplingOffset", heightTile.transform.uvOffset);
 
 
 
@@ -148,8 +149,8 @@ namespace openspace {
         texUnitColor.activate();
         colorTile.texture->bind();
         _programObjectGlobalRendering->setUniform("textureSamplerColor", texUnitColor);
-        _programObjectGlobalRendering->setUniform("colorSamplingScale", colorTile.uvScale);
-        _programObjectGlobalRendering->setUniform("colorSamplingOffset", colorTile.uvOffset);
+        _programObjectGlobalRendering->setUniform("colorSamplingScale", colorTile.transform.uvScale);
+        _programObjectGlobalRendering->setUniform("colorSamplingOffset", colorTile.transform.uvOffset);
 
 
         Geodetic2 swCorner = chunk.surfacePatch().southWestCorner();