ImageDecoder.cpp

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
 
#include "ImageDecoder.h"
#include "GeoTiff.h"
 
namespace {
  using namespace Cogs::Core::TerrainProvider;
}
 
Cogs::Core::TerrainProvider::ImageDecoder::~ImageDecoder()
{
  if (stb_data) {
    stbi_image_free(stb_data);
  }
 
}
 
bool Cogs::Core::TerrainProvider::ImageDecoder::decode(Cogs::TileData& tileData,
                                                       Memory::MemoryBuffer& input, MimeType kind, 
                                                       unsigned suggested_width,
                                                       unsigned suggested_height,
                                                       float suggested_nodata)
{
  switch (kind) {
  case MimeType::Png:
  case MimeType::Gif:
  case MimeType::Jpeg: {
    int width, height, comp;
    stbi_set_flip_vertically_on_load_thread(1);
    stb_data = stbi_load_from_memory((const stbi_uc*)input.data(),
                                     static_cast<int>(input.size()),
                                     &width,
                                     &height,
                                     &comp, 4);
    tileData.format = Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB;
    tileData.width = width;
    tileData.height = height;
    tileData.stride = 0;
    tileData.imageData = stb_data;
    tileData.flags = Cogs::TileDataFlags::None;
    break;
  }
  case MimeType::Tiff: {
    GeoTiffView geotiff(input.data(), input.size());
    if (!geotiff.getFullImage(output, suggested_nodata)) {
      tileData.imageData = nullptr;
      return false;
    }
    tileData.format = geotiff.format;
    tileData.width = geotiff.width;
    tileData.height = geotiff.height;
    tileData.stride = 0;
    tileData.imageData = output.data();
    tileData.minZ = geotiff.minSample.value_or(0.f);
    tileData.maxZ = geotiff.maxSample.value_or(0.f);
    tileData.flags = Cogs::TileDataFlags::ShouldFlip | Cogs::TileDataFlags::IsHeight | TileDataFlags::LinearColorSpace;
    break;
  }
 
  case MimeType::F32: {
    if (input.size() != sizeof(float) * suggested_width * suggested_height) {
      tileData.imageData = nullptr;
      return false;
    }
 
    float min = std::numeric_limits<float>::max();
    float max = -std::numeric_limits<float>::max();
    float* image = (float*)input.data();
    for (size_t i = 0, n = input.size() / sizeof(float); i < n; i++) {
      min = std::min(min, image[i]);
      max = std::max(max, image[i]);
    }
 
    tileData.format = Cogs::TextureFormat::R32_FLOAT;
    tileData.width = suggested_width;
    tileData.height = suggested_height;
    tileData.stride = 0;
    tileData.imageData = input.data();
    tileData.minZ = min;
    tileData.maxZ = max;
    tileData.flags = Cogs::TileDataFlags::None | Cogs::TileDataFlags::IsHeight;
    break;
  }
  case MimeType::RGBA8:
    if (input.size() != 4 * sizeof(uint8_t) * suggested_width * suggested_height) {
      tileData.imageData = nullptr;
      return false;
    }
 
    tileData.format = Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB;
    tileData.width = suggested_width;
    tileData.height = suggested_height;
    tileData.stride = 0;
    tileData.imageData = input.data();
    tileData.flags = Cogs::TileDataFlags::None;
    break;
 
  case MimeType::XML:
  default:
    tileData.imageData = nullptr;
    return false;
  }
  return true;
}