src/terralib/attributefill/RasterToVector.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 RasterToVector.cpp
 */

#include "../common/progress/TaskProgress.h"
#include "../common/StringUtils.h"

#include "../core/translator/Translator.h"

#include "../dataaccess/dataset/DataSet.h"
#include "../dataaccess/dataset/DataSetAdapter.h"

#include "../dataaccess/dataset/DataSetType.h"
#include "../dataaccess/dataset/DataSetTypeConverter.h"
#include "../dataaccess/dataset/ObjectIdSet.h"
#include "../dataaccess/datasource/DataSource.h"
#include "../dataaccess/datasource/DataSourceCapabilities.h"
#include "../dataaccess/datasource/DataSourceTransactor.h"
#include "../dataaccess/utils/Utils.h"

#include "../datatype/Property.h"
#include "../datatype/StringProperty.h"

#include "../geometry.h"

#include "../memory/DataSetItem.h"

#include "../raster/RasterProperty.h"
#include "../raster/RasterSummaryManager.h"
#include "../raster/Utils.h"

#include "../rp/RasterAttributes.h"
#include "../rp/Texture.h"

#include "../statistics.h"

#include "Exception.h"
#include "RasterToVector.h"
#include "Utils.h"


// STL
#include <map>

// Boost
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>

te::attributefill::RasterToVector::RasterToVector() = default;

void te::attributefill::RasterToVector::setInput(te::rst::Raster* inRaster, te::da::DataSourcePtr inVectorDsrc,
    std::string inVectorName,
    te::da::DataSetTypeConverter* inVectorDsType,
    const te::da::ObjectIdSet* oidSet)
{
  m_inRaster = inRaster;
  m_inVectorDsrc = inVectorDsrc;
  m_inVectorName = inVectorName;
  m_inVectorDsType.reset(inVectorDsType);
  m_oidSet = oidSet;
}

void te::attributefill::RasterToVector::setParams(
    std::vector<unsigned int> bands,
    std::vector<te::stat::StatisticalSummary> statSum,
    bool iteratorByBox,
    bool texture)
{
  m_bands = bands;
  m_statSum = statSum;
  m_iteratorByBox = iteratorByBox;
  m_texture = texture;
}

void te::attributefill::RasterToVector::setOutput(te::da::DataSourcePtr outDsrc,
                                                  std::string dsName)
{
  m_outDsrc = outDsrc;
  m_outDset = dsName;
}

bool te::attributefill::RasterToVector::paramsAreValid()
{
  if(!m_inVectorDsType.get())
    return false;

  if(!m_inVectorDsType->getResult()->hasGeom())
    return false;

  if(m_outDset.empty() || !m_outDsrc.get())
    return false;

  return true;
}

bool te::attributefill::RasterToVector::run()
{
  // Prepare raster
  double resX = m_inRaster->getResolutionX();
  double resY = m_inRaster->getResolutionY();

  te::gm::Envelope* env = m_inRaster->getExtent();

  // Raster Attributes
  te::rp::RasterAttributes* rasterAtt = 0;

  // Prepare vector
  te::gm::GeometryProperty* vectorProp =
      te::da::GetFirstGeomProperty(m_inVectorDsType->getResult());

  std::size_t geomIdx = boost::lexical_cast<std::size_t>(
      m_inVectorDsType->getResult()->getPropertyPosition(
          vectorProp->getName()));

  std::unique_ptr<te::da::DataSet> dataSetVector;

  if(m_oidSet == 0)
    dataSetVector = m_inVectorDsrc->getDataSet(m_inVectorName);
  else
    dataSetVector = m_inVectorDsrc->getDataSet(m_inVectorName, m_oidSet);

  std::unique_ptr<te::da::DataSetAdapter> dsVector(
      te::da::CreateAdapter(dataSetVector.get(), m_inVectorDsType.get()));

  // Parameters to get the percentage of classes by area
  bool percentByArea = false;
  std::vector<std::vector<double> > pixelDistinct;
  std::vector<te::stat::StatisticalSummary>::iterator it = std::find(
      m_statSum.begin(), m_statSum.end(), te::stat::PERCENT_EACH_CLASS_BY_AREA);

  if(it != m_statSum.end())
  {
    std::vector<double> pixelDistinctCurrentBand;

    for(std::size_t b = 0; b < m_bands.size(); ++b)
    {
      getPixelDistinct(*m_inRaster, m_bands[b], pixelDistinctCurrentBand);
      pixelDistinct.push_back(pixelDistinctCurrentBand);
    }
    percentByArea = true;
  }

  // Get output DataSetType.
  std::unique_ptr<te::da::DataSetType> outDsType;
  if(percentByArea)
    outDsType = std::move(getDataSetType(pixelDistinct));
  else
    outDsType = std::move(getDataSetType());

  // Create the output dataset in memory
  std::unique_ptr<te::mem::DataSet> outDataset(new te::mem::DataSet(outDsType.get()));

  // Task progress
  te::common::TaskProgress task("Processing Operation...");
  task.setTotalSteps((int)dsVector->size() * (int)m_statSum.size() *
                     (int)m_bands.size());
  task.useTimer(true);

  // Verify if is necessary to remap
  bool remap = false;

  if(m_inRaster->getSRID() != vectorProp->getSRID())
    remap = true;

  // Start to read the dataSet.
  dsVector->moveBeforeFirst();

  while(dsVector->moveNext())
  {
    te::mem::DataSetItem* outDSetItem = new te::mem::DataSetItem(outDataset.get());

    std::vector<te::dt::Property*> vecProp = m_inVectorDsType->getResult()->getProperties();

    for(std::size_t i = 0; i < vecProp.size(); ++i)
    {
      if(!dsVector->isNull(i))
        outDSetItem->setValue(i, dsVector->getValue(i).release());
    }

    // Geometry
    std::unique_ptr<te::gm::Geometry> geom = dsVector->getGeometry(geomIdx);

    if(!geom->isValid())
      continue;

    if(remap)
      geom->transform(m_inRaster->getSRID());

    // Add Item in DataSet if geom does not intersects the raster envelope and
    // continue to the next dataSet item.
    if(!env->intersects(*geom->getMBR()))
    {
      outDataset->add(outDSetItem);

      if(outDataset->size() == 2000)
      {
        save(outDataset.get(), outDsType.get());
        outDataset->clear();
      }

      continue;
    }

    double area = 0;

    // Values from raster for each band
    std::vector<std::map<double, int > > valuesFromRasterByBand;
    std::vector<std::map<double, double > > percentOfEachClassByArea;
    for(std::size_t band = 0; band < m_bands.size(); ++band)
    {
      std::map<double, int > values1;
      valuesFromRasterByBand.push_back(values1);

      std::map<double, double > values2;
      percentOfEachClassByArea.push_back(values2);
    }

    // Flags
    bool isPoint = false;
    bool isNoDataValue = false;
    std::vector< te::gm::Geometry* > singleGeomsPtrs;

    switch(geom->getGeomTypeId())
    {
      case te::gm::MultiPolygonType:
      {
        if(percentByArea)
          area = ((te::gm::MultiPolygon*)geom.get())->getArea();

        singleGeomsPtrs.clear();
        te::gm::Multi2Single( geom.get(), singleGeomsPtrs );

        const std::size_t n_geom = singleGeomsPtrs.size();

        for(std::size_t n = 0; n < n_geom; ++n)
        {
          assert( singleGeomsPtrs[ n ]->getGeomTypeId() == te::gm::PolygonType );
          te::gm::Polygon* polygon = (te::gm::Polygon*)singleGeomsPtrs[ n ];

          for(std::size_t band = 0; band < m_bands.size(); ++band)
          {
            std::map<double, int> values;

            if(m_iteratorByBox == false)
            {
              rasterAtt->getValuesFromBand(*m_inRaster, m_bands[band], *polygon, values);
            }
            else
            {
              uint32_t minimumRow, minimumColumn, maximumRow, maximumColumn;
              GetMinMaxLineAndColumn(*m_inRaster, *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn);

              GetValuesFromBand(*m_inRaster, m_bands[band], *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn, values);

              if(std::find(m_statSum.begin(), m_statSum.end(), te::stat::PERCENT_EACH_CLASS_BY_AREA) != m_statSum.end())
              {
                std::map<double, double> percents;
                GetPercentOfEachClassByArea(*m_inRaster, m_bands[band], *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn, percents);
                joinMaps(percentOfEachClassByArea[band], percents);
              }
            }

            joinMaps(valuesFromRasterByBand[band], values);
          }
        }

        isPoint = false;

        break;
      }
      case te::gm::PolygonType:
      {
        te::gm::Polygon* polygon = dynamic_cast<te::gm::Polygon*>(geom.get());

        area = polygon->getArea();

        for(std::size_t band = 0; band < m_bands.size(); ++band)
        {
          std::map<double, int> values;

          if(m_iteratorByBox == false)
          {
            rasterAtt->getValuesFromBand(*m_inRaster, m_bands[band], *polygon, values);
          }
          else
          {
            uint32_t minimumRow, minimumColumn, maximumRow, maximumColumn;
            GetMinMaxLineAndColumn(*m_inRaster, *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn);

            GetValuesFromBand(*m_inRaster, m_bands[band], *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn, values);

            if(std::find(m_statSum.begin(), m_statSum.end(), te::stat::PERCENT_EACH_CLASS_BY_AREA) != m_statSum.end())
            {
              std::map<double, double> percents;
              GetPercentOfEachClassByArea(*m_inRaster, m_bands[band], *polygon, minimumRow, minimumColumn, maximumRow, maximumColumn, percents);
              joinMaps(percentOfEachClassByArea[band], percents);
            }
          }

          joinMaps(valuesFromRasterByBand[band], values);
        }

        isPoint = false;

        break;
      }
      case te::gm::MultiPointType:
      {
        te::gm::MultiPoint* mPoint = dynamic_cast<te::gm::MultiPoint*>(geom.get());

        std::size_t n_geom = mPoint->getNumGeometries();

        for(std::size_t n = 0; n < n_geom; ++n)
        {
          te::gm::Point* point = dynamic_cast<te::gm::Point*>(mPoint->getGeometryN(n));

          const double coordX = point->getX();
          const double coordY = point->getY();

          te::gm::Coord2D coord2d =
              m_inRaster->getGrid()->geoToGrid(coordX, coordY);

          int x = te::rst::Round(coord2d.x);
          int y = te::rst::Round(coord2d.y);

          for(std::size_t band = 0; band < m_bands.size(); ++band)
          {
            double noDataValue =
              m_inRaster->getBand(m_bands[band])->getProperty()->m_noDataValue;

            double value = noDataValue;
            if((x >= 0 && x < (int)m_inRaster->getNumberOfColumns()) &&
               (y >= 0 && y < (int)m_inRaster->getNumberOfRows()))
            {
              m_inRaster->getValue(x, y, value, m_bands[band]);
            }

            if(value == noDataValue)
            {
              isNoDataValue = true;
              continue;
            }

            std::map<double, int> values;

            ++values[value];

            joinMaps(valuesFromRasterByBand[band], values);
          }

          isPoint = true;
        }
        break;
      }
      case te::gm::PointType:
      {
        te::gm::Point* point = dynamic_cast<te::gm::Point*>(geom.get());

        const double coordX = point->getX();
        const double coordY = point->getY();

        te::gm::Coord2D coord2d =
            m_inRaster->getGrid()->geoToGrid(coordX, coordY);

        int x = te::rst::Round(coord2d.x);
        int y = te::rst::Round(coord2d.y);

        for(std::size_t band = 0; band < m_bands.size(); ++band)
        {
          double noDataValue = m_inRaster->getBand(m_bands[band])->getProperty()->m_noDataValue;

          double value = noDataValue;
          if((x >= 0 && x < (int)m_inRaster->getNumberOfColumns()) &&
             (y >= 0 && y < (int)m_inRaster->getNumberOfRows()))
          {
            m_inRaster->getValue(x, y, value, m_bands[band]);
          }

          if(value == noDataValue)
          {
            isNoDataValue = true;
            continue;
          }

          std::map<double, int> values;

          ++values[value];

          joinMaps(valuesFromRasterByBand[band], values);
        }

        isPoint = true;

        break;
      }
      default:
        continue;
    }

    if(isNoDataValue)
    {
      outDataset->add(outDSetItem);

      if(outDataset->size() == 2000)
      {
        save(outDataset.get(), outDsType.get());
        outDataset->clear();
      }

      continue;
    }

    std::size_t init_index =
        m_inVectorDsType->getResult()->getProperties().size();

    // Statistics set value
    if(!isPoint)
    {
      for(std::size_t band = 0; band < valuesFromRasterByBand.size(); ++band)
      {
        te::stat::NumericStatisticalSummary summary;

        te::stat::GetNumericStatisticalSummary(valuesFromRasterByBand[band], summary);

        if(percentOfEachClassByArea[band].empty())
          te::stat::GetPercentOfEachClassByArea(valuesFromRasterByBand[band], resX, resY, area, summary);
        else
          summary.m_percentEachClass = percentOfEachClassByArea[band];

        std::size_t current_index = init_index + m_statSum.size();

        for(std::size_t it = 0, i = init_index; i < current_index; ++it, ++i)
        {
          te::stat::StatisticalSummary ss = m_statSum[it];

          switch(ss)
          {
            case te::stat::MIN_VALUE:
              outDSetItem->setDouble(i, summary.m_minVal);
              break;
            case te::stat::MAX_VALUE:
              outDSetItem->setDouble(i, summary.m_maxVal);
              break;
            case te::stat::COUNT:
              outDSetItem->setDouble(i, summary.m_count);
              break;
            case te::stat::VALID_COUNT:
              outDSetItem->setDouble(i, summary.m_validCount);
              break;
            case te::stat::MEAN:
              outDSetItem->setDouble(i, summary.m_mean);
              break;
            case te::stat::SUM:
              outDSetItem->setDouble(i, summary.m_sum);
              break;
            case te::stat::STANDARD_DEVIATION:
              outDSetItem->setDouble(i, summary.m_stdDeviation);
              break;
            case te::stat::VARIANCE:
              outDSetItem->setDouble(i, summary.m_variance);
              break;
            case te::stat::SKEWNESS:
              outDSetItem->setDouble(i, summary.m_skewness);
              break;
            case te::stat::KURTOSIS:
              outDSetItem->setDouble(i, summary.m_kurtosis);
              break;
            case te::stat::AMPLITUDE:
              outDSetItem->setDouble(i, summary.m_amplitude);
              break;
            case te::stat::MEDIAN:
              outDSetItem->setDouble(i, summary.m_median);
              break;
            case te::stat::VAR_COEFF:
              outDSetItem->setDouble(i, summary.m_varCoeff);
              break;
            case te::stat::MODE:
            {
              std::string mode;

              if(!summary.m_mode.empty())
              {
                mode = boost::lexical_cast<std::string>(summary.m_mode[0]);
                for(std::size_t m = 1; m < summary.m_mode.size(); ++m)
                {
                  mode += ",";
                  mode += boost::lexical_cast<std::string>(summary.m_mode[m]);
                }
                outDSetItem->setString(i, mode);
              }
              else
              {
                outDSetItem->setString(i, "");
              }
              break;
            }
            case te::stat::PERCENT_EACH_CLASS_BY_AREA:
            {
              std::vector<double>::iterator itPixelDistinct =
                  pixelDistinct[band].begin();

              std::map<double, double>::iterator itPercent =
                  summary.m_percentEachClass.begin();

              while(itPixelDistinct != pixelDistinct[band].end())
              {
                if(itPercent != summary.m_percentEachClass.end())
                {
                  std::string name = outDSetItem->getPropertyName(i);
                  std::vector<std::string> splitString;
                  boost::split(splitString, name, boost::is_any_of("_"));
                  if(splitString[1] ==
                     boost::lexical_cast<std::string>(itPercent->first))
                  {
                    outDSetItem->setDouble(i, itPercent->second);
                    ++itPercent;
                  }
                  else
                  {
                    outDSetItem->setDouble(i, 0);
                  }
                }
                else
                {
                  outDSetItem->setDouble(i, 0);
                }
                ++itPixelDistinct;
                ++i;
              }
              current_index += pixelDistinct[band].size() - 1;
              break;
            }
            default:
              continue;
          }

          if (task.isActive() == false)
            throw te::attributefill::Exception(TE_TR("Operation canceled!"));

          task.pulse();
        }

        // texture
        std::vector<te::rp::Texture> metrics;
        init_index = current_index;

        if(m_texture == true)
        {
          metrics = getTexture(m_inRaster, geom.get(), m_bands[band]);
          current_index += 5;
          for(std::size_t t = 0, i = init_index; i < current_index; ++t, ++i)
          {
            switch(t)
            {
              case 0:
              {
                outDSetItem->setDouble(i, metrics[band].m_contrast);
                break;
              }
              case 1:
              {
                outDSetItem->setDouble(i, metrics[band].m_dissimilarity);
                break;
              }
              case 2:
              {
                outDSetItem->setDouble(i, metrics[band].m_energy);
                break;
              }
              case 3:
              {
                outDSetItem->setDouble(i, metrics[band].m_entropy);
                break;
              }
              case 4:
              {
                outDSetItem->setDouble(i, metrics[band].m_homogeneity);
                break;
              }
            }
          }
        }

        init_index = current_index;
      }
    }
    else
    {
      for(std::size_t i = 0; i < valuesFromRasterByBand.size(); ++i)
      {
        std::map<double, int>::iterator it = valuesFromRasterByBand[i].begin();

        while(it != valuesFromRasterByBand[i].end())
        {
          outDSetItem->setDouble(init_index, it->first);

          ++it;
        }
      }
    }

    outDataset->add(outDSetItem);

    if(outDataset->size() == 2000)
    {
      save(outDataset.get(), outDsType.get());
      outDataset->clear();
    }

    if(task.isActive() == false)
      throw te::attributefill::Exception(TE_TR("Operation canceled!"));
  }

  if(!outDataset->isEmpty())
    save(outDataset.get(), outDsType.get());

  return true;
}

void te::attributefill::RasterToVector::getPixelDistinct(
  te::rst::Raster& inputRaster, unsigned int inputRasterBand,
  std::vector<double>& values)
{
  values.clear();

  const unsigned int nCols = inputRaster.getNumberOfColumns();
  const unsigned int nRows = inputRaster.getNumberOfRows();
  unsigned int col = 0;
  unsigned int row = 0;
  std::set<double> valuesSet;
  double centerValue = 0;

  const te::rst::Band& inputBand = *inputRaster.getBand(inputRasterBand);

  const double inputBandDataValue = inputBand.getProperty()->m_noDataValue;

  for (row = 0; row < nRows; ++row)
  {
    for (col = 0; col < nCols; ++col)
    {
      inputBand.getValue(col, row, centerValue);

      if (centerValue != inputBandDataValue)
      {
        if (valuesSet.find(centerValue) == valuesSet.end())
          valuesSet.insert(centerValue);
      }
    }
  }

  std::set<double>::iterator valuesIt = valuesSet.begin();
  while (valuesIt != valuesSet.end())
  {
    values.push_back(*valuesIt);
    ++valuesIt;
  }
}

std::unique_ptr<te::da::DataSetType> te::attributefill::RasterToVector::getDataSetType(
    std::vector<std::vector<double> > pixelDistinct)
{
  std::unique_ptr<te::da::DataSetType> outdsType(new te::da::DataSetType(*m_inVectorDsType->getResult()));
  outdsType->setCompositeName(m_outDset);
  outdsType->setName(m_outDset);
  outdsType->setTitle(m_outDset);

  te::da::PrimaryKey* pk = outdsType->getPrimaryKey();
  pk->setName(outdsType->getName() + "_pkey");

  for(std::size_t b = 0; b < m_bands.size(); ++b)
  {
    if(!m_statSum.empty() || m_texture == true)
    {
      for(std::size_t i = 0; i < m_statSum.size(); ++i)
      {
        te::dt::SimpleProperty* prop;
        switch(m_statSum[i])
        {
          case 0:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Min_Value",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 1:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Max_Value",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 2:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Mean",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 3:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Sum",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 4:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Count",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 5:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Valid_Count",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 6:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Standard_Deviation",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 7:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Variance",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 8:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Skewness",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 9:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Kurtosis",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 10:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Amplitude",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 11:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Median",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 12:
            prop = new te::dt::SimpleProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                    "_Var_Coeff",
                te::dt::DOUBLE_TYPE);
            outdsType->add(prop);
            break;
          case 13:
            prop = new te::dt::StringProperty(
                "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Mode");
            outdsType->add(prop);
            break;
          case 14:
          {
            std::vector<double>::iterator it = pixelDistinct[b].begin();
            while(it != pixelDistinct[b].end())
            {
              prop = new te::dt::SimpleProperty(
                  "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_" +
                      boost::lexical_cast<std::string>(*it),
                  te::dt::DOUBLE_TYPE);
              outdsType->add(prop);
              ++it;
            }
          }
          break;
          default:
            continue;
        }
      }
      if(m_texture)
      {
        te::dt::SimpleProperty* propContrast = new te::dt::SimpleProperty(
            "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Contrast",
            te::dt::DOUBLE_TYPE);
        outdsType->add(propContrast);

        te::dt::SimpleProperty* propDissimilarity = new te::dt::SimpleProperty(
            "B" + boost::lexical_cast<std::string>(m_bands[b]) +
                "_Dissimilarity",
            te::dt::DOUBLE_TYPE);
        outdsType->add(propDissimilarity);

        te::dt::SimpleProperty* propEnergy = new te::dt::SimpleProperty(
            "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Energy",
            te::dt::DOUBLE_TYPE);
        outdsType->add(propEnergy);

        te::dt::SimpleProperty* propEntropy = new te::dt::SimpleProperty(
            "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Entropy",
            te::dt::DOUBLE_TYPE);
        outdsType->add(propEntropy);

        te::dt::SimpleProperty* propHomogeneity = new te::dt::SimpleProperty(
            "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Homogeneity",
            te::dt::DOUBLE_TYPE);
        outdsType->add(propHomogeneity);
      }
    }
    else
    {
      te::dt::SimpleProperty* propValue = new te::dt::SimpleProperty(
          "B" + boost::lexical_cast<std::string>(m_bands[b]) + "_Value",
          te::dt::DOUBLE_TYPE);
      outdsType->add(propValue);
    }
  }

  return outdsType;
}

std::vector<te::rp::Texture> te::attributefill::RasterToVector::getTexture(
    te::rst::Raster* rst, te::gm::Geometry* geom, int band)
{
  te::rp::RasterAttributes rattributes;
  std::vector<te::rp::Texture> textureVec;

  te::gm::Polygon* polygon;

  if(geom->getGeomTypeId() == te::gm::MultiPolygonType)
  {
    te::gm::MultiPolygon* mPolygon = dynamic_cast<te::gm::MultiPolygon*>(geom);
    polygon = dynamic_cast<te::gm::Polygon*>(mPolygon->getGeometryN(0));
  }
  else
  {
    polygon = dynamic_cast<te::gm::Polygon*>(geom);
  }

  // Retrieving the maximum and minimum GL values of the band.
  double minPixel, maxPixel;
  te::rst::GetDataTypeRanges(rst->getBandDataType(band), minPixel, maxPixel);

  if((maxPixel - minPixel) > 255)
  {  
    const te::rst::RasterSummary* rsMin = te::rst::RasterSummaryManager::getInstance().get(rst, te::rst::SUMMARY_MIN, true);
    const te::rst::RasterSummary* rsMax = te::rst::RasterSummaryManager::getInstance().get(rst, te::rst::SUMMARY_MAX, true);
    const std::complex<double>* cmin = rsMin->at(band).m_minVal;
    const std::complex<double>* cmax = rsMax->at(band).m_maxVal;

    minPixel = cmin->real();
    maxPixel = cmax->real();
  }

  boost::numeric::ublas::matrix<double> glcm =
      rattributes.getGLCM(*rst, band, 1, 1, *polygon, minPixel, maxPixel);
  te::rp::Texture metrics = rattributes.getGLCMMetrics(glcm);
  textureVec.push_back(metrics);

  return textureVec;
}

void te::attributefill::RasterToVector::joinMaps(std::map<double, int>& mainMap, std::map<double, int>& newMap)
{
  std::map<double, int>::iterator it_newMap = newMap.begin();

  while(it_newMap != newMap.end())
  {
    mainMap[it_newMap->first] += it_newMap->second;

    ++it_newMap;
  }
}

void te::attributefill::RasterToVector::joinMaps(std::map<double, double>& mainMap, std::map<double, double>& newMap)
{
  std::map<double, double>::iterator it_newMap = newMap.begin();

  while(it_newMap != newMap.end())
  {
    mainMap[it_newMap->first] += it_newMap->second;

    ++it_newMap;
  }
}

void te::attributefill::RasterToVector::save(te::da::DataSet* result, te::da::DataSetType* outDsType)
{
  // do any adaptation necessary to persist the output dataset
  te::da::DataSetTypeConverter* converter = new te::da::DataSetTypeConverter(outDsType, m_outDsrc->getCapabilities());
  te::da::DataSetType* dsTypeResult = converter->getResult();

  std::unique_ptr<te::da::DataSourceTransactor> t = m_outDsrc->getTransactor();

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

  try
  {
    t->begin();

    std::string dsTypeName = outDsType->getName();
    std::vector<std::string> dataSetNames = t->getDataSetNames();
    bool create = true;

    for (std::size_t i = 0; i < dataSetNames.size(); ++i)
    {
      std::vector<std::string> tok;
      te::common::Tokenize(dataSetNames[i], tok, ".");

      std::string temp_dsName;

      if (tok.size() > 1)
        temp_dsName = tok[1];
      else
        temp_dsName = dataSetNames[i];

      if (dsTypeName == temp_dsName)
      {
        create = false;
      }
    }

    if (create)
    {
      // create the dataset
      t->createDataSet(dsTypeResult, options);
    }

    // copy from memory to output datasource
    result->moveBeforeFirst();
    t->add(dsTypeName, result, options);

    t->commit();
  }
  catch(te::common::Exception& e)
  {
    t->rollBack();
    throw e;
  }
  catch(std::exception& e)
  {
    t->rollBack();
    throw e;
  }
}