WCSClient.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/ws/ogc/wcs/client/WCSClient.cpp

  \brief WS Client for OGC WCS

  \author Vinicius Campanha
*/

// LibCURL
#include <curl/curl.h>

// TerraLib
#include "../../../../core/filesystem/FileSystem.h"
#include "../../../../core/translator/Translator.h"
#include "../../../../core/uri/Utils.h"
#include "../../../core/CurlWrapper.h"
#include "../../../core/Exception.h"
#include "WCSClient.h"

//STL
#include <iostream>
#include <string>

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

te::ws::ogc::WCSClient::WCSClient(const std::string usrDataDir, const std::string uri, const std::string version)
  : m_version(version),
    m_uri (uri)
{
  m_dataDir = usrDataDir + "/wcs/";

  m_curl = std::shared_ptr<te::ws::core::CurlWrapper>(new te::ws::core::CurlWrapper());

  if(!m_uri.user().empty() && !m_uri.password().empty())
  {
    m_curl->setAuthenticationMethod(te::ws::core::HTTP_BASIC);
    m_curl->setUsername(m_uri.user());
    m_curl->setPassword(m_uri.password());
  }

  std::string baseUrl = m_uri.scheme() + "://" + m_uri.host();

  if (!m_uri.port().empty())
  {
    baseUrl = baseUrl + ":" + m_uri.port();
  }

  baseUrl = baseUrl + m_uri.path() + "?";

  if (!m_uri.query().empty())
  {
    std::string query = m_uri.query();

    size_t endsWith = query.rfind("&");

    if (endsWith != (query.size() - 1))
    {
      query.append("&");
    }

    baseUrl = baseUrl + query;
  }

  m_uri = te::core::URI(baseUrl);

  if (te::core::FileSystem::isDirectory(usrDataDir) && !te::core::FileSystem::exists(m_dataDir))
    te::core::FileSystem::createDirectories(m_dataDir);
}

te::ws::ogc::WCSClient::~WCSClient() = default;

void te::ws::ogc::WCSClient::updateCapabilities()
{
  std::string url = m_uri.uri();

  if(m_version == "2.0.1")
  {
    url = url + "SERVICE=WCS" + "&VERSION=" + m_version + "&REQUEST=GetCapabilities";
  }
  else
  {
    throw te::common::Exception(TE_TR("WCS version not supported!"));
  }

  m_curl->setTaskMessage(TE_TR("Getting Capabilities"));

  // Request the WCS Capabilities XML file
  std::string xmlPath = te::ws::ogc::WCSClient::makeFileRequest(url, "capabilities.xml");

  try
  {
    // Parse the XML file into a struct
    m_capabilities = m_parser.parseCapabilities(xmlPath);
  }
  catch(te::ws::core::Exception&)
  {
    throw;
  }
}


te::ws::ogc::wcs::CoverageDescription te::ws::ogc::WCSClient::describeCoverage(const std::string coverage)
{

  if(m_descriptionMap.find(coverage) != m_descriptionMap.end())
  {
    return m_descriptionMap[coverage];
  }

  te::ws::ogc::wcs::CoverageDescription describeCoverage;

  std::string url = m_uri.uri();

  if(m_version == "2.0.1")
  {
    url = url + "SERVICE=WCS" + "&VERSION=" + m_version + "&REQUEST=DescribeCoverage&CoverageID=" + coverage;
  }
  else
  {
    throw te::common::Exception(TE_TR("WCS version not supported!"));
  }

  m_curl->setTaskMessage(TE_TR("Getting Coverage Description"));

  // Request the WCS Describe Coverage XML file
  std::string xmlPath = te::ws::ogc::WCSClient::makeFileRequest(url, "describeCoverage.xml");


  try
  {
    // Parse the XML file into a struct
    describeCoverage = m_parser.parseDescribeCoverage(xmlPath);

  }
  catch(te::ws::core::Exception&)
  {
    throw;
  }

  m_descriptionMap[coverage] = describeCoverage;

  return describeCoverage;
}

std::string te::ws::ogc::WCSClient::getFileExtension(const std::string& format) const
{
  std::string fileExtension;

  if(format == "image/tiff")
  {
    fileExtension = ".tif";
  }

  return fileExtension;
}


std::string te::ws::ogc::WCSClient::getCoverage(const te::ws::ogc::wcs::CoverageRequest coverageRequest, te::common::TaskProgress* taskProgress) const
{
  std::string coveragePath;

  std::string url = m_uri.uri();

  if(m_version == "2.0.1")
  {
    url = url + "SERVICE=WCS" + "&VERSION=" + m_version + "&REQUEST=GetCoverage&COVERAGEID=" + coverageRequest.coverageID;

    if(!coverageRequest.format.empty())
      url += "&FORMAT=" + coverageRequest.format;

    if(!coverageRequest.mediaType.empty())
      url += "&MEDIATYPE=" + coverageRequest.mediaType;

    const te::ws::ogc::wcs::EnvelopeWithTimePeriod* envelope = &coverageRequest.envelope;

    std::string x1 = envelope->lowerCorner_X;
    std::string y1 = envelope->lowerCorner_Y;
    std::string x2 = envelope->upperCorner_X;
    std::string y2 = envelope->upperCorner_Y;

    std::string subset1, subset2;

    if(!x1.empty() && !x2.empty())
      subset1 = "&SUBSET=" + envelope->firstLabel + "(" + x1 + (!x1.empty() && !x2.empty()? ",": "") + x2 + ")";

    if(!y1.empty() && !y2.empty())
      subset2 = "&SUBSET=" + envelope->secondLabel + "(" + y1 + (!y1.empty() && !y2.empty()? ",": "") + y2 + ")";

    url += subset1 + subset2;

    if(!envelope->timeLabel.empty())
    {
      url += "&SUBSET=" + envelope->timeLabel + "(" + te::core::URIEncode("\"");

      if(coverageRequest.time.empty())
        url += envelope->endPosition;
      else
        url += coverageRequest.time;

      url += te::core::URIEncode("\"")+ ")";
    }

    for(std::map<std::string, std::string>::const_iterator parameter = coverageRequest.additionalParameters.begin(); parameter != coverageRequest.additionalParameters.end(); parameter++)
    {
      url += "&" + parameter->first + "=" + parameter->second;
    }
  }
  else
  {
    throw te::common::Exception(TE_TR("WCS version not supported!"));
  }

  m_curl->setTaskMessage(TE_TR("Getting Coverage"));

  std::string fileName = coverageRequest.coverageID;

  if(!coverageRequest.time.empty())
    fileName += "_" + coverageRequest.time;

  fileName += getFileExtension(coverageRequest.format);

  try
  {
    coveragePath = makeFileRequest(url, fileName, taskProgress);
  }
  catch(te::ws::core::Exception&)
  {
    throw;
  }

  return coveragePath;
}

std::string te::ws::ogc::WCSClient::makeFileRequest(const std::string url, const std::string fileName, te::common::TaskProgress* taskProgress) const
{
  std::string path = m_dataDir + fileName;

  m_curl->downloadFile(url, path, taskProgress);

  return path;
}

const te::ws::ogc::wcs::Capabilities& te::ws::ogc::WCSClient::getCapabilities() const
{
  return m_capabilities;
}

void te::ws::ogc::WCSClient::setCurlWrapper(te::ws::core::CurlWrapper* curlWrapper)
{
  m_curl.reset(curlWrapper);
}