src/terralib/gdal/Band.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.

    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/gdal/Band.cpp
 
  \brief This class represents raster band description.
*/

// TerraLib
#include "../core/translator/Translator.h"
#include "../raster/RasterProperty.h"
#include "../raster/Utils.h"
#include "Band.h"
#include "Exception.h"
#include "Raster.h"
#include "Utils.h"

// STL
#include <cassert>
#include <limits>

// GDAL
#include <gdal_priv.h>

te::gdal::Band::Band(Raster* rstPtr, std::size_t idx, GDALRasterBand* gdalRasterBandPtr )
  : te::rst::Band(nullptr, idx),
    m_raster(rstPtr),
    m_rasterBand(gdalRasterBandPtr)
{
  m_gdaltype = m_rasterBand->GetRasterDataType();
  
  m_property = GetBandProperty(m_rasterBand, static_cast<unsigned int>(idx));

  te::rst::SetBlockFunctions(&m_getBuff, &m_getBuffI, &m_setBuff, &m_setBuffI, m_property->getType());

  m_buffer = new unsigned char[getBlockSize()];

  m_x = std::numeric_limits<int>::max();

  m_y = std::numeric_limits<int>::max();

  m_update_buffer = false;  
}

te::gdal::Band::Band(const Band& rhs)
  : te::rst::Band(rhs),
    m_raster(rhs.m_raster),
    m_rasterBand(rhs.m_rasterBand),
    m_getBuff(rhs.m_getBuff),
    m_gdaltype(rhs.m_gdaltype)
{
  m_buffer = new unsigned char[getBlockSize()];

  m_x = std::numeric_limits<int>::max();

  m_y = std::numeric_limits<int>::max();

  m_update_buffer = false;
}

te::gdal::Band::~Band()
{
  if (m_update_buffer)
  {
    CPLErr error = m_rasterBand->WriteBlock(m_x, m_y, m_buffer);

    if(error == CE_Failure || error == CE_Fatal)
    {
      //TODO There are codes that describes the error. Send a message according to it.
    }

    m_rasterBand->FlushCache();
  }

  unsigned char* buff = reinterpret_cast<unsigned char*>(m_buffer);

  delete [] buff;
}

te::rst::Raster* te::gdal::Band::getRaster() const
{
  return m_raster;
}

te::gdal::Band& te::gdal::Band::operator=(const Band& rhs)
{
  assert(m_property->getType() == rhs.m_property->getType());

  if(this != &rhs)
  {
    te::rst::Band::operator=(rhs);

    m_getBuff = rhs.m_getBuff;

    unsigned char* buffer = new unsigned char[rhs.getBlockSize()];

    for (int x = 0; x < m_property->m_nblocksx; ++x)
      for (int y = 0; y < m_property->m_nblocksy; ++y)
      {
        rhs.read(x, y, buffer);

        write(x, y, buffer);
      }

    delete [] buffer;
  }

  return *this;
}

void te::gdal::Band::getValue(unsigned int c, unsigned int r, double& value) const
{
  m_i = placeBuffer(c, r);

  m_getBuff(m_i, m_buffer, &value);
}

void te::gdal::Band::setValue(unsigned int c, unsigned int r, const double value)
{
  m_i = placeBuffer(c, r);

  m_setBuff(m_i, m_buffer, &value);

  m_update_buffer = true;
}

void te::gdal::Band::getIValue(unsigned int c, unsigned int r, double& value) const
{
  m_i = placeBuffer(c, r);

  m_getBuffI(m_i, m_buffer, &value);
}

void te::gdal::Band::setIValue(unsigned int c, unsigned int r, const double value)
{
  m_i = placeBuffer(c, r);

  m_setBuffI(m_i, m_buffer, &value);

  m_update_buffer = true;
}

void te::gdal::Band::read(int x, int y, void* buffer) const
{
  if (m_update_buffer)
  {
    CPLErr error = m_rasterBand->WriteBlock(m_x, m_y, m_buffer);

    if(error == CE_Failure || error == CE_Fatal)
    {
      //TODO There are codes that describes the error. Send a message according to it.
    }

    m_rasterBand->FlushCache();

    m_update_buffer = false;
  }  
  
  CPLErr error = m_rasterBand->ReadBlock(x, y, buffer);

  if(error == CE_Failure || error == CE_Fatal)
  {
    //TODO There are codes that describes the error. Send a message according to it.
  }
}

void* te::gdal::Band::read(int x, int y)
{
  if( ( x != m_x ) || ( y != m_y ) )
  {
    read( x, y, m_buffer );
    m_x = x;
    m_y = y;
  }
  
  return m_buffer;
}

void te::gdal::Band::write(int x, int y, void* buffer)
{
  if (m_update_buffer)
  {
    CPLErr error = m_rasterBand->WriteBlock(m_x, m_y, m_buffer);

    if(error == CE_Failure || error == CE_Fatal)
    {
      //TODO There are codes that describes the error. Send a message according to it.
    }

    m_rasterBand->FlushCache();

    m_update_buffer = false;
  }  
  
  CPLErr error = m_rasterBand->WriteBlock(x, y, buffer);

  if(error == CE_Failure || error == CE_Fatal)
  {
    //TODO There are codes that describes the error. Send a message according to it.
  }
}

std::complex<double> te::gdal::Band::getMinValue(bool readall, unsigned int rs, unsigned int cs, unsigned int rf, unsigned int cf) const
{
  if (rs == 0, cs == 0, rf == 0, cf == 0)
  {
    double min = 0;
    double max = 0;
    double mean = 0;
    double stdDev = 0;

    if (m_rasterBand->GetStatistics(!readall, true, &min, &max, &mean, &stdDev) == CE_None)
    {
      return std::complex<double>(min, 0.0);
    }
  }
  
  return te::rst::Band::getMinValue(readall, rs, cs, rf, cf);
}

std::complex<double> te::gdal::Band::getMaxValue(bool readall, unsigned int rs, unsigned int cs, unsigned int rf, unsigned int cf) const
{
  if (rs == 0, cs == 0, rf == 0, cf == 0)
  {
    double min = 0;
    double max = 0;
    double mean = 0;
    double stdDev = 0;

    if (m_rasterBand->GetStatistics(!readall, true, &min, &max, &mean, &stdDev) == CE_None)
    {
      return std::complex<double>(max, 0.0);
    }
  }

  return te::rst::Band::getMaxValue(readall, rs, cs, rf, cf);
}

std::complex<double> te::gdal::Band::getStdValue(unsigned int rs, unsigned int cs, unsigned int rf, unsigned int cf) const
{
  if (rs == 0, cs == 0, rf == 0, cf == 0)
  {
    double min = 0;
    double max = 0;
    double mean = 0;
    double stdDev = 0;

    if (m_rasterBand->GetStatistics(false, true, &min, &max, &mean, &stdDev) == CE_None)
    {
      return std::complex<double>(stdDev, 0.0);
    }
  }

  return te::rst::Band::getStdValue(rs, cs, rf, cf);
}

std::complex<double> te::gdal::Band::getMeanValue(unsigned int rs, unsigned int cs, unsigned int rf, unsigned int cf) const
{
  if (rs == 0, cs == 0, rf == 0, cf == 0)
  {
    double min = 0;
    double max = 0;
    double mean = 0;
    double stdDev = 0;

    if (m_rasterBand->GetStatistics(false, true, &min, &max, &mean, &stdDev) == CE_None)
    {
      return std::complex<double>(mean, 0.0);
    }
  }
  
  return te::rst::Band::getMeanValue(rs, cs, rf, cf);
}

int te::gdal::Band::placeBuffer(unsigned c, unsigned r) const
{
  assert(c >= 0 && c < m_raster->getNumberOfColumns());
  assert(r >= 0 && r < m_raster->getNumberOfRows());

  m_currX = static_cast<int>(c) / m_property->m_blkw;

  m_currY = static_cast<int>(r) / m_property->m_blkh;

  m_currC = static_cast<int>(c) % m_property->m_blkw;

  m_currR = static_cast<int>(r) % m_property->m_blkh;

  if (m_currX != m_x || m_currY != m_y)
  {
    if (m_update_buffer)
    {
      CPLErr error = m_rasterBand->WriteBlock(m_x, m_y, m_buffer);

      if(error == CE_Failure || error == CE_Fatal)
      {
        //TODO There are codes that describes the error. Send a message according to it.
      }

      m_rasterBand->FlushCache();

      m_update_buffer = false;
    }

    read(m_currX, m_currY, m_buffer);

    m_x = m_currX;

    m_y = m_currY;
  }

// calculates and returns the value of m_i
  return (m_currC + m_currR * m_property->m_blkw);
}