src/terralib/ws/ogc/wms/dataaccess/WMSLayer.cpp

Go to the documentation of this file.

#include "WMSLayer.h"

#include "../../../../dataaccess/datasource/DataSource.h"
#include "../../../../dataaccess/dataset/DataSetType.h"
#include "../../../../dataaccess/utils/Utils.h"
#include "../../../../maptools/AbstractRenderer.h"
#include "../../../../maptools/RendererFactory.h"
#include "../../../../maptools/Utils.h"
#include "../../../../raster/RasterProperty.h"
#include "../../../../raster/BandProperty.h"
#include "../../../../raster/Band.h"
#include "../../../../raster/Grid.h"
#include "../../../../raster/RasterFactory.h"
#include "../../../../memory/DataSet.h"
#include "../../../../memory/DataSetItem.h"
#include "../../../core/Exception.h"
#include "DataSource.h"
#include "Utils.h"

//Boost
#include <boost/format.hpp>

//STL
#include <vector>

const std::string te::ws::ogc::wms::WMSLayer::sm_type("OGCWMSLAYER");

te::ws::ogc::wms::WMSLayer::WMSLayer(te::map::AbstractLayer *parent)
  : te::map::AbstractLayer(parent),
    m_rendererType("OGC_WMS_LAYER_RENDERER"),
    m_currentSRID(TE_UNKNOWN_SRS)
{

}

te::ws::ogc::wms::WMSLayer::WMSLayer(const std::string &id, te::map::AbstractLayer *parent)
  : te::map::AbstractLayer(id, parent),
    m_rendererType("OGC_WMS_LAYER_RENDERER"),
    m_currentSRID(TE_UNKNOWN_SRS)
{

}

te::ws::ogc::wms::WMSLayer::WMSLayer(const std::string &id, const std::string &title, te::map::AbstractLayer *parent)
  : te::map::AbstractLayer(id, title, parent),
    m_rendererType("OGC_WMS_LAYER_RENDERER"),
    m_currentSRID(TE_UNKNOWN_SRS)
{

}

te::ws::ogc::wms::WMSLayer::~WMSLayer() = default;

te::map::AbstractLayer* te::ws::ogc::wms::WMSLayer::clone()
{
  te::ws::ogc::wms::WMSLayer* layer = new te::ws::ogc::wms::WMSLayer;

  te::map::CopyAbstractLayerInfo(this, layer);

  layer->setRendererType(m_rendererType);

  layer->setCurrentSRID(m_currentSRID);
  
  layer->setGetMapRequest(m_getMapRequest);

  return layer;
}

const te::gm::Envelope &te::ws::ogc::wms::WMSLayer::getExtent() const
{
  if(m_currentSRID == TE_UNKNOWN_SRS)
  {
    return te::map::AbstractLayer::getExtent();
  }
  else
  {
    return m_currentExtent;
  }
}

int te::ws::ogc::wms::WMSLayer::getSRID() const
{
  if(m_currentSRID == TE_UNKNOWN_SRS)
  {
    return te::map::AbstractLayer::getSRID();
  }
  else
  {
    return m_currentSRID;
  }
}

void te::ws::ogc::wms::WMSLayer::setCurrentSRID(const int &srid)
{
  if(m_currentSRID == srid)
    return;

  m_currentSRID = srid;

  m_currentExtent = te::map::AbstractLayer::getExtent();

  m_currentExtent.transform(m_srid, m_currentSRID);
}

std::unique_ptr<te::map::LayerSchema> te::ws::ogc::wms::WMSLayer::getSchema() const
{
  if (m_schema.get() == nullptr)
  {
    assert(!m_datasetName.empty());

    try
    {
      te::da::DataSourcePtr ds = te::da::GetDataSource(m_datasourceId, true);

      m_schema = ds->getDataSetType(m_datasetName);
    }
    catch (...)
    {
      te::da::DataSetType* dataSetType = new te::da::DataSetType(m_datasetName);

      m_schema = std::unique_ptr<te::da::DataSetType>(dataSetType);

      return std::unique_ptr<te::map::LayerSchema>(static_cast<te::map::LayerSchema*>(m_schema->clone()));
    }
  }

  return std::unique_ptr<te::map::LayerSchema>(static_cast<te::map::LayerSchema*>(m_schema->clone()));
}

std::unique_ptr<te::da::DataSet> te::ws::ogc::wms::WMSLayer::getData(
    te::common::TraverseType /*travType*/,
    const te::common::AccessPolicy /*accessPolicy*/) const
{
  te::rst::Raster* raster = nullptr;

  try
  {
    raster = te::ws::ogc::wms::GetLayerMapRaster(this);
  }
  catch (...)
  {
    throw te::ws::core::Exception() << te::ErrorDescription(TE_TR("No data is available."));
  }


  if (m_schema.get() == nullptr)
  {
    te::da::DataSourcePtr ds = te::da::GetDataSource(m_datasourceId, true);

    m_schema = ds->getDataSetType(m_datasetName);
  }

  //update internal dataSetType if neeed
  te::rst::RasterProperty* rasterProperty = te::da::GetFirstRasterProperty(m_schema.get());

  if (rasterProperty)
  {
    if (rasterProperty->getBandProperties().empty())
    {
      for (size_t i = 0; i < raster->getNumberOfBands(); i++)
      {
        rasterProperty->add(new te::rst::BandProperty(*raster->getBand(i)->getProperty()));
      }
    }

    rasterProperty->set(new te::rst::Grid(*raster->getGrid()));
  }


  std::unique_ptr<te::map::LayerSchema> dataSetType = getSchema();

  std::map<std::string, std::string> rinfo;

  te::mem::DataSet* dataSet = new te::mem::DataSet(dataSetType.release());

  te::mem::DataSetItem* dataSetItem = new te::mem::DataSetItem(dataSet);

  dataSetItem->setRaster(0, raster);

  dataSet->add(dataSetItem);

  return std::unique_ptr<te::da::DataSet>(dataSet);
}

std::unique_ptr<te::da::DataSet> te::ws::ogc::wms::WMSLayer::getData(const std::string& /*propertyName*/,
                                                                   const te::gm::Envelope* /*e*/,
                                                                   te::gm::SpatialRelation /*r*/,
                                                                   te::common::TraverseType travType,
                                                                   const te::common::AccessPolicy accessPolicy) const
{
  return getData(travType, accessPolicy);
}

std::unique_ptr<te::da::DataSet> te::ws::ogc::wms::WMSLayer::getData(const std::string& /*propertyName*/,
                                                                   const te::gm::Geometry* /*g*/,
                                                                   te::gm::SpatialRelation /*r*/,
                                                                   te::common::TraverseType travType,
                                                                   const te::common::AccessPolicy accessPolicy) const
{
  return getData(travType, accessPolicy);
}

std::unique_ptr<te::da::DataSet> te::ws::ogc::wms::WMSLayer::getData(te::da::Expression* /*restriction*/,
                                                                   te::common::TraverseType travType,
                                                                   const te::common::AccessPolicy accessPolicy) const
{
  return getData(travType, accessPolicy);
}

std::unique_ptr<te::da::DataSet> te::ws::ogc::wms::WMSLayer::getData(const te::da::ObjectIdSet* /*oids*/,
                                                                   te::common::TraverseType travType,
                                                                   const te::common::AccessPolicy accessPolicy) const
{
  return getData(travType, accessPolicy);
}

bool te::ws::ogc::wms::WMSLayer::isValid() const
{
  if(m_datasourceId.empty() || m_getMapRequest.m_layers.empty())
    return false;

  if(m_getMapRequest.m_width == 0 || m_getMapRequest.m_height == 0 || m_getMapRequest.m_format.empty())
    return false;

  te::da::DataSourcePtr ds;
  try
  {
    ds = te::da::GetDataSource(m_datasourceId, true);
  }
  catch(...)
  {
    return false;
  }

  if(ds.get() == nullptr || !ds->isValid() || !ds->isOpened())
    return false;

  return true;
}

void te::ws::ogc::wms::WMSLayer::draw(te::map::Canvas *canvas,
                                      const te::gm::Envelope &bbox, int srid,
                                      const double &scale, bool *cancel)
{
  if(m_rendererType.empty())
    throw te::ws::core::Exception() << te::ErrorDescription((boost::format(TE_TR("Could not draw the WMS layer %1%. The renderer type is empty!")) % getTitle()).str());

  // Try get the defined renderer
  std::unique_ptr<te::map::AbstractRenderer> renderer(te::map::RendererFactory::make(m_rendererType));

  if(renderer.get() == nullptr)
    throw te::ws::core::Exception() << te::ErrorDescription((boost::format(TE_TR("Could not draw the WMS layer %1%. The renderer %2% could not be created!"))  % getTitle() % m_rendererType).str());

  this->setCurrentSRID(srid);

  renderer->draw(this, canvas, bbox, srid, scale, cancel);
}

const std::string &te::ws::ogc::wms::WMSLayer::getType() const
{
  return sm_type;
}

const std::string &te::ws::ogc::wms::WMSLayer::getDataSourceId() const
{
  return m_datasourceId;
}

void te::ws::ogc::wms::WMSLayer::setDataSourceId(const std::string &datasourceId)
{
  m_datasourceId = datasourceId;
}

const std::string &te::ws::ogc::wms::WMSLayer::getRendererType() const
{
  return m_rendererType;
}

void te::ws::ogc::wms::WMSLayer::setRendererType(const std::string &rendererType)
{
  m_rendererType = rendererType;
}

te::ws::ogc::wms::WMSGetMapRequest te::ws::ogc::wms::WMSLayer::getRequest() const
{
  return m_getMapRequest;
}

void te::ws::ogc::wms::WMSLayer::setGetMapRequest(const te::ws::ogc::wms::WMSGetMapRequest &getMapRequest)
{
  m_getMapRequest = getMapRequest;
}

const te::ws::ogc::wms::WMSGetMapResponse te::ws::ogc::wms::WMSLayer::getMap() const
{

  te::da::DataSourcePtr ds;
  try
  {
    ds = te::da::GetDataSource(m_datasourceId, true);
  }
  catch(...)
  {
    return te::ws::ogc::wms::WMSGetMapResponse();
  }

  if(ds.get() == nullptr || !ds->isValid() || !ds->isOpened())
    return te::ws::ogc::wms::WMSGetMapResponse();

  te::ws::ogc::wms::da::DataSource* wmsDataSource = dynamic_cast<te::ws::ogc::wms::da::DataSource*>(ds.get());

  if(wmsDataSource == nullptr)
  {
    return te::ws::ogc::wms::WMSGetMapResponse();
  }

  return wmsDataSource->getMap(m_getMapRequest);
}

const std::string te::ws::ogc::wms::WMSLayer::saveGetMap(const std::string &filename) const
{
  te::da::DataSourcePtr ds;
  try
  {
    ds = te::da::GetDataSource(m_datasourceId, true);
  }
  catch(...)
  {
    return std::string("");
  }

  if(ds.get() == nullptr || !ds->isValid() || !ds->isOpened())
    return std::string("");

  te::ws::ogc::wms::da::DataSource* wmsDataSource = dynamic_cast<te::ws::ogc::wms::da::DataSource*>(ds.get());

  if(wmsDataSource == nullptr)
  {
    return std::string("");
  }

  return wmsDataSource->saveGetMap(m_getMapRequest, filename);
}

const te::ws::ogc::wms::WMSGetFeatureInfoResponse te::ws::ogc::wms::WMSLayer::getFeatureInfo(const te::ws::ogc::wms::WMSGetFeatureInfoRequest &request)
{
  te::da::DataSourcePtr ds;
  try
  {
    ds = te::da::GetDataSource(m_datasourceId, true);
  }
  catch(...)
  {
    return te::ws::ogc::wms::WMSGetFeatureInfoResponse();
  }

  if(ds.get() == nullptr || !ds->isValid() || !ds->isOpened())
    return te::ws::ogc::wms::WMSGetFeatureInfoResponse();

  te::ws::ogc::wms::da::DataSource* wmsDataSource = dynamic_cast<te::ws::ogc::wms::da::DataSource*>(ds.get());

  if(wmsDataSource == nullptr)
  {
    return te::ws::ogc::wms::WMSGetFeatureInfoResponse();
  }

  return wmsDataSource->getFeatureInfo(request);
}