ogr/DataSet.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/ogr/DataSet.cpp

  \brief Implementation of a DataSet for OGR data provider.
*/

// TerraLib
#include "../core/translator/Translator.h"
#include "../dataaccess/dataset/DataSetType.h"
#include "../datatype/ByteArray.h"
#include "../datatype/DateTimeProperty.h"
#include "../datatype/StringProperty.h"
#include "../datatype/TimeInstant.h"
#include "../geometry/Envelope.h"
#include "../geometry/Geometry.h"
#include "../geometry/WKBReader.h"
#include "../srs/Config.h"
#include "DataSource.h"
#include "DataSet.h"
#include "Exception.h"
#include "Utils.h"

// OGR
#include <ogrsf_frmts.h>
#include <ogr_core.h>
#include <gdal_priv.h>

// STL
#include <cassert>
#include <memory>

//te::ogr::DataSet::DataSet(OGRDataSource* dsrc, OGRLayer* layer) :
te::ogr::DataSet::DataSet(GDALDataset* dsrc, OGRLayer* layer)
    :

      m_dt(nullptr),
      m_ogrDs(dsrc),
      m_layer(layer),
      m_currentFeature(nullptr),
      m_i(-1),
      m_wkbArray(nullptr),
      m_wkbArraySize(0),
      m_srid(TE_UNKNOWN_SRS)
{
  assert(layer);

  layer->ResetReading();

  m_dt = Convert2TerraLib(layer->GetLayerDefn());
  
  assert(m_dt);

  if(m_dt->hasGeom())
  {
    OGRSpatialReference* osrs = m_layer->GetSpatialRef();
    if(osrs)
      m_srid = Convert2TerraLibProjection(osrs);
  }
}

te::ogr::DataSet::~DataSet()
{
  OGRFeature::DestroyFeature(m_currentFeature);

  delete [] m_wkbArray;

  delete m_dt;

  m_ogrDs->ReleaseResultSet(m_layer);

  //OGRDataSource::DestroyDataSource(m_ogrDs);
  GDALClose(m_ogrDs);
}

std::size_t te::ogr::DataSet::getNumProperties() const
{
  return m_dt->size();
}

int te::ogr::DataSet::getPropertyDataType(std::size_t pos) const
{
  return m_dt->getProperty(pos)->getType();
}

std::string te::ogr::DataSet::getPropertyName(std::size_t pos) const
{
  return m_dt->getProperty(pos)->getName();
}

std::string te::ogr::DataSet::getDatasetNameOfProperty(std::size_t) const
{
  return "";
}

bool te::ogr::DataSet::isEmpty() const
{
  return !(size() > 0);
}

std::unique_ptr<te::gm::Envelope> te::ogr::DataSet::getExtent(std::size_t /*i*/)
{
  OGREnvelope psExtent;
  OGRErr error = m_layer->GetExtent(&psExtent);

  if(error != OGRERR_NONE)
  {
    //TODO There are codes that describes the error. Send a message according to it.
    throw Exception(TE_TR("Fail getting extent from OGR dataset."));
  }

  te::gm::Envelope* env =  Convert2TerraLib(&psExtent);
  return std::unique_ptr<te::gm::Envelope>(env);
}

std::size_t te::ogr::DataSet::size() const
{
  return static_cast<std::size_t>(m_layer->GetFeatureCount());
}

bool te::ogr::DataSet::moveNext()
{
  OGRFeature::DestroyFeature(m_currentFeature);

  m_currentFeature = m_layer->GetNextFeature();

  m_i++;
  return m_currentFeature != nullptr;
}

bool te::ogr::DataSet::movePrevious()
{
  return move(static_cast<size_t>(m_i - 1));
}

bool te::ogr::DataSet::moveBeforeFirst()
{
  m_layer->ResetReading();
  m_i = -1;
  return true;
}

bool te::ogr::DataSet::moveFirst()
{
  m_layer->ResetReading();
  m_i = -1;
  return moveNext();
}

bool te::ogr::DataSet::moveLast()
{
  size_t lastPos = static_cast<size_t>(m_layer->GetFeatureCount() - 1);
  return move(lastPos);
}

bool te::ogr::DataSet::move(std::size_t i)
{
  if(static_cast<size_t>(m_i) == i)
    return true;

  int p = static_cast<int>(i);

  OGRErr error = m_layer->SetNextByIndex(p);

  m_i = p - 1;
  if(error == OGRERR_NONE)
    return moveNext();
  else
    return false;
}

bool te::ogr::DataSet::isAtBegin() const
{
  return m_i == 0;
}

bool te::ogr::DataSet::isBeforeBegin() const
{
  return m_i < 0;
}

bool te::ogr::DataSet::isAtEnd() const
{
  return m_i == static_cast<int>(size()-1);
}

bool te::ogr::DataSet::isAfterEnd() const
{
  return m_i > static_cast<int>(size());
}

bool te::ogr::DataSet::isPositionValid() const
{
  return m_i > -1 && m_i < static_cast<int>(size());
}

char te::ogr::DataSet::getChar(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getChar not supported."));
}

unsigned char te::ogr::DataSet::getUChar(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getUChar not supported."));
}

boost::int16_t te::ogr::DataSet::getInt16(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getInt16 not supported."));
}

boost::int32_t te::ogr::DataSet::getInt32(std::size_t i) const
{
  return m_currentFeature->GetFieldAsInteger(static_cast<int>(i));
}

boost::int64_t te::ogr::DataSet::getInt64(std::size_t i) const
{
  return m_currentFeature->GetFieldAsInteger64(static_cast<int>(i));
}

bool te::ogr::DataSet::getBool(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getBool not supported."));
}

float te::ogr::DataSet::getFloat(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getFloat not supported."));
}

double te::ogr::DataSet::getDouble(std::size_t i) const
{
  return m_currentFeature->GetFieldAsDouble(static_cast<int>(i));
}

std::string te::ogr::DataSet::getNumeric(std::size_t i) const
{
  return m_currentFeature->GetFieldAsString(static_cast<int>(i));
}

std::string te::ogr::DataSet::getString(std::size_t i) const
{
  return m_currentFeature->GetFieldAsString(static_cast<int>(i));
}

std::unique_ptr<te::dt::ByteArray> te::ogr::DataSet::getByteArray(std::size_t i) const
{
  int size = 0;
  GByte* bytes = m_currentFeature->GetFieldAsBinary(static_cast<int>(i), &size);

  te::dt::ByteArray* byteArray = new te::dt::ByteArray(static_cast<size_t>(size));
  byteArray->copy(reinterpret_cast<char*>(bytes), static_cast<size_t>(size));
  
  return std::unique_ptr<te::dt::ByteArray>(byteArray);
}

std::unique_ptr<te::gm::Geometry> te::ogr::DataSet::getGeometry(std::size_t /*i*/) const
{
  char* wkb = (char*)getWKB();

  te::gm::Geometry* geom = nullptr;

  if (wkb)
  {
    geom = te::gm::WKBReader::read(wkb);
    geom->setSRID(m_srid);
  }

  return std::unique_ptr<te::gm::Geometry>(geom);
}

std::unique_ptr<te::rst::Raster> te::ogr::DataSet::getRaster(std::size_t /*i*/) const
{
  throw te::common::Exception(TE_TR("OGR driver: getRaster not supported."));
}

std::unique_ptr<te::dt::DateTime> te::ogr::DataSet::getDateTime(std::size_t i) const
{
  if(m_dt == nullptr)
    return std::unique_ptr<te::dt::DateTime>(nullptr);

  int pnYear,
      pnMonth,
      pnDay,
      pnHour,
      pnMinute,
      pnSecond,
      pnTZFlag;

  if(m_currentFeature->GetFieldAsDateTime(static_cast<int>(i), &pnYear, &pnMonth, &pnDay, &pnHour, &pnMinute, &pnSecond, &pnTZFlag) == FALSE)
    return std::unique_ptr<te::dt::DateTime>(new te::dt::Date);

  te::dt::Property* p = m_dt->getProperty(i);
  te::dt::DateTimeType subType = static_cast<te::dt::DateTimeProperty*>(p)->getSubType();
  te::dt::DateTime* dateTime = nullptr;

  if(subType == te::dt::DATE)
  {
    dateTime = new te::dt::Date(static_cast<unsigned short>(pnYear), static_cast<unsigned short>(pnMonth), static_cast<unsigned short>(pnDay));
  }
  else if(subType == te::dt::TIME_DURATION)
  {
    dateTime = new te::dt::TimeDuration(pnHour, pnMinute, pnSecond);
  }
  else if(subType == te::dt::TIME_INSTANT)
  {
    te::dt::Date d(static_cast<unsigned short>(pnYear), static_cast<unsigned short>(pnMonth), static_cast<unsigned short>(pnDay));
    te::dt::TimeDuration td(pnHour, pnMinute, pnSecond);
    dateTime = new te::dt::TimeInstant(d, td);
  }

  return std::unique_ptr<te::dt::DateTime>(dateTime);
}

std::unique_ptr<te::dt::Array> te::ogr::DataSet::getArray(std::size_t /*i*/) const
{
  return std::unique_ptr<te::dt::Array>(); // Not supported by OGR library
}

bool te::ogr::DataSet::isNull(std::size_t i) const
{
  if(m_currentFeature->IsFieldSet(static_cast<int>(i)) == 0)
    return true;

  if (getPropertyDataType(i) == te::dt::GEOMETRY_TYPE)
  {
    OGRGeometry* geom = m_currentFeature->GetGeometryRef();

    if (geom == nullptr || geom->IsEmpty())
    {
      OGRGeometryFactory::destroyGeometry(geom);
      return true;
    }
  }

  return false;
}

const unsigned char* te::ogr::DataSet::getWKB() const
{
  OGRGeometry* geom;

  // The OGR library supports only one geometry field
  if (m_currentFeature->GetGeometryRef())
    geom = m_currentFeature->GetGeometryRef()->clone();
  else
    return nullptr;

  if(geom == nullptr)
    return nullptr;

  if (geom->getGeometryType() == wkbPolygon ||
      geom->getGeometryType() == wkbPolygonM ||
      geom->getGeometryType() == wkbPolygonZM ||
      geom->getGeometryType() == wkbPolygon25D)
  {
    geom = OGRGeometryFactory::forceToMultiPolygon(geom);
  }
  else if (geom->getGeometryType() == wkbLineString ||
           geom->getGeometryType() == wkbLineStringM ||
           geom->getGeometryType() == wkbLineStringZM ||
           geom->getGeometryType() == wkbLineString25D)
  {
    geom = OGRGeometryFactory::forceToMultiLineString(geom);
  }
  else if (geom->getGeometryType() == wkbPoint ||
           geom->getGeometryType() == wkbPointM ||
           geom->getGeometryType() == wkbPointZM ||
           geom->getGeometryType() == wkbPoint25D)
  {
    geom = OGRGeometryFactory::forceToMultiPoint(geom);
  }

  int wkbSize = geom->WkbSize();
  
  if(wkbSize > m_wkbArraySize)
  {
    m_wkbArraySize = wkbSize;
    delete [] m_wkbArray;
    m_wkbArray = new unsigned char[m_wkbArraySize];
  }

  geom->exportToWkb(wkbNDR, m_wkbArray, wkbVariantIso);

  OGRGeometryFactory::destroyGeometry(geom);

  return static_cast<const unsigned char*>(m_wkbArray);
}