TsCloudDetection.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/unittest/rp/cloud_detection/TsCloudDetection.cpp

  \brief A test suit for the Cloud Detection interface.
*/

// TerraLib
#include "../Config.h"
#include <terralib/dataaccess/datasource/DataSourceFactory.h>
#include <terralib/dataaccess/datasource/DataSourceInfo.h>
#include <terralib/dataaccess/datasource/DataSourceInfoManager.h>
#include <terralib/dataaccess/datasource/DataSourceManager.h>
#include <terralib/memory/DataSet.h>
#include <terralib/memory/DataSetItem.h>
#include <terralib/rp/CloudDetection.h>
#include <terralib/rp.h>
#include <terralib/raster.h>

// Boost
#define BOOST_TEST_NO_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/uuid/uuid_io.hpp>

BOOST_AUTO_TEST_CASE(cloudDetection_test)
{
  /* Openning input raster */

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

  rasterInfo["URI"] = TERRALIB_DATA_DIR "/geotiff/Landsat8_22162_07102015_8bits_rec.tif";
  boost::shared_ptr< te::rst::Raster > cloudRasterPtrPointer ( te::rst::RasterFactory::open(
    rasterInfo));
  BOOST_CHECK(cloudRasterPtrPointer.get());

  boost::shared_ptr< te::rst::Raster > shadowRasterPtrPointer(te::rst::RasterFactory::open(
    rasterInfo));
  BOOST_CHECK(shadowRasterPtrPointer.get());

  /* Creating the algorithm parameters */

  int cloudBand = 2;
  int shadowBand = 1;
  double minCloud = 130;
  double maxCloud = 255;
  double minShadow = 0;
  double maxShadow = 60;

  std::vector<te::rp::Filter::InputParameters::FilterType> vecFilter;
  std::vector<int> vecIt;

  std::unique_ptr<te::rp::CloudDetection> cloudDetection(new te::rp::CloudDetection());

  //run cloud detection operation
  te::rst::Raster* raster = cloudDetection->executeCloudDetection(cloudRasterPtrPointer.get(), shadowRasterPtrPointer.get(), cloudBand, shadowBand,
    minCloud, maxCloud, minShadow, maxShadow, vecFilter, vecIt);

  BOOST_CHECK( raster );

  //check output parameters
  std::string outputdataset = "terralib_unittest_rp_clouddetection.shp";

  BOOST_CHECK(!outputdataset.empty());

  std::string uriStr = TERRALIB_BUILD_PATH "/terralib_unittest_rp/" + outputdataset;

  //check output datasource parameters
  te::da::DataSourceInfoPtr outDSInfo;

  boost::filesystem::path uri(uriStr);

  std::size_t idx = outputdataset.find(".");
  if (idx != std::string::npos)
    outputdataset = outputdataset.substr(0, idx);

  std::string dsinfo("file://" + uri.string());

  // let's include the new datasource in the managers
  boost::uuids::basic_random_generator<boost::mt19937> gen;
  boost::uuids::uuid u = gen();
  std::string id = boost::uuids::to_string(u);

  te::da::DataSourceInfoPtr ds(new te::da::DataSourceInfo);
  ds->setConnInfo(dsinfo);
  ds->setTitle(uri.stem().string());
  ds->setAccessDriver("OGR");
  ds->setType("OGR");
  ds->setDescription("Test Cloud Detection");
  ds->setId(id);

  te::da::DataSourceInfoManager::getInstance().add(ds);
  outDSInfo = ds;

  //output parameters
  std::vector<te::gm::Geometry*> geomVec;
  std::vector< double > geomsValues;

  //vectorize
  raster->vectorize(geomVec, 0, 0, &geomsValues);

  BOOST_CHECK(!geomVec.empty());

  std::unique_ptr<te::da::DataSetType> dsType(new te::da::DataSetType(outputdataset));

  //create id property
  te::dt::SimpleProperty* idProperty = new te::dt::SimpleProperty("id", te::dt::INT32_TYPE);
  dsType->add(idProperty);

  //create geometry property
  te::gm::GeometryProperty* geomProperty = new te::gm::GeometryProperty("geom", raster->getSRID(), te::gm::PolygonType);
  dsType->add(geomProperty);

  //create primary key
  std::string pkName = "pk_id";
  pkName += "_" + outputdataset;
  te::da::PrimaryKey* pk = new te::da::PrimaryKey(pkName, dsType.get());
  pk->add(idProperty);

  std::unique_ptr<te::mem::DataSet> dataSet(new te::mem::DataSet(dsType.get()));

  for (std::size_t t = 0; t < geomVec.size(); ++t)
  {
    //create dataset item
    te::mem::DataSetItem* item = new te::mem::DataSetItem(dataSet.get());

    //set id
    item->setInt32(0, (int)t);

    //set geometry
    item->setGeometry(1, geomVec[t]);

    dataSet->add(item);
  }

  te::da::DataSourcePtr dataSource = te::da::DataSourceManager::getInstance().get(outDSInfo->getId(), outDSInfo->getType(), outDSInfo->getConnInfo());

  //save dataset
  dataSet->moveBeforeFirst();

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

  dataSource->createDataSet(dsType.get(), options);

  dataSource->add(outputdataset, dataSet.get(), options);
}