mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-20 19:21:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

Move tile datatype related stuff to separate file

Browse Source
This commit is contained in:
Erik Broberg
2016-06-28 11:59:19 -04:00
parent 81676ed98f
commit dd8bdc69b7
6 changed files with 294 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/globebrowsing/CMakeLists.txt
View File

@@ -53,6 +53,7 @@ set(HEADER_FILES
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileselector.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tilediskcache.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledataset.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledatatype.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileioresult.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.h
@@ -97,6 +98,7 @@ set(SOURCE_FILES
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileselector.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tilediskcache.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledataset.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledatatype.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileioresult.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.cpp

202
modules/globebrowsing/tile/tiledataset.cpp
View File

@@ -50,12 +50,12 @@ namespace {
namespace openspace {
// INIT THIS TO FALSE AFTER REMOVED FROM TILEPROVIDER
bool TileDataset::GdalHasBeenInitialized = false;
bool TileDataset::GdalHasBeenInitialized = false;
TileDataset::TileDataset(const std::string& gdalDatasetDesc, int minimumPixelSize,
TileDataset::TileDataset(const std::string& gdalDatasetDesc, int minimumPixelSize,
bool doPreprocessing, GLuint dataType)
: _minimumPixelSize(minimumPixelSize)
, _doPreprocessing(doPreprocessing)
@@ -64,7 +64,7 @@ namespace openspace {
if (!GdalHasBeenInitialized) {
GDALAllRegister();
CPLSetConfigOption("GDAL_DATA", absPath("${MODULE_GLOBEBROWSING}/gdal_data").c_str());
GdalHasBeenInitialized = true;
}
@@ -102,7 +102,7 @@ namespace openspace {
const int TileDataset::calculateMaxLevel(int tileLevelDifference) {
int numOverviews = _dataset->GetRasterBand(1)->GetOverviewCount();
if (numOverviews <= 0) { // No overviews.
return - tileLevelDifference;
return -tileLevelDifference;
}
else { // Use the overview to get the maximum level.
return numOverviews - 1 - tileLevelDifference;
@@ -114,8 +114,8 @@ namespace openspace {
// Floating point types does not have a fix maximum or minimum value and
// can not be normalized when sampling a texture. Hence no rescaling is needed.
double maximumValue = (_dataLayout.gdalType == GDT_Float32 || _dataLayout.gdalType == GDT_Float64) ?
1.0 : getMaximumValue(_dataLayout.gdalType);
1.0 : TileDataType::getMaximumValue(_dataLayout.gdalType);
TileDepthTransform transform;
transform.depthOffset = firstBand->GetOffset();
transform.depthScale = firstBand->GetScale() * maximumValue;
@@ -130,8 +130,7 @@ namespace openspace {
return _depthTransform;
}
std::shared_ptr<TileIOResult> TileDataset::readTileData(ChunkIndex chunkIndex)
{
std::shared_ptr<TileIOResult> TileDataset::readTileData(ChunkIndex chunkIndex) {
GdalDataRegion region(_dataset, chunkIndex, _tileLevelDifference);
size_t bytesPerLine = _dataLayout.bytesPerPixel * region.numPixels.x;
@@ -201,7 +200,7 @@ namespace openspace {
for (size_t c = 0; c < _dataLayout.numRasters; c++) {
hasMissingData |= result->preprocessData->maxValues[c] == missingDataValue;
}
bool onHighLevel = region.chunkIndex.level > 6;
bool onHighLevel = chunkIndex.level > 6;
if (hasMissingData && onHighLevel) {
result->error = CE_Fatal;
}
@@ -257,7 +256,6 @@ namespace openspace {
preprocessData->minValues[c] = FLT_MAX;
}
ValueReader valueReader = getValueReader(dataLayout.gdalType);
for (size_t y = 0; y < region.numPixels.y; y++) {
size_t yi_flipped = y * bytesPerLine;
size_t yi = (region.numPixels.y - 1 - y) * bytesPerLine;
@@ -265,7 +263,7 @@ namespace openspace {
for (size_t x = 0; x < region.numPixels.x; x++) {
for (size_t c = 0; c < dataLayout.numRasters; c++) {
float val = readFloat(dataLayout.gdalType, &(imageData[yi + i]));
float val = TileDataType::interpretFloat(dataLayout.gdalType, &(imageData[yi + i]));
preprocessData->maxValues[c] = std::max(val, preprocessData->maxValues[c]);
preprocessData->minValues[c] = std::min(val, preprocessData->minValues[c]);
@@ -275,76 +273,14 @@ namespace openspace {
}
for (size_t c = 0; c < dataLayout.numRasters; c++) {
if (preprocessData->maxValues[c] > 8800.0f) {
LDEBUG("Bad preprocess data: " << preprocessData->maxValues[c] << " at " << region.chunkIndex);
//LDEBUG("Bad preprocess data: " << preprocessData->maxValues[c] << " at " << region.chunkIndex);
}
}
return std::shared_ptr<TilePreprocessData>(preprocessData);
}
TileDataset::ValueReader TileDataset::getValueReader(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLubyte*>(src)); };
case GDT_UInt16: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLushort*>(src)); };
case GDT_Int16: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLshort*>(src)); };
case GDT_UInt32: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLuint*>(src)); };
case GDT_Int32: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLint*>(src)); };
case GDT_Float32: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLfloat*>(src)); };
case GDT_Float64: return [](const char* src) { return static_cast<float>(*reinterpret_cast<const GLdouble*>(src)); };
default:
LERROR("Unknown data type");
ghoul_assert(false, "Unknown data type");
return nullptr;
}
}
float TileDataset::readFloat(GDALDataType gdalType, const char* src) {
switch (gdalType) {
case GDT_Byte: return static_cast<float>(*reinterpret_cast<const GLubyte*>(src));
case GDT_UInt16: return static_cast<float>(*reinterpret_cast<const GLushort*>(src));
case GDT_Int16: return static_cast<float>(*reinterpret_cast<const GLshort*>(src));
case GDT_UInt32: return static_cast<float>(*reinterpret_cast<const GLuint*>(src));
case GDT_Int32: return static_cast<float>(*reinterpret_cast<const GLint*>(src));
case GDT_Float32: return static_cast<float>(*reinterpret_cast<const GLfloat*>(src));
case GDT_Float64: return static_cast<float>(*reinterpret_cast<const GLdouble*>(src));
default:
LERROR("Unknown data type");
ghoul_assert(false, "Unknown data type");
return -1.0;
}
}
size_t TileDataset::numberOfBytes(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return sizeof(GLubyte);
case GDT_UInt16: return sizeof(GLushort);
case GDT_Int16: return sizeof(GLshort);
case GDT_UInt32: return sizeof(GLuint);
case GDT_Int32: return sizeof(GLint);
case GDT_Float32: return sizeof(GLfloat);
case GDT_Float64: return sizeof(GLdouble);
default:
LERROR("Unknown data type");
ghoul_assert(false, "Unknown data type");
return -1;
}
}
size_t TileDataset::getMaximumValue(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return 2 << 7;
case GDT_UInt16: return 2 << 15;
case GDT_Int16: return 2 << 14;
case GDT_UInt32: return 2 << 31;
case GDT_Int32: return 2 << 30;
default:
LERROR("Unknown data type");
return -1;
}
}
@@ -387,111 +323,9 @@ namespace openspace {
}
TextureFormat TileDataset::getTextureFormat(
int rasterCount, GDALDataType gdalType)
{
TextureFormat format;
switch (rasterCount) {
case 1: // Red
format.ghoulFormat = Texture::Format::Red;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_R8; break;
case GDT_UInt16: format.glFormat = GL_R16UI; break;
case GDT_Int16: format.glFormat = GL_R16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_R32UI; break;
case GDT_Int32: format.glFormat = GL_R32I; break;
case GDT_Float32: format.glFormat = GL_R32F; break;
//case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 2:
format.ghoulFormat = Texture::Format::RG;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RG8; break;
case GDT_UInt16: format.glFormat = GL_RG16UI; break;
case GDT_Int16: format.glFormat = GL_RG16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RG32UI; break;
case GDT_Int32: format.glFormat = GL_RG32I; break;
case GDT_Float32: format.glFormat = GL_RG32F; break;
case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 3:
format.ghoulFormat = Texture::Format::RGB;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RGB8; break;
case GDT_UInt16: format.glFormat = GL_RGB16UI; break;
case GDT_Int16: format.glFormat = GL_RGB16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RGB32UI; break;
case GDT_Int32: format.glFormat = GL_RGB32I; break;
case GDT_Float32: format.glFormat = GL_RGB32F; break;
// case GDT_Float64: format.glFormat = GL_RED; break;// No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 4:
format.ghoulFormat = Texture::Format::RGBA;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RGBA8; break;
case GDT_UInt16: format.glFormat = GL_RGBA16UI; break;
case GDT_Int16: format.glFormat = GL_RGB16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RGBA32UI; break;
case GDT_Int32: format.glFormat = GL_RGBA32I; break;
case GDT_Float32: format.glFormat = GL_RGBA32F; break;
case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
default:
LERROR("Unknown number of channels for OpenGL texture: " << rasterCount);
break;
}
return format;
}
GLuint TileDataset::getOpenGLDataType(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return GL_UNSIGNED_BYTE;
case GDT_UInt16: return GL_UNSIGNED_SHORT;
case GDT_Int16: return GL_SHORT;
case GDT_UInt32: return GL_UNSIGNED_INT;
case GDT_Int32: return GL_INT;
case GDT_Float32: return GL_FLOAT;
case GDT_Float64: return GL_DOUBLE;
default:
LERROR("GDAL data type unknown to OpenGL: " << gdalType);
return GL_UNSIGNED_BYTE;
}
}
GDALDataType TileDataset::getGdalDataType(GLuint glType) {
switch (glType) {
case GL_UNSIGNED_BYTE: return GDT_Byte;
case GL_UNSIGNED_SHORT: return GDT_UInt16;
case GL_SHORT: return GDT_Int16;
case GL_UNSIGNED_INT: return GDT_UInt32;
case GL_INT: return GDT_Int32;
case GL_FLOAT: return GDT_Float32;
case GL_DOUBLE: return GDT_Float64;
default:
LERROR("OpenGL data type unknown to GDAL: " << glType);
return GDT_Unknown;
}
}
TileDataset::GdalDataRegion::GdalDataRegion(GDALDataset * dataSet,
const ChunkIndex& chunkIndex, int tileLevelDifference)
: chunkIndex(chunkIndex)
{
const ChunkIndex& chunkIndex, int tileLevelDifference) {
GDALRasterBand* firstBand = dataSet->GetRasterBand(1);
@@ -540,6 +374,8 @@ namespace openspace {
pixelStart = glm::uvec2(pixelStart0.x >> toShift, pixelStart0.y >> toShift);
pixelEnd = glm::uvec2(pixelEnd0.x >> toShift, pixelEnd0.y >> toShift);
numPixels = pixelEnd - pixelStart;
}
TileDataset::DataLayout::DataLayout() {
@@ -548,12 +384,12 @@ namespace openspace {
TileDataset::DataLayout::DataLayout(GDALDataset* dataSet, GLuint _glType) {
// Assume all raster bands have the same data type
gdalType = _glType != 0 ? getGdalDataType(glType) : dataSet->GetRasterBand(1)->GetRasterDataType();
glType = getOpenGLDataType(gdalType);
gdalType = _glType != 0 ? TileDataType::getGdalDataType(glType) : dataSet->GetRasterBand(1)->GetRasterDataType();
glType = TileDataType::getOpenGLDataType(gdalType);
numRasters = dataSet->GetRasterCount();
bytesPerDatum = numberOfBytes(gdalType);
bytesPerDatum = TileDataType::numberOfBytes(gdalType);
bytesPerPixel = bytesPerDatum * numRasters;
textureFormat = getTextureFormat(numRasters, gdalType);
textureFormat = TileDataType::getTextureFormat(numRasters, gdalType);
}
} // namespace openspace

43
modules/globebrowsing/tile/tiledataset.h
View File

@@ -25,25 +25,20 @@
#ifndef __TILE_DATASET_H__
#define __TILE_DATASET_H__
//#include <modules/globebrowsing/other/tileprovider.h>
#include <ghoul/opengl/texture.h>
#include <modules/globebrowsing/tile/tileioresult.h>
#include <modules/globebrowsing/geometry/geodetic2.h>
#include <modules/globebrowsing/other/threadpool.h>
#include <ghoul/filesystem/file.h>
#include "gdal_priv.h"
#include <memory>
#include <set>
#include <queue>
#include <iostream>
#include "gdal_priv.h"
#include <ghoul/filesystem/file.h>
#include <ghoul/opengl/texture.h>
#include <modules/globebrowsing/tile/tileioresult.h>
#include <modules/globebrowsing/tile/tiledatatype.h>
#include <modules/globebrowsing/geometry/geodetic2.h>
#include <modules/globebrowsing/other/threadpool.h>
namespace openspace {
using namespace ghoul::opengl;
@@ -73,7 +68,6 @@ namespace openspace {
GDALDataType gdalType;
GLuint glType;
size_t bytesPerDatum;
size_t numRasters;
size_t bytesPerPixel;
@@ -96,10 +90,7 @@ namespace openspace {
struct GdalDataRegion {
GdalDataRegion(GDALDataset* dataSet, const ChunkIndex& chunkIndex,
int tileLevelDifference);
const ChunkIndex chunkIndex;
GdalDataRegion(GDALDataset* dataSet, const ChunkIndex& chunkIndex, int tileLevelDifference);
glm::uvec2 pixelStart;
glm::uvec2 pixelEnd;
@@ -122,28 +113,14 @@ namespace openspace {
TileDepthTransform calculateTileDepthTransform();
static int calculateTileLevelDifference(GDALDataset* dataset, int minimumPixelSize);
static glm::uvec2 geodeticToPixel(GDALDataset* dataSet, const Geodetic2& geo);
static GLuint getOpenGLDataType(GDALDataType gdalType);
static GDALDataType getGdalDataType(GLuint glType);
static TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType);
static size_t numberOfBytes(GDALDataType gdalType);
std::shared_ptr<TilePreprocessData> preprocess(const char* imageData,
const GdalDataRegion& region, const DataLayout& dataLayout);
typedef std::function<float(const char*)> ValueReader;
static ValueReader getValueReader(GDALDataType gdalType);
static float readFloat(GDALDataType gdalType, const char* src);
static size_t getMaximumValue(GDALDataType gdalType);
static int calculateTileLevelDifference(GDALDataset* dataset, int minimumPixelSize);
static char* getImageDataFlippedY(const GdalDataRegion& region,
const DataLayout& dataLayout, const char* imageData);

202
modules/globebrowsing/tile/tiledatatype.cpp Normal file
View File

@@ -0,0 +1,202 @@
/*****************************************************************************************
* *
* 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 <ogr_featurestyle.h>
#include <ogr_spatialref.h>
#include <ghoul/logging/logmanager.h>
#include <ghoul/filesystem/filesystem.h> // abspath
#include <ghoul/misc/assert.h>
#include <modules/globebrowsing/tile/tiledatatype.h>
#include <modules/globebrowsing/geometry/angle.h>
#include <float.h>
#include <sstream>
#include <algorithm>
namespace {
const std::string _loggerCat = "TileIOResult";
}
namespace openspace {
float TileDataType::interpretFloat(GDALDataType gdalType, const char* src) {
switch (gdalType) {
case GDT_Byte: return static_cast<float>(*reinterpret_cast<const GLubyte*>(src));
case GDT_UInt16: return static_cast<float>(*reinterpret_cast<const GLushort*>(src));
case GDT_Int16: return static_cast<float>(*reinterpret_cast<const GLshort*>(src));
case GDT_UInt32: return static_cast<float>(*reinterpret_cast<const GLuint*>(src));
case GDT_Int32: return static_cast<float>(*reinterpret_cast<const GLint*>(src));
case GDT_Float32: return static_cast<float>(*reinterpret_cast<const GLfloat*>(src));
case GDT_Float64: return static_cast<float>(*reinterpret_cast<const GLdouble*>(src));
default:
LERROR("Unknown data type");
ghoul_assert(false, "Unknown data type");
return -1.0;
}
}
size_t TileDataType::numberOfBytes(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return sizeof(GLubyte);
case GDT_UInt16: return sizeof(GLushort);
case GDT_Int16: return sizeof(GLshort);
case GDT_UInt32: return sizeof(GLuint);
case GDT_Int32: return sizeof(GLint);
case GDT_Float32: return sizeof(GLfloat);
case GDT_Float64: return sizeof(GLdouble);
default:
LERROR("Unknown data type");
ghoul_assert(false, "Unknown data type");
return -1;
}
}
size_t TileDataType::getMaximumValue(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return 1 << 8;
case GDT_UInt16: return 1 << 16;
case GDT_Int16: return 1 << 15;
case GDT_UInt32: return 1 << 32;
case GDT_Int32: return 1 << 31;
default:
LERROR("Unknown data type");
return -1;
}
}
TextureFormat TileDataType::getTextureFormat(
int rasterCount, GDALDataType gdalType)
{
TextureFormat format;
switch (rasterCount) {
case 1: // Red
format.ghoulFormat = Texture::Format::Red;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_R8; break;
case GDT_UInt16: format.glFormat = GL_R16UI; break;
case GDT_Int16: format.glFormat = GL_R16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_R32UI; break;
case GDT_Int32: format.glFormat = GL_R32I; break;
case GDT_Float32: format.glFormat = GL_R32F; break;
//case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 2:
format.ghoulFormat = Texture::Format::RG;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RG8; break;
case GDT_UInt16: format.glFormat = GL_RG16UI; break;
case GDT_Int16: format.glFormat = GL_RG16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RG32UI; break;
case GDT_Int32: format.glFormat = GL_RG32I; break;
case GDT_Float32: format.glFormat = GL_RG32F; break;
case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 3:
format.ghoulFormat = Texture::Format::RGB;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RGB8; break;
case GDT_UInt16: format.glFormat = GL_RGB16UI; break;
case GDT_Int16: format.glFormat = GL_RGB16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RGB32UI; break;
case GDT_Int32: format.glFormat = GL_RGB32I; break;
case GDT_Float32: format.glFormat = GL_RGB32F; break;
// case GDT_Float64: format.glFormat = GL_RED; break;// No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
case 4:
format.ghoulFormat = Texture::Format::RGBA;
switch (gdalType) {
case GDT_Byte: format.glFormat = GL_RGBA8; break;
case GDT_UInt16: format.glFormat = GL_RGBA16UI; break;
case GDT_Int16: format.glFormat = GL_RGB16_SNORM; break;
case GDT_UInt32: format.glFormat = GL_RGBA32UI; break;
case GDT_Int32: format.glFormat = GL_RGBA32I; break;
case GDT_Float32: format.glFormat = GL_RGBA32F; break;
case GDT_Float64: format.glFormat = GL_RED; break; // No representation of 64 bit float?
default: LERROR("GDAL data type unknown to OpenGL: " << gdalType);
}
break;
default:
LERROR("Unknown number of channels for OpenGL texture: " << rasterCount);
break;
}
return format;
}
GLuint TileDataType::getOpenGLDataType(GDALDataType gdalType) {
switch (gdalType) {
case GDT_Byte: return GL_UNSIGNED_BYTE;
case GDT_UInt16: return GL_UNSIGNED_SHORT;
case GDT_Int16: return GL_SHORT;
case GDT_UInt32: return GL_UNSIGNED_INT;
case GDT_Int32: return GL_INT;
case GDT_Float32: return GL_FLOAT;
case GDT_Float64: return GL_DOUBLE;
default:
LERROR("GDAL data type unknown to OpenGL: " << gdalType);
return GL_UNSIGNED_BYTE;
}
}
GDALDataType TileDataType::getGdalDataType(GLuint glType) {
switch (glType) {
case GL_UNSIGNED_BYTE: return GDT_Byte;
case GL_UNSIGNED_SHORT: return GDT_UInt16;
case GL_SHORT: return GDT_Int16;
case GL_UNSIGNED_INT: return GDT_UInt32;
case GL_INT: return GDT_Int32;
case GL_FLOAT: return GDT_Float32;
case GL_DOUBLE: return GDT_Float64;
default:
LERROR("OpenGL data type unknown to GDAL: " << glType);
return GDT_Unknown;
}
}
} // namespace openspace

60
modules/globebrowsing/tile/tiledatatype.h Normal file
View File

@@ -0,0 +1,60 @@
/*****************************************************************************************
* *
* 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_DATA_TYPE_H__
#define __TILE_DATA_TYPE_H__
#include <ghoul/opengl/texture.h>
#include <modules/globebrowsing/geometry/geodetic2.h>
#include <modules/globebrowsing/tile/tileioresult.h>
#include "gdal_priv.h"
namespace openspace {
struct TileDataType {
static GLuint getOpenGLDataType(GDALDataType gdalType);
static GDALDataType getGdalDataType(GLuint glType);
static TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType);
static size_t getMaximumValue(GDALDataType gdalType);
static size_t numberOfBytes(GDALDataType gdalType);
static float interpretFloat(GDALDataType gdalType, const char* src);
};
} // namespace openspace
#endif // __TILE_DATA_TYPE_H__

2
modules/globebrowsing/tile/tileioresult.cpp
View File

@@ -29,7 +29,7 @@
#include <ghoul/filesystem/filesystem.h> // abspath
#include <ghoul/misc/assert.h>
#include <modules/globebrowsing/tile/tileprovider.h>
#include <modules/globebrowsing/tile/tileioresult.h>
#include <modules/globebrowsing/geometry/angle.h>