A simple test for PatchCoverageProvider

modules/globebrowsing/CMakeLists.txt

@@ -48,6 +48,7 @@ set(HEADER_FILES
 
     ${CMAKE_CURRENT_SOURCE_DIR}/other/distanceswitch.h
     ${CMAKE_CURRENT_SOURCE_DIR}/other/texturetileset.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/other/patchcoverageprovider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/other/tileprovider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/other/gdaldataconverter.h
     ${CMAKE_CURRENT_SOURCE_DIR}/other/lrucache.h
@@ -79,6 +80,7 @@ set(SOURCE_FILES
 
     ${CMAKE_CURRENT_SOURCE_DIR}/other/distanceswitch.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/other/texturetileset.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/other/patchcoverageprovider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/other/tileprovider.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/other/gdaldataconverter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/other/lrucache.inl

modules/globebrowsing/geodetics/geodetic2.cpp

@@ -95,6 +95,9 @@ namespace openspace {
         return x ^ (y << 16) ^ (level << 21);
     }
 
+    bool GeodeticTileIndex::operator==(const GeodeticTileIndex& other) const {
+        return x == other.x && y == other.y && level == other.level;
+    }
 
     //////////////////////////////////////////////////////////////////////////////////////
     //							 	GEODETICPATCH										//

modules/globebrowsing/geodetics/geodetic2.h

@@ -95,6 +95,8 @@ struct GeodeticTileIndex {
     int x, y, level;
 
     HashKey hashKey() const;
+
+    bool operator==(const GeodeticTileIndex& other) const;
 };
 
 

modules/globebrowsing/globes/clipmapglobe.cpp

@@ -80,7 +80,7 @@ namespace openspace {
 	void ClipMapGlobe::render(const RenderData& data)
 	{
 		// TODO : Choose the max depth and the min depth depending on the camera
-		int maxDepth = 10;
+		int maxDepth = 3;
 		int minDepth = 0;
 		// render patches
 		for (size_t i = minDepth; i < maxDepth; i++)

modules/globebrowsing/other/patchcoverageprovider.cpp

@@ -0,0 +1,111 @@
+/*****************************************************************************************
+*                                                                                       *
+* 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/other/patchcoverageprovider.h>
+
+#include <ghoul/logging/logmanager.h>
+
+#include <glm/glm.hpp>
+
+namespace {
+    const std::string _loggerCat = "PatchCoverageProvider";
+}
+
+namespace openspace {
+
+    PatchCoverageProvider::PatchCoverageProvider(
+        Geodetic2 sizeLevel0,
+        Geodetic2 offsetLevel0,
+        int depth)
+        : _sizeLevel0(sizeLevel0)
+        , _offsetLevel0(offsetLevel0)
+        , _depth(depth)
+    {
+
+    }
+
+    PatchCoverageProvider::~PatchCoverageProvider(){
+
+    }
+
+    GeodeticTileIndex PatchCoverageProvider::getTileIndex(const GeodeticPatch& patch) {
+        // Calculate the level of the index depanding on the size of the incoming patch.
+        // The level is as big as possible (as far down as possible) but it can't be
+        // too big since at maximum four tiles should be used to cover a patch
+        int level = log2(static_cast<int>(glm::max(
+            _sizeLevel0.lat / (patch.size().lat),
+            _sizeLevel0.lon / (patch.size().lon))));
+        
+        // If the depth is not big enough, the level must be clamped.
+        level = glm::min(level, _depth);
+        
+        // Calculate the index in x y where the tile should be positioned
+        Vec2 tileSize = _sizeLevel0.toLonLatVec2() / pow(2, level);
+        Vec2 nw = patch.northWestCorner().toLonLatVec2();
+        Vec2 offset = _offsetLevel0.toLonLatVec2();
+        glm::ivec2 tileIndexXY = (nw - offset) / tileSize;
+
+        // Flip y since indices increase from top to bottom
+        //tileIndexXY.y = pow(2, level - 1) - tileIndexXY.y;
+
+        // Create the tileindex
+        GeodeticTileIndex tileIndex = { tileIndexXY.x, tileIndexXY.y, level };
+        return tileIndex;
+    }
+
+    glm::mat3 PatchCoverageProvider::getUvTransformationPatchToTile(
+        GeodeticPatch patch,
+        const GeodeticTileIndex& tileIndex)
+    {
+        GeodeticPatch tile(tileIndex);
+        return getUvTransformationPatchToTile(patch, tile);
+    }
+
+    glm::mat3 PatchCoverageProvider::getUvTransformationPatchToTile(
+        GeodeticPatch patch,
+        GeodeticPatch tile)
+    {
+        Vec2 posDiff =
+            patch.southWestCorner().toLonLatVec2() -
+            tile.southWestCorner().toLonLatVec2();
+
+        glm::mat3 invTileScale = glm::mat3(
+        {	1 / (tile.size().lon),	        0,								0,
+            0,								1 / (tile.size().lat),          0,
+            0,								0,								1 });
+
+        glm::mat3 globalTranslation = glm::mat3(
+        {	1,			0,			0,
+            0,			1,			0,
+            posDiff.x,	posDiff.y,	1 });
+
+        glm::mat3 patchScale = glm::mat3(
+        {	(patch.halfSize().lon * 2),	0,								0,
+            0,							(patch.halfSize().lat * 2),		0,
+            0,							0,								1 });
+
+        return invTileScale * globalTranslation * patchScale;
+    }
+
+}  // namespace openspace

modules/globebrowsing/other/patchcoverageprovider.h

@@ -0,0 +1,79 @@
+/*****************************************************************************************
+*                                                                                       *
+* 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 __PATCHCOVERAGEPROVIDER_H__
+#define __PATCHCOVERAGEPROVIDER_H__
+
+#include <ghoul/logging/logmanager.h>
+
+#include <modules/globebrowsing/geodetics/geodetic2.h>
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//									PATCH TILE CONVERTER							    //
+//////////////////////////////////////////////////////////////////////////////////////////
+
+namespace openspace {
+    class PatchCoverageProvider
+    {
+    public:
+        PatchCoverageProvider(
+            Geodetic2 sizeLevel0,
+            Geodetic2 offsetLevel0,
+            int depth);
+        ~PatchCoverageProvider();
+
+        /**
+            Returns the index of the tile at an appropriate level.
+            Appropriate meaning that the tile should be at as high level as possible
+            Without the tile being smaller than the patch in lat-lon space.
+            The tile is at least as big as the patch.
+        */
+        GeodeticTileIndex getTileIndex(const GeodeticPatch& patch);
+
+        /**
+            A transformation (translation and scaling) from the texture space of a patch
+            to the texture space of a tile.
+        */
+        glm::mat3 getUvTransformationPatchToTile( 
+            GeodeticPatch patch,
+            const GeodeticTileIndex& tileIndex);
+
+        /**
+            Overloaded function
+        */
+        glm::mat3 getUvTransformationPatchToTile(
+            GeodeticPatch patch,
+            GeodeticPatch tile);
+
+    private:
+        Geodetic2 _sizeLevel0;
+        Geodetic2 _offsetLevel0;
+        int _depth;
+        
+    };
+
+}  // namespace openspace
+
+#endif  // __PATCHCOVERAGEPROVIDER_H__

modules/globebrowsing/other/texturetileset.cpp

@@ -121,7 +121,7 @@ namespace openspace {
         glm::ivec2 tileIndexXY = (nw - offset) / tileSize;
 
         // Flip y since indices increase from top to bottom
-        tileIndexXY.y *= -1;
+        //tileIndexXY.y = pow(2, level - 1) - tileIndexXY.y;
 
         // Create the tileindex
         GeodeticTileIndex tileIndex = { tileIndexXY.x, tileIndexXY.y, level };

modules/globebrowsing/rendering/patchrenderer.cpp

@@ -56,7 +56,7 @@ namespace openspace {
     //							PATCH RENDERER											//
     //////////////////////////////////////////////////////////////////////////////////////
     PatchRenderer::PatchRenderer()
-        : _tileSet(Geodetic2(M_PI, M_PI * 2), Geodetic2(M_PI / 2, -M_PI), 1)
+        : _tileSet(Geodetic2(M_PI * 2, M_PI * 2), Geodetic2(M_PI, -M_PI), 1)
     {
 
     }